看啥推荐读物

专栏名称: 努力提升的东东

自律给我自由

今天看啥

微信公众号rss订阅, 微信rss, 稳定的RSS源

微信公众号RSS订阅方法

B站投稿RSS订阅方法

知乎回答RSS订阅方法

知乎专栏 RSS订阅方法

雪球动态RSS订阅方法

微博RSS订阅方法

微博搜索关键词订阅方法

豆瓣日记 RSS订阅方法

2020-12-30

努力提升的东东 · 简书 · · 2020-12-30 22:00

修复颜色样式的问题
//
// Begin anonymous function. This is used to contain local scope variables without polutting global scope.
//
if (typeof(SyntaxHighlighter) == 'undefined') 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, '<');

// Replace two or more sequential spaces with 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 /?>|<br\s*/?>/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 = /(. )((>|<).*)/;

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;

原文地址：访问原文地址
快照地址：访问文章快照

分享到微博