var XRegExp;
(function () {
    function s(f, i) {
        if (!XRegExp.isRegExp(f))
            throw TypeError("type RegExp expected");
        var g = f._xregexp;
        f = XRegExp(f.source, t(f) + (i || ""));
        if (g)
            f._xregexp = { source: g.source, captureNames: g.captureNames ? g.captureNames.slice(0) : null };
        return f
    }
    function t(f) {
        return (f.global ? "g" : "") + (f.ignoreCase ? "i" : "") + (f.multiline ? "m" : "") + (f.extended ? "x" : "") + (f.sticky ? "y" : "")
    }
    function z(f, i, g, a) {
        var b = v.length, c, d, e;
        A = true;
        try {
            for (; b--;) {
                e = v[b];
                if (g & e.scope && (!e.trigger || e.trigger.call(a))) {
                    e.pattern.lastIndex = i;
                    if ((d = e.pattern.exec(f)) && d.index === i) {
                        c = { output: e.handler.call(a, d, g), match: d };
                        break
                    }
                }
            }
        } catch (h) {
            throw h
        } finally {
            A = false
        }
        return c
    }
    function B(f, i, g) {
        if (Array.prototype.indexOf)
            return f.indexOf(i, g);
        for (g = g || 0; g < f.length; g++)
            if (f[g] === i)
                return g;
        return -1
    }
    XRegExp = function (f, i) {
        var g = [], a = XRegExp.OUTSIDE_CLASS, b = 0, c, d;
        if (XRegExp.isRegExp(f)) {
            if (i !== undefined)
                throw TypeError("can't supply flags when constructing one RegExp from another");
            return s(f)
        }
        if (A)
            throw Error("can't call the XRegExp constructor within token definition functions");
        i = i || "";
        for (c = {
            hasNamedCapture: false, captureNames: [], hasFlag: function (e) {
            return i.indexOf(e) > -1
        }, setFlag: function (e) {
            i += e
        }
        }; b < f.length;)
            if (d = z(f, b, a, c)) {
                g.push(d.output);
                b += d.match[0].length || 1
            } else if (d = o.exec.call(C[a], f.slice(b))) {
                g.push(d[0]);
                b += d[0].length
            } else {
                d = f.charAt(b);
                if (d === "[")
                    a = XRegExp.INSIDE_CLASS;
                else if (d === "]")
                    a = XRegExp.OUTSIDE_CLASS;
                g.push(d);
                b++
            }
        g = RegExp(g.join(""), o.replace.call(i, D, ""));
        g._xregexp = { source: f, captureNames: c.hasNamedCapture ? c.captureNames : null };
        return g
    };
    XRegExp.version = "1.5.0";
    XRegExp.INSIDE_CLASS = 1;
    XRegExp.OUTSIDE_CLASS = 2;
    var q = /\$(?:(\d\d?|[$&`'])|{([$\w]+)})/g, D = /[^gimy]+|([\s\S])(?=[\s\S]*\1)/g, w = /^(?:[?*+]|{\d+(?:,\d*)?})\??/, A = false, v = [], o = { exec: RegExp.prototype.exec, test: RegExp.prototype.test, match: String.prototype.match, replace: String.prototype.replace, split: String.prototype.split }, F = o.exec.call(/()??/, "")[1] === undefined, x = function () {
        var f = /^/g;
        o.test.call(f, "");
        return !f.lastIndex
    }(), G = function () {
        var f = /x/g;
        o.replace.call("x", f, "");
        return !f.lastIndex
    }(), y = RegExp.prototype.sticky !== undefined, C = {};
    C[XRegExp.INSIDE_CLASS] = /^(?:\\(?:[0-3][0-7]{0,2}|[4-7][0-7]?|x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|c[A-Za-z]|[\s\S]))/;
    C[XRegExp.OUTSIDE_CLASS] = /^(?:\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9]\d*|x[\dA-Fa-f]{2}|u[\dA-Fa-f]{4}|c[A-Za-z]|[\s\S])|\(\?[:=!]|[?*+]\?|{\d+(?:,\d*)?}\??)/;
    XRegExp.addToken = function (f, i, g, a) {
        v.push({ pattern: s(f, "g" + (y ? "y" : "")), handler: i, scope: g || XRegExp.OUTSIDE_CLASS, trigger: a || null })
    };
    XRegExp.cache = function (f, i) {
        var g = f + "/" + (i || "");
        return XRegExp.cache[g] || (XRegExp.cache[g] = XRegExp(f, i))
    };
    XRegExp.copyAsGlobal = function (f) {
        return s(f, "g")
    };
    XRegExp.escape = function (f) {
        return f.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")
    };
    XRegExp.execAt = function (f, i, g, a) {
        i = s(i, "g" + (a && y ? "y" : ""));
        i.lastIndex = g = g || 0;
        f = i.exec(f);
        return a ? f && f.index === g ? f : null : f
    };
    XRegExp.freezeTokens = function () {
        XRegExp.addToken = function () {
            throw Error("can't run addToken after freezeTokens")
        }
    };
    XRegExp.isRegExp = function (f) {
        return Object.prototype.toString.call(f) === "[object RegExp]"
    };
    XRegExp.iterate = function (f, i, g, a) {
        for (var b = s(i, "g"), c = -1, d; d = b.exec(f) ;) {
            g.call(a, d, ++c, f, b);
            b.lastIndex === d.index && b.lastIndex++
        }
        if (i.global)
            i.lastIndex = 0
    };
    XRegExp.matchChain = function (f, i) {
        return function g(a, b) {
            var c = i[b].regex ? i[b] : { regex: i[b] }, d = s(c.regex, "g"), e = [], h;
            for (h = 0; h < a.length; h++)
                XRegExp.iterate(a[h], d, function (j) {
                    e.push(c.backref ? j[c.backref] || "" : j[0])
                });
            return b === i.length - 1 || !e.length ? e : g(e, b + 1)
        }([f], 0)
    };
    RegExp.prototype.apply = function (f, i) {
        return this.exec(i[0])
    };
    RegExp.prototype.call = function (f, i) {
        return this.exec(i)
    };
    RegExp.prototype.exec = function (f) {
        var i = o.exec.apply(this, arguments), g;
        if (i) {
            if (!F && i.length > 1 && B(i, "") > -1) {
                g = RegExp(this.source, o.replace.call(t(this), "g", ""));
                o.replace.call(f.toString().slice(i.index), g, function () {
                    for (var b = 1; b < arguments.length - 2; b++)
                        if (arguments[b] === undefined)
                            i[b] = undefined
                })
            }
            if (this._xregexp && this._xregexp.captureNames)
                for (var a = 1; a < i.length; a++)
                    if (g = this._xregexp.captureNames[a - 1])
                        i[g] = i[a];
            !x && this.global && !i[0].length && this.lastIndex > i.index && this.lastIndex--
        }
        return i
    };
    if (!x)
        RegExp.prototype.test = function (f) {
            (f = o.exec.call(this, f)) && this.global && !f[0].length && this.lastIndex > f.index && this.lastIndex--;
            return !!f
        };
    String.prototype.match = function (f) {
        XRegExp.isRegExp(f) || (f = RegExp(f));
        if (f.global) {
            var i = o.match.apply(this, arguments);
            f.lastIndex = 0;
            return i
        }
        return f.exec(this)
    };
    String.prototype.replace = function (f, i) {
        var g = XRegExp.isRegExp(f), a, b;
        if (g && typeof i.valueOf() === "string" && i.indexOf("${") === -1 && G)
            return o.replace.apply(this, arguments);
        if (g) {
            if (f._xregexp)
                a = f._xregexp.captureNames
        } else
            f += "";
        if (typeof i === "function")
            b = o.replace.call(this, f, function () {
                if (a) {
                    arguments[0] = new String(arguments[0]);
                    for (var c = 0; c < a.length; c++)
                        if (a[c])
                            arguments[0][a[c]] = arguments[c + 1]
                }
                if (g && f.global)
                    f.lastIndex = arguments[arguments.length - 2] + arguments[0].length;
                return i.apply(null, arguments)
            });
        else {
            b = this + "";
            b = o.replace.call(b, f, function () {
                var c = arguments;
                return o.replace.call(i, q, function (d, e, h) {
                    if (e)
                        switch (e) {
                            case "$":
                                return "$";
                            case "&":
                                return c[0];
                            case "`":
                                return c[c.length - 1].slice(0, c[c.length - 2]);
                            case "'":
                                return c[c.length - 1].slice(c[c.length - 2] + c[0].length);
                            default:
                                h = "";
                                e = +e;
                                if (!e)
                                    return d;
                                for (; e > c.length - 3;) {
                                    h = String.prototype.slice.call(e, -1) + h;
                                    e = Math.floor(e / 10)
                                }
                                return (e ? c[e] || "" : "$") + h
                        }
                    else {
                        e = +h;
                        if (e <= c.length - 3)
                            return c[e];
                        e = a ? B(a, h) : -1;
                        return e > -1 ? c[e + 1] : d
                    }
                })
            })
        }
        if (g && f.global)
            f.lastIndex = 0;
        return b
    };
    String.prototype.split = function (f, i) {
        if (!XRegExp.isRegExp(f))
            return o.split.apply(this, arguments);
        var g = this + "", a = [], b = 0, c, d;
        if (i === undefined || +i < 0)
            i = Infinity;
        else {
            i = Math.floor(+i);
            if (!i)
                return []
        }
        for (f = XRegExp.copyAsGlobal(f) ; c = f.exec(g) ;) {
            if (f.lastIndex > b) {
                a.push(g.slice(b, c.index));
                c.length > 1 && c.index < g.length && Array.prototype.push.apply(a, c.slice(1));
                d = c[0].length;
                b = f.lastIndex;
                if (a.length >= i)
                    break
            }
            f.lastIndex === c.index && f.lastIndex++
        }
        if (b === g.length) {
            if (!o.test.call(f, "") || d)
                a.push("")
        } else
            a.push(g.slice(b));
        return a.length > i ? a.slice(0, i) : a
    };
    XRegExp.addToken(/\(\?#[^)]*\)/, function (f) {
        return o.test.call(w, f.input.slice(f.index + f[0].length)) ? "" : "(?:)"
    });
    XRegExp.addToken(/\((?!\?)/, function () {
        this.captureNames.push(null);
        return "("
    });
    XRegExp.addToken(/\(\?<([$\w]+)>/, function (f) {
        this.captureNames.push(f[1]);
        this.hasNamedCapture = true;
        return "("
    });
    XRegExp.addToken(/\\k<([\w$]+)>/, function (f) {
        var i = B(this.captureNames, f[1]);
        return i > -1 ? "\\" + (i + 1) + (isNaN(f.input.charAt(f.index + f[0].length)) ? "" : "(?:)") : f[0]
    });
    XRegExp.addToken(/\[\^?]/, function (f) {
        return f[0] === "[]" ? "\\b\\B" : "[\\s\\S]"
    });
    XRegExp.addToken(/^\(\?([imsx]+)\)/, function (f) {
        this.setFlag(f[1]);
        return ""
    });
    XRegExp.addToken(/(?:\s+|#.*)+/, function (f) {
        return o.test.call(w, f.input.slice(f.index + f[0].length)) ? "" : "(?:)"
    }, XRegExp.OUTSIDE_CLASS, function () {
        return this.hasFlag("x")
    });
    XRegExp.addToken(/\./, function () {
        return "[\\s\\S]"
    }, XRegExp.OUTSIDE_CLASS, function () {
        return this.hasFlag("s")
    })
})();



/**
 * 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': false,

            /** 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: 'SyntaxHighlighter',

            strings: {
                expandSource: 'expand source',
                help: '?',
                alert: 'SyntaxHighlighter\n\n',
                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: /\/\*[\s\S]*?\*\//gm,
            singleLineCComments: /\/\/.*$/gm,
            singleLinePerlComments: /#.*$/gm,
            doubleQuotedString: /"([^\\"\n]|\\.)*"/g,
            singleQuotedString: /'([^\\'\n]|\\.)*'/g,
            multiLineDoubleQuotedString: new XRegExp('"([^\\\\"]|\\\\.)*"', 'gs'),
            multiLineSingleQuotedString: new XRegExp("'([^\\\\']|\\\\.)*'", 'gs'),
            xmlComments: /(&lt;|<)!--[\s\S]*?--(&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*script\s*(&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.getElementsByName(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 = /<br\s*\/?>|&lt;br\s*\/?&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 \r\n 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;