Просмотр архива Сервис хранения кода.


/**
 * SyntaxHighlighter
 * http://alexgorbatchev.com/SyntaxHighlighter
 *
 * SyntaxHighlighter is donationware. If you are using it, please donate.
 * http://alexgorbatchev.com/SyntaxHighlighter/donate.html
 *
 * @version
 * 3.0.83 (July 02 2010)
 * 
 * @copyright
 * Copyright (C) 2004-2010 Alex Gorbatchev.
 *
 * @license
 * Dual licensed under the MIT and GPL licenses.
 */
//
// Begin anonymous function. This is used to contain local scope variables without polutting global scope.
//
var SyntaxHighlighter = function() { 

// CommonJS
if (typeof(require) != 'undefined' && typeof(XRegExp) == 'undefined')
{
    XRegExp = require('XRegExp').XRegExp;
}

// Shortcut object which will be assigned to the SyntaxHighlighter variable.
// This is a shorthand for local reference in order to avoid long namespace 
// references to SyntaxHighlighter.whatever...
var sh = {
    defaults : {
        /** Additional CSS class names to be added to highlighter elements. */
        'class-name' : '',
        
        /** First line number. */
        'first-line' : 1,
        
        /**
         * Pads line numbers. Possible values are:
         *
         *   false - don't pad line numbers.
         *   true  - automaticaly pad numbers with minimum required number of leading zeroes.
         *   [int] - length up to which pad line numbers.
         */
        'pad-line-numbers' : false,
        
        /** Lines to highlight. */
        'highlight' : null,
        
        /** Title to be displayed above the code block. */
        'title' : null,
        
        /** Enables or disables smart tabs. */
        'smart-tabs' : true,
        
        /** Gets or sets tab size. */
        'tab-size' : 4,
        
        /** Enables or disables gutter. */
        'gutter' : true,
        
        /** Enables or disables toolbar. */
        'toolbar' : true,
        
        /** Enables quick code copy and paste from double click. */
        'quick-code' : true,
        
        /** Forces code view to be collapsed. */
        'collapse' : false,
        
        /** Enables or disables automatic links. */
        'auto-links' : true,
        
        /** Gets or sets light mode. Equavalent to turning off gutter and toolbar. */
        'light' : false,
        
        'html-script' : false
    },
    
    config : {
        space : '&nbsp;',
        
        /** Enables use of <SCRIPT type="syntaxhighlighter" /> tags. */
        useScriptTags : true,
        
        /** Blogger mode flag. */
        bloggerMode : false,
        
        stripBrs : false,
        
        /** Name of the tag that SyntaxHighlighter will automatically look for. */
        tagName : 'pre',
        
        strings : {
            expandSource : 'expand source',
            help : '?',
            alert: 'SyntaxHighlighternn',
            noBrush : 'Can't find brush for: ',
            brushNotHtmlScript : 'Brush wasn't configured for html-script option: ',
            
            // this is populated by the build script
            aboutDialog : '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><title>About SyntaxHighlighter</title></head><body style="font-family:Geneva,Arial,Helvetica,sans-serif;background-color:#fff;color:#000;font-size:1em;text-align:center;"><div style="text-align:center;margin-top:1.5em;"><div style="font-size:xx-large;">SyntaxHighlighter</div><div style="font-size:.75em;margin-bottom:3em;"><div>version 3.0.83 (July 02 2010)</div><div><a href="http://alexgorbatchev.com/SyntaxHighlighter" target="_blank" style="color:#005896">http://alexgorbatchev.com/SyntaxHighlighter</a></div><div>JavaScript code syntax highlighter.</div><div>Copyright 2004-2010 Alex Gorbatchev.</div></div><div>If you like this script, please <a href="https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=2930402" style="color:#005896">donate</a> to <br/>keep development active!</div></div></body></html>'
        }
    },
    
    /** Internal 'global' variables. */
    vars : {
        discoveredBrushes : null,
        highlighters : {}
    },
    
    /** This object is populated by user included external brush files. */
    brushes : {},

    /** Common regular expressions. */
    regexLib : {
        multiLineCComments            : //*[sS]*?*//gm,
        singleLineCComments            : ///.*$/gm,
        singleLinePerlComments        : /#.*$/gm,
        doubleQuotedString            : /"([^\"n]|\.)*"/g,
        singleQuotedString            : /'([^\'n]|\.)*'/g,
        multiLineDoubleQuotedString    : new XRegExp('"([^\\"]|\\.)*"', 'gs'),
        multiLineSingleQuotedString    : new XRegExp("'([^\\']|\\.)*'", 'gs'),
        xmlComments                    : /(&lt;|<)!--[sS]*?--(&gt;|>)/gm,
        url                            : /w+://[w-./?%&=:@;]*/g,
        
        /** <?= ?> tags. */
        phpScriptTags                 : { left: /(&lt;|<)?=?/g, right: /?(&gt;|>)/g },
        
        /** <%= %> tags. */
        aspScriptTags                : { left: /(&lt;|<)%=?/g, right: /%(&gt;|>)/g },
        
        /** <script></script> tags. */
        scriptScriptTags            : { left: /(&lt;|<)s*script.*?(&gt;|>)/gi, right: /(&lt;|<)/s*scripts*(&gt;|>)/gi }
    },

    toolbar: {
        /**
         * Generates HTML markup for the toolbar.
         * @param {Highlighter} highlighter Highlighter instance.
         * @return {String} Returns HTML markup.
         */
        getHtml: function(highlighter)
        {
            var html = '<div class="toolbar">',
                items = sh.toolbar.items,
                list = items.list
                ;
            
            function defaultGetHtml(highlighter, name)
            {
                return sh.toolbar.getButtonHtml(highlighter, name, sh.config.strings[name]);
            };
            
            for (var i = 0; i < list.length; i++)
                html += (items[list[i]].getHtml || defaultGetHtml)(highlighter, list[i]);
            
            html += '</div>';
            
            return html;
        },
        
        /**
         * Generates HTML markup for a regular button in the toolbar.
         * @param {Highlighter} highlighter Highlighter instance.
         * @param {String} commandName        Command name that would be executed.
         * @param {String} label            Label text to display.
         * @return {String}                    Returns HTML markup.
         */
        getButtonHtml: function(highlighter, commandName, label)
        {
            return '<span><a href="#" class="toolbar_item'
                + ' command_' + commandName
                + ' ' + commandName
                + '">' + label + '</a></span>'
                ;
        },
        
        /**
         * Event handler for a toolbar anchor.
         */
        handler: function(e)
        {
            var target = e.target,
                className = target.className || ''
                ;

            function getValue(name)
            {
                var r = new RegExp(name + '_(\w+)'),
                    match = r.exec(className)
                    ;

                return match ? match[1] : null;
            };
            
            var highlighter = getHighlighterById(findParentElement(target, '.syntaxhighlighter').id),
                commandName = getValue('command')
                ;
            
            // execute the toolbar command
            if (highlighter && commandName)
                sh.toolbar.items[commandName].execute(highlighter);

            // disable default A click behaviour
            e.preventDefault();
        },
        
        /** Collection of toolbar items. */
        items : {
            // Ordered lis of items in the toolbar. Can't expect `for (var n in items)` to be consistent.
            list: ['expandSource', 'help'],

            expandSource: {
                getHtml: function(highlighter)
                {
                    if (highlighter.getParam('collapse') != true)
                        return '';
                        
                    var title = highlighter.getParam('title');
                    return sh.toolbar.getButtonHtml(highlighter, 'expandSource', title ? title : sh.config.strings.expandSource);
                },
            
                execute: function(highlighter)
                {
                    var div = getHighlighterDivById(highlighter.id);
                    removeClass(div, 'collapsed');
                }
            },

            /** Command to display the about dialog window. */
            help: {
                execute: function(highlighter)
                {    
                    var wnd = popup('', '_blank', 500, 250, 'scrollbars=0'),
                        doc = wnd.document
                        ;
                    
                    doc.write(sh.config.strings.aboutDialog);
                    doc.close();
                    wnd.focus();
                }
            }
        }
    },

    /**
     * Finds all elements on the page which should be processes by SyntaxHighlighter.
     *
     * @param {Object} globalParams        Optional parameters which override element's 
     *                                     parameters. Only used if element is specified.
     * 
     * @param {Object} element    Optional element to highlight. If none is
     *                             provided, all elements in the current document 
     *                             are returned which qualify.
     *
     * @return {Array}    Returns list of <code>{ target: DOMElement, params: Object }</code> objects.
     */
    findElements: function(globalParams, element)
    {
        var elements = element ? [element] : toArray(document.getElementsByTagName(sh.config.tagName)), 
            conf = sh.config,
            result = []
            ;

        // support for <SCRIPT TYPE="syntaxhighlighter" /> feature
        if (conf.useScriptTags)
            elements = elements.concat(getSyntaxHighlighterScriptTags());

        if (elements.length === 0) 
            return result;
    
        for (var i = 0; i < elements.length; i++) 
        {
            var item = {
                target: elements[i], 
                // local params take precedence over globals
                params: merge(globalParams, parseParams(elements[i].className))
            };

            if (item.params['brush'] == null)
                continue;
                
            result.push(item);
        }
        
        return result;
    },

    /**
     * Shorthand to highlight all elements on the page that are marked as 
     * SyntaxHighlighter source code.
     * 
     * @param {Object} globalParams        Optional parameters which override element's 
     *                                     parameters. Only used if element is specified.
     * 
     * @param {Object} element    Optional element to highlight. If none is
     *                             provided, all elements in the current document 
     *                             are highlighted.
     */ 
    highlight: function(globalParams, element)
    {
        var elements = this.findElements(globalParams, element),
            propertyName = 'innerHTML', 
            highlighter = null,
            conf = sh.config
            ;

        if (elements.length === 0) 
            return;
    
        for (var i = 0; i < elements.length; i++) 
        {
            var element = elements[i],
                target = element.target,
                params = element.params,
                brushName = params.brush,
                code
                ;

            if (brushName == null)
                continue;

            // Instantiate a brush
            if (params['html-script'] == 'true' || sh.defaults['html-script'] == true) 
            {
                highlighter = new sh.HtmlScript(brushName);
                brushName = 'htmlscript';
            }
            else
            {
                var brush = findBrush(brushName);
                
                if (brush)
                    highlighter = new brush();
                else
                    continue;
            }
            
            code = target[propertyName];
            
            // remove CDATA from <SCRIPT/> tags if it's present
            if (conf.useScriptTags)
                code = stripCData(code);
                
            // Inject title if the attribute is present
            if ((target.title || '') != '')
                params.title = target.title;
                
            params['brush'] = brushName;
            highlighter.init(params);
            element = highlighter.getDiv(code);
            
            // carry over ID
            if ((target.id || '') != '')
                element.id = target.id;
            
            target.parentNode.replaceChild(element, target);
        }
    },

    /**
     * Main entry point for the SyntaxHighlighter.
     * @param {Object} params Optional params to apply to all highlighted elements.
     */
    all: function(params)
    {
        attachEvent(
            window,
            'load',
            function() { sh.highlight(params); }
        );
    }
}; // end of sh

sh['all']            = sh.all;
sh['highlight']        = sh.highlight;

/**
 * Checks if target DOM elements has specified CSS class.
 * @param {DOMElement} target Target DOM element to check.
 * @param {String} className Name of the CSS class to check for.
 * @return {Boolean} Returns true if class name is present, false otherwise.
 */
function hasClass(target, className)
{
    return target.className.indexOf(className) != -1;
};

/**
 * Adds CSS class name to the target DOM element.
 * @param {DOMElement} target Target DOM element.
 * @param {String} className New CSS class to add.
 */
function addClass(target, className)
{
    if (!hasClass(target, className))
        target.className += ' ' + className;
};

/**
 * Removes CSS class name from the target DOM element.
 * @param {DOMElement} target Target DOM element.
 * @param {String} className CSS class to remove.
 */
function removeClass(target, className)
{
    target.className = target.className.replace(className, '');
};

/**
 * Converts the source to array object. Mostly used for function arguments and 
 * lists returned by getElementsByTagName() which aren't Array objects.
 * @param {List} source Source list.
 * @return {Array} Returns array.
 */
function toArray(source)
{
    var result = [];
    
    for (var i = 0; i < source.length; i++) 
        result.push(source[i]);
        
    return result;
};

/**
 * Splits block of text into lines.
 * @param {String} block Block of text.
 * @return {Array} Returns array of lines.
 */
function splitLines(block)
{
    return block.split('n');
}

/**
 * Generates HTML ID for the highlighter.
 * @param {String} highlighterId Highlighter ID.
 * @return {String} Returns HTML ID.
 */
function getHighlighterId(id)
{
    var prefix = 'highlighter_';
    return id.indexOf(prefix) == 0 ? id : prefix + id;
};

/**
 * Finds Highlighter instance by ID.
 * @param {String} highlighterId Highlighter ID.
 * @return {Highlighter} Returns instance of the highlighter.
 */
function getHighlighterById(id)
{
    return sh.vars.highlighters[getHighlighterId(id)];
};

/**
 * Finds highlighter's DIV container.
 * @param {String} highlighterId Highlighter ID.
 * @return {Element} Returns highlighter's DIV element.
 */
function getHighlighterDivById(id)
{
    return document.getElementById(getHighlighterId(id));
};

/**
 * Stores highlighter so that getHighlighterById() can do its thing. Each
 * highlighter must call this method to preserve itself.
 * @param {Highilghter} highlighter Highlighter instance.
 */
function storeHighlighter(highlighter)
{
    sh.vars.highlighters[getHighlighterId(highlighter.id)] = highlighter;
};

/**
 * Looks for a child or parent node which has specified classname.
 * Equivalent to jQuery's $(container).find(".className")
 * @param {Element} target Target element.
 * @param {String} search Class name or node name to look for.
 * @param {Boolean} reverse If set to true, will go up the node tree instead of down.
 * @return {Element} Returns found child or parent element on null.
 */
function findElement(target, search, reverse /* optional */)
{
    if (target == null)
        return null;
        
    var nodes            = reverse != true ? target.childNodes : [ target.parentNode ],
        propertyToFind    = { '#' : 'id', '.' : 'className' }[search.substr(0, 1)] || 'nodeName',
        expectedValue,
        found
        ;

    expectedValue = propertyToFind != 'nodeName'
        ? search.substr(1)
        : search.toUpperCase()
        ;
        
    // main return of the found node
    if ((target[propertyToFind] || '').indexOf(expectedValue) != -1)
        return target;
    
    for (var i = 0; nodes && i < nodes.length && found == null; i++)
        found = findElement(nodes[i], search, reverse);
    
    return found;
};

/**
 * Looks for a parent node which has specified classname.
 * This is an alias to <code>findElement(container, className, true)</code>.
 * @param {Element} target Target element.
 * @param {String} className Class name to look for.
 * @return {Element} Returns found parent element on null.
 */
function findParentElement(target, className)
{
    return findElement(target, className, true);
};

/**
 * Finds an index of element in the array.
 * @ignore
 * @param {Object} searchElement
 * @param {Number} fromIndex
 * @return {Number} Returns index of element if found; -1 otherwise.
 */
function indexOf(array, searchElement, fromIndex)
{
    fromIndex = Math.max(fromIndex || 0, 0);

    for (var i = fromIndex; i < array.length; i++)
        if(array[i] == searchElement)
            return i;
    
    return -1;
};

/**
 * Generates a unique element ID.
 */
function guid(prefix)
{
    return (prefix || '') + Math.round(Math.random() * 1000000).toString();
};

/**
 * Merges two objects. Values from obj2 override values in obj1.
 * Function is NOT recursive and works only for one dimensional objects.
 * @param {Object} obj1 First object.
 * @param {Object} obj2 Second object.
 * @return {Object} Returns combination of both objects.
 */
function merge(obj1, obj2)
{
    var result = {}, name;

    for (name in obj1) 
        result[name] = obj1[name];
    
    for (name in obj2) 
        result[name] = obj2[name];
        
    return result;
};

/**
 * Attempts to convert string to boolean.
 * @param {String} value Input string.
 * @return {Boolean} Returns true if input was "true", false if input was "false" and value otherwise.
 */
function toBoolean(value)
{
    var result = { "true" : true, "false" : false }[value];
    return result == null ? value : result;
};

/**
 * Opens up a centered popup window.
 * @param {String} url        URL to open in the window.
 * @param {String} name        Popup name.
 * @param {int} width        Popup width.
 * @param {int} height        Popup height.
 * @param {String} options    window.open() options.
 * @return {Window}            Returns window instance.
 */
function popup(url, name, width, height, options)
{
    var x = (screen.width - width) / 2,
        y = (screen.height - height) / 2
        ;
        
    options +=    ', left=' + x + 
                ', top=' + y +
                ', width=' + width +
                ', height=' + height
        ;
    options = options.replace(/^,/, '');

    var win = window.open(url, name, options);
    win.focus();
    return win;
};

/**
 * Adds event handler to the target object.
 * @param {Object} obj        Target object.
 * @param {String} type        Name of the event.
 * @param {Function} func    Handling function.
 */
function attachEvent(obj, type, func, scope)
{
    function handler(e)
    {
        e = e || window.event;
        
        if (!e.target)
        {
            e.target = e.srcElement;
            e.preventDefault = function()
            {
                this.returnValue = false;
            };
        }
            
        func.call(scope || window, e);
    };
    
    if (obj.attachEvent) 
    {
        obj.attachEvent('on' + type, handler);
    }
    else 
    {
        obj.addEventListener(type, handler, false);
    }
};

/**
 * Displays an alert.
 * @param {String} str String to display.
 */
function alert(str)
{
    window.alert(sh.config.strings.alert + str);
};

/**
 * Finds a brush by its alias.
 *
 * @param {String} alias        Brush alias.
 * @param {Boolean} showAlert    Suppresses the alert if false.
 * @return {Brush}                Returns bursh constructor if found, null otherwise.
 */
function findBrush(alias, showAlert)
{
    var brushes = sh.vars.discoveredBrushes,
        result = null
        ;
    
    if (brushes == null) 
    {
        brushes = {};
        
        // Find all brushes
        for (var brush in sh.brushes) 
        {
            var info = sh.brushes[brush],
                aliases = info.aliases
                ;
            
            if (aliases == null) 
                continue;
            
            // keep the brush name
            info.brushName = brush.toLowerCase();
            
            for (var i = 0; i < aliases.length; i++) 
                brushes[aliases[i]] = brush;
        }
        
        sh.vars.discoveredBrushes = brushes;
    }
    
    result = sh.brushes[brushes[alias]];

    if (result == null && showAlert != false)
        alert(sh.config.strings.noBrush + alias);
    
    return result;
};

/**
 * Executes a callback on each line and replaces each line with result from the callback.
 * @param {Object} str            Input string.
 * @param {Object} callback        Callback function taking one string argument and returning a string.
 */
function eachLine(str, callback)
{
    var lines = splitLines(str);
    
    for (var i = 0; i < lines.length; i++)
        lines[i] = callback(lines[i], i);
        
    return lines.join('n');
};

/**
 * This is a special trim which only removes first and last empty lines
 * and doesn't affect valid leading space on the first line.
 * 
 * @param {String} str   Input string
 * @return {String}      Returns string without empty first and last lines.
 */
function trimFirstAndLastLines(str)
{
    return str.replace(/^[ ]*[n]+|[n]*[ ]*$/g, '');
};

/**
 * Parses key/value pairs into hash object.
 * 
 * Understands the following formats:
 * - name: word;
 * - name: [word, word];
 * - name: "string";
 * - name: 'string';
 * 
 * For example:
 *   name1: value; name2: [value, value]; name3: 'value'
 *   
 * @param {String} str    Input string.
 * @return {Object}       Returns deserialized object.
 */
function parseParams(str)
{
    var match, 
        result = {},
        arrayRegex = new XRegExp("^\[(?<values>(.*?))\]$"),
        regex = new XRegExp(
            "(?<name>[\w-]+)" +
            "\s*:\s*" +
            "(?<value>" +
                "[\w-%#]+|" +        // word
                "\[.*?\]|" +        // [] array
                '".*?"|' +            // "" string
                "'.*?'" +            // '' string
            ")\s*;?",
            "g"
        )
        ;

    while ((match = regex.exec(str)) != null) 
    {
        var value = match.value
            .replace(/^['"]|['"]$/g, '') // strip quotes from end of strings
            ;
        
        // try to parse array value
        if (value != null && arrayRegex.test(value))
        {
            var m = arrayRegex.exec(value);
            value = m.values.length > 0 ? m.values.split(/s*,s*/) : [];
        }
        
        result[match.name] = value;
    }
    
    return result;
};

/**
 * Wraps each line of the string into <code/> tag with given style applied to it.
 * 
 * @param {String} str   Input string.
 * @param {String} css   Style name to apply to the string.
 * @return {String}      Returns input string with each line surrounded by <span/> tag.
 */
function wrapLinesWithCode(str, css)
{
    if (str == null || str.length == 0 || str == 'n') 
        return str;

    str = str.replace(/</g, '&lt;');

    // Replace two or more sequential spaces with &nbsp; leaving last space untouched.
    str = str.replace(/ {2,}/g, function(m)
    {
        var spaces = '';
        
        for (var i = 0; i < m.length - 1; i++)
            spaces += sh.config.space;
        
        return spaces + ' ';
    });

    // Split each line and apply <span class="...">...</span> to them so that
    // leading spaces aren't included.
    if (css != null) 
        str = eachLine(str, function(line)
        {
            if (line.length == 0) 
                return '';
            
            var spaces = '';
            
            line = line.replace(/^(&nbsp;| )+/, function(s)
            {
                spaces = s;
                return '';
            });
            
            if (line.length == 0) 
                return spaces;
            
            return spaces + '<code class="' + css + '">' + line + '</code>';
        });

    return str;
};

/**
 * Pads number with zeros until it's length is the same as given length.
 * 
 * @param {Number} number    Number to pad.
 * @param {Number} length    Max string length with.
 * @return {String}            Returns a string padded with proper amount of '0'.
 */
function padNumber(number, length)
{
    var result = number.toString();
    
    while (result.length < length)
        result = '0' + result;
    
    return result;
};

/**
 * Replaces tabs with spaces.
 * 
 * @param {String} code        Source code.
 * @param {Number} tabSize    Size of the tab.
 * @return {String}            Returns code with all tabs replaces by spaces.
 */
function processTabs(code, tabSize)
{
    var tab = '';
    
    for (var i = 0; i < tabSize; i++)
        tab += ' ';

    return code.replace(/t/g, tab);
};

/**
 * Replaces tabs with smart spaces.
 * 
 * @param {String} code    Code to fix the tabs in.
 * @param {Number} tabSize Number of spaces in a column.
 * @return {String}        Returns code with all tabs replaces with roper amount of spaces.
 */
function processSmartTabs(code, tabSize)
{
    var lines = splitLines(code),
        tab = 't',
        spaces = ''
        ;
    
    // Create a string with 1000 spaces to copy spaces from... 
    // It's assumed that there would be no indentation longer than that.
    for (var i = 0; i < 50; i++) 
        spaces += '                    '; // 20 spaces * 50
            
    // This function inserts specified amount of spaces in the string
    // where a tab is while removing that given tab.
    function insertSpaces(line, pos, count)
    {
        return line.substr(0, pos)
            + spaces.substr(0, count)
            + line.substr(pos + 1, line.length) // pos + 1 will get rid of the tab
            ;
    };

    // Go through all the lines and do the 'smart tabs' magic.
    code = eachLine(code, function(line)
    {
        if (line.indexOf(tab) == -1) 
            return line;
        
        var pos = 0;
        
        while ((pos = line.indexOf(tab)) != -1) 
        {
            // This is pretty much all there is to the 'smart tabs' logic.
            // Based on the position within the line and size of a tab,
            // calculate the amount of spaces we need to insert.
            var spaces = tabSize - pos % tabSize;
            line = insertSpaces(line, pos, spaces);
        }
        
        return line;
    });
    
    return code;
};

/**
 * Performs various string fixes based on configuration.
 */
function fixInputString(str)
{
    var br = /<brs*/?>|&lt;brs*/?&gt;/gi;
    
    if (sh.config.bloggerMode == true)
        str = str.replace(br, 'n');

    if (sh.config.stripBrs == true)
        str = str.replace(br, '');
        
    return str;
};

/**
 * Removes all white space at the begining and end of a string.
 * 
 * @param {String} str   String to trim.
 * @return {String}      Returns string without leading and following white space characters.
 */
function trim(str)
{
    return str.replace(/^s+|s+$/g, '');
};

/**
 * Unindents a block of text by the lowest common indent amount.
 * @param {String} str   Text to unindent.
 * @return {String}      Returns unindented text block.
 */
function unindent(str)
{
    var lines = splitLines(fixInputString(str)),
        indents = new Array(),
        regex = /^s*/,
        min = 1000
        ;
    
    // go through every line and check for common number of indents
    for (var i = 0; i < lines.length && min > 0; i++) 
    {
        var line = lines[i];
        
        if (trim(line).length == 0) 
            continue;
        
        var matches = regex.exec(line);
        
        // In the event that just one line doesn't have leading white space
        // we can't unindent anything, so bail completely.
        if (matches == null) 
            return str;
            
        min = Math.min(matches[0].length, min);
    }
    
    // trim minimum common number of white space from the begining of every line
    if (min > 0) 
        for (var i = 0; i < lines.length; i++) 
            lines[i] = lines[i].substr(min);
    
    return lines.join('n');
};

/**
 * Callback method for Array.sort() which sorts matches by
 * index position and then by length.
 * 
 * @param {Match} m1    Left object.
 * @param {Match} m2    Right object.
 * @return {Number}     Returns -1, 0 or -1 as a comparison result.
 */
function matchesSortCallback(m1, m2)
{
    // sort matches by index first
    if(m1.index < m2.index)
        return -1;
    else if(m1.index > m2.index)
        return 1;
    else
    {
        // if index is the same, sort by length
        if(m1.length < m2.length)
            return -1;
        else if(m1.length > m2.length)
            return 1;
    }
    
    return 0;
};

/**
 * Executes given regular expression on provided code and returns all
 * matches that are found.
 * 
 * @param {String} code    Code to execute regular expression on.
 * @param {Object} regex   Regular expression item info from <code>regexList</code> collection.
 * @return {Array}         Returns a list of Match objects.
 */ 
function getMatches(code, regexInfo)
{
    function defaultAdd(match, regexInfo)
    {
        return match[0];
    };
    
    var index = 0,
        match = null,
        matches = [],
        func = regexInfo.func ? regexInfo.func : defaultAdd
        ;
    
    while((match = regexInfo.regex.exec(code)) != null)
    {
        var resultMatch = func(match, regexInfo);
        
        if (typeof(resultMatch) == 'string')
            resultMatch = [new sh.Match(resultMatch, match.index, regexInfo.css)];

        matches = matches.concat(resultMatch);
    }
    
    return matches;
};

/**
 * Turns all URLs in the code into <a/> tags.
 * @param {String} code Input code.
 * @return {String} Returns code with </a> tags.
 */
function processUrls(code)
{
    var gt = /(.*)((&gt;|&lt;).*)/;
    
    return code.replace(sh.regexLib.url, function(m)
    {
        var suffix = '',
            match = null
            ;
        
        // We include &lt; and &gt; in the URL for the common cases like <http://google.com>
        // The problem is that they get transformed into &lt;http://google.com&gt;
        // Where as &gt; easily looks like part of the URL string.
    
        if (match = gt.exec(m))
        {
            m = match[1];
            suffix = match[2];
        }
        
        return '<a href="' + m + '">' + m + '</a>' + suffix;
    });
};

/**
 * Finds all <SCRIPT TYPE="syntaxhighlighter" /> elementss.
 * @return {Array} Returns array of all found SyntaxHighlighter tags.
 */
function getSyntaxHighlighterScriptTags()
{
    var tags = document.getElementsByTagName('script'),
        result = []
        ;
    
    for (var i = 0; i < tags.length; i++)
        if (tags[i].type == 'syntaxhighlighter')
            result.push(tags[i]);
            
    return result;
};

/**
 * Strips <![CDATA[]]> from <SCRIPT /> content because it should be used
 * there in most cases for XHTML compliance.
 * @param {String} original    Input code.
 * @return {String} Returns code without leading <![CDATA[]]> tags.
 */
function stripCData(original)
{
    var left = '<![CDATA[',
        right = ']]>',
        // for some reason IE inserts some leading blanks here
        copy = trim(original),
        changed = false,
        leftLength = left.length,
        rightLength = right.length
        ;
    
    if (copy.indexOf(left) == 0)
    {
        copy = copy.substring(leftLength);
        changed = true;
    }
    
    var copyLength = copy.length;
    
    if (copy.indexOf(right) == copyLength - rightLength)
    {
        copy = copy.substring(0, copyLength - rightLength);
        changed = true;
    }
    
    return changed ? copy : original;
};


/**
 * Quick code mouse double click handler.
 */
function quickCodeHandler(e)
{
    var target = e.target,
        highlighterDiv = findParentElement(target, '.syntaxhighlighter'),
        container = findParentElement(target, '.container'),
        textarea = document.createElement('textarea'),
        highlighter
        ;

    if (!container || !highlighterDiv || findElement(container, 'textarea'))
        return;

    highlighter = getHighlighterById(highlighterDiv.id);
    
    // add source class name
    addClass(highlighterDiv, 'source');

    // Have to go over each line and grab it's text, can't just do it on the
    // container because Firefox loses all n where as Webkit doesn't.
    var lines = container.childNodes,
        code = []
        ;
    
    for (var i = 0; i < lines.length; i++)
        code.push(lines[i].innerText || lines[i].textContent);
    
    // using r instead of r or rn makes this work equally well on IE, FF and Webkit
    code = code.join('r');
    
    // inject <textarea/> tag
    textarea.appendChild(document.createTextNode(code));
    container.appendChild(textarea);
    
    // preselect all text
    textarea.focus();
    textarea.select();
    
    // set up handler for lost focus
    attachEvent(textarea, 'blur', function(e)
    {
        textarea.parentNode.removeChild(textarea);
        removeClass(highlighterDiv, 'source');
    });
};

/**
 * Match object.
 */
sh.Match = function(value, index, css)
{
    this.value = value;
    this.index = index;
    this.length = value.length;
    this.css = css;
    this.brushName = null;
};

sh.Match.prototype.toString = function()
{
    return this.value;
};

/**
 * Simulates HTML code with a scripting language embedded.
 * 
 * @param {String} scriptBrushName Brush name of the scripting language.
 */
sh.HtmlScript = function(scriptBrushName)
{
    var brushClass = findBrush(scriptBrushName),
        scriptBrush,
        xmlBrush = new sh.brushes.Xml(),
        bracketsRegex = null,
        ref = this,
        methodsToExpose = 'getDiv getHtml init'.split(' ')
        ;

    if (brushClass == null)
        return;
    
    scriptBrush = new brushClass();
    
    for(var i = 0; i < methodsToExpose.length; i++)
        // make a closure so we don't lose the name after i changes
        (function() {
            var name = methodsToExpose[i];
            
            ref[name] = function()
            {
                return xmlBrush[name].apply(xmlBrush, arguments);
            };
        })();
    
    if (scriptBrush.htmlScript == null)
    {
        alert(sh.config.strings.brushNotHtmlScript + scriptBrushName);
        return;
    }
    
    xmlBrush.regexList.push(
        { regex: scriptBrush.htmlScript.code, func: process }
    );
    
    function offsetMatches(matches, offset)
    {
        for (var j = 0; j < matches.length; j++) 
            matches[j].index += offset;
    }
    
    function process(match, info)
    {
        var code = match.code,
            matches = [],
            regexList = scriptBrush.regexList,
            offset = match.index + match.left.length,
            htmlScript = scriptBrush.htmlScript,
            result
            ;

        // add all matches from the code
        for (var i = 0; i < regexList.length; i++)
        {
            result = getMatches(code, regexList[i]);
            offsetMatches(result, offset);
            matches = matches.concat(result);
        }
        
        // add left script bracket
        if (htmlScript.left != null && match.left != null)
        {
            result = getMatches(match.left, htmlScript.left);
            offsetMatches(result, match.index);
            matches = matches.concat(result);
        }
        
        // add right script bracket
        if (htmlScript.right != null && match.right != null)
        {
            result = getMatches(match.right, htmlScript.right);
            offsetMatches(result, match.index + match[0].lastIndexOf(match.right));
            matches = matches.concat(result);
        }
        
        for (var j = 0; j < matches.length; j++)
            matches[j].brushName = brushClass.brushName;
            
        return matches;
    }
};

/**
 * Main Highlither class.
 * @constructor
 */
sh.Highlighter = function()
{
    // not putting any code in here because of the prototype inheritance
};

sh.Highlighter.prototype = {
    /**
     * Returns value of the parameter passed to the highlighter.
     * @param {String} name                Name of the parameter.
     * @param {Object} defaultValue        Default value.
     * @return {Object}                    Returns found value or default value otherwise.
     */
    getParam: function(name, defaultValue)
    {
        var result = this.params[name];
        return toBoolean(result == null ? defaultValue : result);
    },
    
    /**
     * Shortcut to document.createElement().
     * @param {String} name        Name of the element to create (DIV, A, etc).
     * @return {HTMLElement}    Returns new HTML element.
     */
    create: function(name)
    {
        return document.createElement(name);
    },
    
    /**
     * Applies all regular expression to the code and stores all found
     * matches in the `this.matches` array.
     * @param {Array} regexList        List of regular expressions.
     * @param {String} code            Source code.
     * @return {Array}                Returns list of matches.
     */
    findMatches: function(regexList, code)
    {
        var result = [];
        
        if (regexList != null)
            for (var i = 0; i < regexList.length; i++) 
                // BUG: length returns len+1 for array if methods added to prototype chain (oising@gmail.com)
                if (typeof (regexList[i]) == "object")
                    result = result.concat(getMatches(code, regexList[i]));
        
        // sort and remove nested the matches
        return this.removeNestedMatches(result.sort(matchesSortCallback));
    },
    
    /**
     * Checks to see if any of the matches are inside of other matches. 
     * This process would get rid of highligted strings inside comments, 
     * keywords inside strings and so on.
     */
    removeNestedMatches: function(matches)
    {
        // Optimized by Jose Prado (http://joseprado.com)
        for (var i = 0; i < matches.length; i++) 
        { 
            if (matches[i] === null)
                continue;
            
            var itemI = matches[i],
                itemIEndPos = itemI.index + itemI.length
                ;
            
            for (var j = i + 1; j < matches.length && matches[i] !== null; j++) 
            {
                var itemJ = matches[j];
                
                if (itemJ === null) 
                    continue;
                else if (itemJ.index > itemIEndPos) 
                    break;
                else if (itemJ.index == itemI.index && itemJ.length > itemI.length)
                    matches[i] = null;
                else if (itemJ.index >= itemI.index && itemJ.index < itemIEndPos) 
                    matches[j] = null;
            }
        }
        
        return matches;
    },
    
    /**
     * Creates an array containing integer line numbers starting from the 'first-line' param.
     * @return {Array} Returns array of integers.
     */
    figureOutLineNumbers: function(code)
    {
        var lines = [],
            firstLine = parseInt(this.getParam('first-line'))
            ;
        
        eachLine(code, function(line, index)
        {
            lines.push(index + firstLine);
        });
        
        return lines;
    },
    
    /**
     * Determines if specified line number is in the highlighted list.
     */
    isLineHighlighted: function(lineNumber)
    {
        var list = this.getParam('highlight', []);
        
        if (typeof(list) != 'object' && list.push == null) 
            list = [ list ];
        
        return indexOf(list, lineNumber.toString()) != -1;
    },
    
    /**
     * Generates HTML markup for a single line of code while determining alternating line style.
     * @param {Integer} lineNumber    Line number.
     * @param {String} code Line    HTML markup.
     * @return {String}                Returns HTML markup.
     */
    getLineHtml: function(lineIndex, lineNumber, code)
    {
        var classes = [
            'line',
            'number' + lineNumber,
            'index' + lineIndex,
            'alt' + (lineNumber % 2 == 0 ? 1 : 2).toString()
        ];
        
        if (this.isLineHighlighted(lineNumber))
             classes.push('highlighted');
        
        if (lineNumber == 0)
            classes.push('break');
            
        return '<div class="' + classes.join(' ') + '">' + code + '</div>';
    },
    
    /**
     * Generates HTML markup for line number column.
     * @param {String} code            Complete code HTML markup.
     * @param {Array} lineNumbers    Calculated line numbers.
     * @return {String}                Returns HTML markup.
     */
    getLineNumbersHtml: function(code, lineNumbers)
    {
        var html = '',
            count = splitLines(code).length,
            firstLine = parseInt(this.getParam('first-line')),
            pad = this.getParam('pad-line-numbers')
            ;
        
        if (pad == true)
            pad = (firstLine + count - 1).toString().length;
        else if (isNaN(pad) == true)
            pad = 0;
            
        for (var i = 0; i < count; i++)
        {
            var lineNumber = lineNumbers ? lineNumbers[i] : firstLine + i,
                code = lineNumber == 0 ? sh.config.space : padNumber(lineNumber, pad)
                ;
                
            html += this.getLineHtml(i, lineNumber, code);
        }
        
        return html;
    },
    
    /**
     * Splits block of text into individual DIV lines.
     * @param {String} code            Code to highlight.
     * @param {Array} lineNumbers    Calculated line numbers.
     * @return {String}                Returns highlighted code in HTML form.
     */
    getCodeLinesHtml: function(html, lineNumbers)
    {
        html = trim(html);
        
        var lines = splitLines(html),
            padLength = this.getParam('pad-line-numbers'),
            firstLine = parseInt(this.getParam('first-line')),
            html = '',
            brushName = this.getParam('brush')
            ;

        for (var i = 0; i < lines.length; i++)
        {
            var line = lines[i],
                indent = /^(&nbsp;|s)+/.exec(line),
                spaces = null,
                lineNumber = lineNumbers ? lineNumbers[i] : firstLine + i;
                ;

            if (indent != null)
            {
                spaces = indent[0].toString();
                line = line.substr(spaces.length);
                spaces = spaces.replace(' ', sh.config.space);
            }

            line = trim(line);
            
            if (line.length == 0)
                line = sh.config.space;
            
            html += this.getLineHtml(
                i,
                lineNumber, 
                (spaces != null ? '<code class="' + brushName + ' spaces">' + spaces + '</code>' : '') + line
            );
        }
        
        return html;
    },
    
    /**
     * Returns HTML for the table title or empty string if title is null.
     */
    getTitleHtml: function(title)
    {
        return title ? '<caption>' + title + '</caption>' : '';
    },
    
    /**
     * Finds all matches in the source code.
     * @param {String} code        Source code to process matches in.
     * @param {Array} matches    Discovered regex matches.
     * @return {String} Returns formatted HTML with processed mathes.
     */
    getMatchesHtml: function(code, matches)
    {
        var pos = 0, 
            result = '',
            brushName = this.getParam('brush', '')
            ;
        
        function getBrushNameCss(match)
        {
            var result = match ? (match.brushName || brushName) : brushName;
            return result ? result + ' ' : '';
        };
        
        // Finally, go through the final list of matches and pull the all
        // together adding everything in between that isn't a match.
        for (var i = 0; i < matches.length; i++) 
        {
            var match = matches[i],
                matchBrushName
                ;
            
            if (match === null || match.length === 0) 
                continue;
            
            matchBrushName = getBrushNameCss(match);
            
            result += wrapLinesWithCode(code.substr(pos, match.index - pos), matchBrushName + 'plain')
                    + wrapLinesWithCode(match.value, matchBrushName + match.css)
                    ;

            pos = match.index + match.length + (match.offset || 0);
        }

        // don't forget to add whatever's remaining in the string
        result += wrapLinesWithCode(code.substr(pos), getBrushNameCss() + 'plain');

        return result;
    },
    
    /**
     * Generates HTML markup for the whole syntax highlighter.
     * @param {String} code Source code.
     * @return {String} Returns HTML markup.
     */
    getHtml: function(code)
    {
        var html = '',
            classes = [ 'syntaxhighlighter' ],
            tabSize,
            matches,
            lineNumbers
            ;
        
        // process light mode
        if (this.getParam('light') == true)
            this.params.toolbar = this.params.gutter = false;

        className = 'syntaxhighlighter';

        if (this.getParam('collapse') == true)
            classes.push('collapsed');
        
        if ((gutter = this.getParam('gutter')) == false)
            classes.push('nogutter');

        // add custom user style name
        classes.push(this.getParam('class-name'));

        // add brush alias to the class name for custom CSS
        classes.push(this.getParam('brush'));

        code = trimFirstAndLastLines(code)
            .replace(/r/g, ' ') // IE lets these buggers through
            ;

        tabSize = this.getParam('tab-size');

        // replace tabs with spaces
        code = this.getParam('smart-tabs') == true
            ? processSmartTabs(code, tabSize)
            : processTabs(code, tabSize)
            ;

        // unindent code by the common indentation
        code = unindent(code);

        if (gutter)
            lineNumbers = this.figureOutLineNumbers(code);
        
        // find matches in the code using brushes regex list
        matches = this.findMatches(this.regexList, code);
        // processes found matches into the html
        html = this.getMatchesHtml(code, matches);
        // finally, split all lines so that they wrap well
        html = this.getCodeLinesHtml(html, lineNumbers);

        // finally, process the links
        if (this.getParam('auto-links'))
            html = processUrls(html);
        
        if (typeof(navigator) != 'undefined' && navigator.userAgent && navigator.userAgent.match(/MSIE/))
            classes.push('ie');
        
        html = 
            '<div id="' + getHighlighterId(this.id) + '" class="' + classes.join(' ') + '">'
                + (this.getParam('toolbar') ? sh.toolbar.getHtml(this) : '')
                + '<table border="0" cellpadding="0" cellspacing="0">'
                    + this.getTitleHtml(this.getParam('title'))
                    + '<tbody>'
                        + '<tr>'
                            + (gutter ? '<td class="gutter">' + this.getLineNumbersHtml(code) + '</td>' : '')
                            + '<td class="code">'
                                + '<div class="container">'
                                    + html
                                + '</div>'
                            + '</td>'
                        + '</tr>'
                    + '</tbody>'
                + '</table>'
            + '</div>'
            ;
            
        return html;
    },
    
    /**
     * Highlights the code and returns complete HTML.
     * @param {String} code     Code to highlight.
     * @return {Element}        Returns container DIV element with all markup.
     */
    getDiv: function(code)
    {
        if (code === null) 
            code = '';
        
        this.code = code;

        var div = this.create('div');

        // create main HTML
        div.innerHTML = this.getHtml(code);
        
        // set up click handlers
        if (this.getParam('toolbar'))
            attachEvent(findElement(div, '.toolbar'), 'click', sh.toolbar.handler);
        
        if (this.getParam('quick-code'))
            attachEvent(findElement(div, '.code'), 'dblclick', quickCodeHandler);
        
        return div;
    },
    
    /**
     * Initializes the highlighter/brush.
     *
     * Constructor isn't used for initialization so that nothing executes during necessary
     * `new SyntaxHighlighter.Highlighter()` call when setting up brush inheritence.
     *
     * @param {Hash} params Highlighter parameters.
     */
    init: function(params)
    {
        this.id = guid();
        
        // register this instance in the highlighters list
        storeHighlighter(this);
        
        // local params take precedence over defaults
        this.params = merge(sh.defaults, params || {})
        
        // process light mode
        if (this.getParam('light') == true)
            this.params.toolbar = this.params.gutter = false;
    },
    
    /**
     * Converts space separated list of keywords into a regular expression string.
     * @param {String} str    Space separated keywords.
     * @return {String}       Returns regular expression string.
     */
    getKeywords: function(str)
    {
        str = str
            .replace(/^s+|s+$/g, '')
            .replace(/s+/g, '|')
            ;
        
        return '\b(?:' + str + ')\b';
    },
    
    /**
     * Makes a brush compatible with the `html-script` functionality.
     * @param {Object} regexGroup Object containing `left` and `right` regular expressions.
     */
    forHtmlScript: function(regexGroup)
    {
        this.htmlScript = {
            left : { regex: regexGroup.left, css: 'script' },
            right : { regex: regexGroup.right, css: 'script' },
            code : new XRegExp(
                "(?<left>" + regexGroup.left.source + ")" +
                "(?<code>.*?)" +
                "(?<right>" + regexGroup.right.source + ")",
                "sgi"
                )
        };
    }
}; // end of Highlighter

return sh;
}(); // end of anonymous function

// CommonJS
typeof(exports) != 'undefined' ? exports['SyntaxHighlighter'] = SyntaxHighlighter : null;