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: ' ',
|
|
/** 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: /(<|<)!--[\s\S]*?--(>|>)/gm,
|
url: /\w+:\/\/[\w-.\/?%&=:@;]*/g,
|
|
/** <?= ?> tags. */
|
phpScriptTags: { left: /(<|<)\?=?/g, right: /\?(>|>)/g },
|
|
/** <%= %> tags. */
|
aspScriptTags: { left: /(<|<)%=?/g, right: /%(>|>)/g },
|
|
/** <script></script> tags. */
|
scriptScriptTags: { left: /(<|<)\s*script.*?(>|>)/gi, right: /(<|<)\/\s*script\s*(>|>)/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(/^( | )+/, 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 < and > in the URL for the common cases like <http://google.com>
|
// The problem is that they get transformed into <http://google.com>
|
// Where as > 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 = /^( |\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;
|
