docs/template/static/scripts/sunlight.js
/**
* Sunlight
* Intelligent syntax highlighting
*
* http://sunlightjs.com/
*
* by Tommy Montgomery <http://tmont.com>
* Licensed under WTFPL <http://sam.zoy.org/wtfpl/>
*/
(function(window, document, undefined){
var
//http://webreflection.blogspot.com/2009/01/32-bytes-to-know-if-your-browser-is-ie.html
//we have to sniff this because IE requires \r
isIe = !+"\v1",
EOL = isIe ? "\r" : "\n",
EMPTY = function() { return null; },
HIGHLIGHTED_NODE_COUNT = 0,
DEFAULT_LANGUAGE = "plaintext",
DEFAULT_CLASS_PREFIX = "sunlight-",
//global sunlight variables
defaultAnalyzer,
getComputedStyle,
globalOptions = {
tabWidth: 4,
classPrefix: DEFAULT_CLASS_PREFIX,
showWhitespace: false,
maxHeight: false
},
languages = {},
languageDefaults = {},
events = {
beforeHighlightNode: [],
beforeHighlight: [],
beforeTokenize: [],
afterTokenize: [],
beforeAnalyze: [],
afterAnalyze: [],
afterHighlight: [],
afterHighlightNode: []
};
defaultAnalyzer = (function() {
function defaultHandleToken(suffix) {
return function(context) {
var element = document.createElement("span");
element.className = context.options.classPrefix + suffix;
element.appendChild(context.createTextNode(context.tokens[context.index]));
return context.addNode(element) || true;
};
}
return {
handleToken: function(context) {
return defaultHandleToken(context.tokens[context.index].name)(context);
},
//just append default content as a text node
handle_default: function(context) {
return context.addNode(context.createTextNode(context.tokens[context.index]));
},
//this handles the named ident mayhem
handle_ident: function(context) {
var evaluate = function(rules, createRule) {
var i;
rules = rules || [];
for (i = 0; i < rules.length; i++) {
if (typeof(rules[i]) === "function") {
if (rules[i](context)) {
return defaultHandleToken("named-ident")(context);
}
} else if (createRule && createRule(rules[i])(context.tokens)) {
return defaultHandleToken("named-ident")(context);
}
}
return false;
};
return evaluate(context.language.namedIdentRules.custom)
|| evaluate(context.language.namedIdentRules.follows, function(ruleData) { return createProceduralRule(context.index - 1, -1, ruleData, context.language.caseInsensitive); })
|| evaluate(context.language.namedIdentRules.precedes, function(ruleData) { return createProceduralRule(context.index + 1, 1, ruleData, context.language.caseInsensitive); })
|| evaluate(context.language.namedIdentRules.between, function(ruleData) { return createBetweenRule(context.index, ruleData.opener, ruleData.closer, context.language.caseInsensitive); })
|| defaultHandleToken("ident")(context);
}
};
}());
languageDefaults = {
analyzer: create(defaultAnalyzer),
customTokens: [],
namedIdentRules: {},
punctuation: /[^\w\s]/,
numberParser: defaultNumberParser,
caseInsensitive: false,
doNotParse: /\s/,
contextItems: {},
embeddedLanguages: {}
};
//adapted from http://blargh.tommymontgomery.com/2010/04/get-computed-style-in-javascript/
getComputedStyle = (function() {
var func = null;
if (document.defaultView && document.defaultView.getComputedStyle) {
func = document.defaultView.getComputedStyle;
} else {
func = function(element, anything) {
return element["currentStyle"] || {};
};
}
return function(element, style) {
return func(element, null)[style];
}
}());
//-----------
//FUNCTIONS
//-----------
function createCodeReader(text) {
var index = 0,
line = 1,
column = 1,
length,
EOF = undefined,
currentChar,
nextReadBeginsLine;
text = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n"); //normalize line endings to unix
length = text.length;
currentChar = length > 0 ? text.charAt(0) : EOF;
function getCharacters(count) {
var value;
if (count === 0) {
return "";
}
count = count || 1;
value = text.substring(index + 1, index + count + 1);
return value === "" ? EOF : value;
}
return {
toString: function() {
return "length: " + length + ", index: " + index + ", line: " + line + ", column: " + column + ", current: [" + currentChar + "]";
},
peek: function(count) {
return getCharacters(count);
},
substring: function() {
return text.substring(index);
},
peekSubstring: function() {
return text.substring(index + 1);
},
read: function(count) {
var value = getCharacters(count),
newlineCount,
lastChar;
if (value === "") {
//this is a result of reading/peeking/doing nothing
return value;
}
if (value !== EOF) {
//advance index
index += value.length;
column += value.length;
//update line count
if (nextReadBeginsLine) {
line++;
column = 1;
nextReadBeginsLine = false;
}
newlineCount = value.substring(0, value.length - 1).replace(/[^\n]/g, "").length;
if (newlineCount > 0) {
line += newlineCount;
column = 1;
}
lastChar = last(value);
if (lastChar === "\n") {
nextReadBeginsLine = true;
}
currentChar = lastChar;
} else {
index = length;
currentChar = EOF;
}
return value;
},
text: function() { return text; },
getLine: function() { return line; },
getColumn: function() { return column; },
isEof: function() { return index >= length; },
isSol: function() { return column === 1; },
isSolWs: function() {
var temp = index,
c;
if (column === 1) {
return true;
}
//look backward until we find a newline or a non-whitespace character
while ((c = text.charAt(--temp)) !== "") {
if (c === "\n") {
return true;
}
if (!/\s/.test(c)) {
return false;
}
}
return true;
},
isEol: function() { return nextReadBeginsLine; },
EOF: EOF,
current: function() { return currentChar; }
};
}
//http://javascript.crockford.com/prototypal.html
function create(o) {
function F() {}
F.prototype = o;
return new F();
}
function appendAll(parent, children) {
var i;
for (i = 0; i < children.length; i++) {
parent.appendChild(children[i]);
}
}
//gets the last character in a string or the last element in an array
function last(thing) {
return thing.charAt ? thing.charAt(thing.length - 1) : thing[thing.length - 1];
}
//array.contains()
function contains(arr, value, caseInsensitive) {
var i;
if (arr.indexOf && !caseInsensitive) {
return arr.indexOf(value) >= 0;
}
for (i = 0; i < arr.length; i++) {
if (arr[i] === value) {
return true;
}
if (caseInsensitive && typeof(arr[i]) === "string" && typeof(value) === "string" && arr[i].toUpperCase() === value.toUpperCase()) {
return true;
}
}
return false;
}
//non-recursively merges one object into the other
function merge(defaultObject, objectToMerge) {
var key;
if (!objectToMerge) {
return defaultObject;
}
for (key in objectToMerge) {
defaultObject[key] = objectToMerge[key];
}
return defaultObject;
}
function clone(object) {
return merge({}, object);
}
//http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript/3561711#3561711
function regexEscape(s) {
return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");
}
function createProceduralRule(startIndex, direction, tokenRequirements, caseInsensitive) {
tokenRequirements = tokenRequirements.slice(0);
return function(tokens) {
var tokenIndexStart = startIndex,
j,
expected,
actual;
if (direction === 1) {
tokenRequirements.reverse();
}
for (j = 0; j < tokenRequirements.length; j++) {
actual = tokens[tokenIndexStart + (j * direction)];
expected = tokenRequirements[tokenRequirements.length - 1 - j];
if (actual === undefined) {
if (expected["optional"] !== undefined && expected.optional) {
tokenIndexStart -= direction;
} else {
return false;
}
} else if (actual.name === expected.token && (expected["values"] === undefined || contains(expected.values, actual.value, caseInsensitive))) {
//derp
continue;
} else if (expected["optional"] !== undefined && expected.optional) {
tokenIndexStart -= direction; //we need to reevaluate against this token again
} else {
return false;
}
}
return true;
};
}
function createBetweenRule(startIndex, opener, closer, caseInsensitive) {
return function(tokens) {
var index = startIndex,
token,
success = false;
//check to the left: if we run into a closer or never run into an opener, fail
while ((token = tokens[--index]) !== undefined) {
if (token.name === closer.token && contains(closer.values, token.value)) {
if (token.name === opener.token && contains(opener.values, token.value, caseInsensitive)) {
//if the closer is the same as the opener that's okay
success = true;
break;
}
return false;
}
if (token.name === opener.token && contains(opener.values, token.value, caseInsensitive)) {
success = true;
break;
}
}
if (!success) {
return false;
}
//check to the right for the closer
index = startIndex;
while ((token = tokens[++index]) !== undefined) {
if (token.name === opener.token && contains(opener.values, token.value, caseInsensitive)) {
if (token.name === closer.token && contains(closer.values, token.value, caseInsensitive)) {
//if the closer is the same as the opener that's okay
success = true;
break;
}
return false;
}
if (token.name === closer.token && contains(closer.values, token.value, caseInsensitive)) {
success = true;
break;
}
}
return success;
};
}
function matchWord(context, wordMap, tokenName, doNotRead) {
var current = context.reader.current(),
i,
word,
peek,
line = context.reader.getLine(),
column = context.reader.getColumn();
wordMap = wordMap || [];
if (context.language.caseInsensitive) {
current = current.toUpperCase();
}
if (!wordMap[current]) {
return null;
}
wordMap = wordMap[current];
for (i = 0; i < wordMap.length; i++) {
word = wordMap[i].value;
peek = current + context.reader.peek(word.length);
if (word === peek || wordMap[i].regex.test(peek)) {
return context.createToken(
tokenName,
context.reader.current() + context.reader[doNotRead ? "peek" : "read"](word.length - 1),
line,
column
);
}
}
return null;
}
//gets the next token in the specified direction while matcher matches the current token
function getNextWhile(tokens, index, direction, matcher) {
var count = 1,
token;
direction = direction || 1;
while (token = tokens[index + (direction * count++)]) {
if (!matcher(token)) {
return token;
}
}
return undefined;
}
//this is crucial for performance
function createHashMap(wordMap, boundary, caseInsensitive) {
//creates a hash table where the hash is the first character of the word
var newMap = { },
i,
word,
firstChar;
for (i = 0; i < wordMap.length; i++) {
word = caseInsensitive ? wordMap[i].toUpperCase() : wordMap[i];
firstChar = word.charAt(0);
if (!newMap[firstChar]) {
newMap[firstChar] = [];
}
newMap[firstChar].push({ value: word, regex: new RegExp("^" + regexEscape(word) + boundary, caseInsensitive ? "i" : "") });
}
return newMap;
}
function defaultNumberParser(context) {
var current = context.reader.current(),
number,
line = context.reader.getLine(),
column = context.reader.getColumn(),
allowDecimal = true,
peek;
if (!/\d/.test(current)) {
//is it a decimal followed by a number?
if (current !== "." || !/\d/.test(context.reader.peek())) {
return null;
}
//decimal without leading zero
number = current + context.reader.read();
allowDecimal = false;
} else {
number = current;
if (current === "0" && context.reader.peek() !== ".") {
//hex or octal
allowDecimal = false;
}
}
//easy way out: read until it's not a number or letter
//this will work for hex (0xef), octal (012), decimal and scientific notation (1e3)
//anything else and you're on your own
while ((peek = context.reader.peek()) !== context.reader.EOF) {
if (!/[A-Za-z0-9]/.test(peek)) {
if (peek === "." && allowDecimal && /\d$/.test(context.reader.peek(2))) {
number += context.reader.read();
allowDecimal = false;
continue;
}
break;
}
number += context.reader.read();
}
return context.createToken("number", number, line, column);
}
function fireEvent(eventName, highlighter, eventContext) {
var delegates = events[eventName] || [],
i;
for (i = 0; i < delegates.length; i++) {
delegates[i].call(highlighter, eventContext);
}
}
function Highlighter(options) {
this.options = merge(clone(globalOptions), options);
}
Highlighter.prototype = (function() {
var parseNextToken = (function() {
function isIdentMatch(context) {
return context.language.identFirstLetter && context.language.identFirstLetter.test(context.reader.current());
}
//token parsing functions
function parseKeyword(context) {
return matchWord(context, context.language.keywords, "keyword");
}
function parseCustomTokens(context) {
var tokenName,
token;
if (context.language.customTokens === undefined) {
return null;
}
for (tokenName in context.language.customTokens) {
token = matchWord(context, context.language.customTokens[tokenName], tokenName);
if (token !== null) {
return token;
}
}
return null;
}
function parseOperator(context) {
return matchWord(context, context.language.operators, "operator");
}
function parsePunctuation(context) {
var current = context.reader.current();
if (context.language.punctuation.test(regexEscape(current))) {
return context.createToken("punctuation", current, context.reader.getLine(), context.reader.getColumn());
}
return null;
}
function parseIdent(context) {
var ident,
peek,
line = context.reader.getLine(),
column = context.reader.getColumn();
if (!isIdentMatch(context)) {
return null;
}
ident = context.reader.current();
while ((peek = context.reader.peek()) !== context.reader.EOF) {
if (!context.language.identAfterFirstLetter.test(peek)) {
break;
}
ident += context.reader.read();
}
return context.createToken("ident", ident, line, column);
}
function parseDefault(context) {
if (context.defaultData.text === "") {
//new default token
context.defaultData.line = context.reader.getLine();
context.defaultData.column = context.reader.getColumn();
}
context.defaultData.text += context.reader.current();
return null;
}
function parseScopes(context) {
var current = context.reader.current(),
tokenName,
specificScopes,
j,
opener,
line,
column,
continuation,
value;
for (tokenName in context.language.scopes) {
specificScopes = context.language.scopes[tokenName];
for (j = 0; j < specificScopes.length; j++) {
opener = specificScopes[j][0];
value = current + context.reader.peek(opener.length - 1);
if (opener !== value && (!context.language.caseInsensitive || value.toUpperCase() !== opener.toUpperCase())) {
continue;
}
line = context.reader.getLine(), column = context.reader.getColumn();
context.reader.read(opener.length - 1);
continuation = getScopeReaderFunction(specificScopes[j], tokenName);
return continuation(context, continuation, value, line, column);
}
}
return null;
}
function parseNumber(context) {
return context.language.numberParser(context);
}
function parseCustomRules(context) {
var customRules = context.language.customParseRules,
i,
token;
if (customRules === undefined) {
return null;
}
for (i = 0; i < customRules.length; i++) {
token = customRules[i](context);
if (token) {
return token;
}
}
return null;
}
return function(context) {
if (context.language.doNotParse.test(context.reader.current())) {
return parseDefault(context);
}
return parseCustomRules(context)
|| parseCustomTokens(context)
|| parseKeyword(context)
|| parseScopes(context)
|| parseIdent(context)
|| parseNumber(context)
|| parseOperator(context)
|| parsePunctuation(context)
|| parseDefault(context);
}
}());
function getScopeReaderFunction(scope, tokenName) {
var escapeSequences = scope[2] || [],
closerLength = scope[1].length,
closer = typeof(scope[1]) === "string" ? new RegExp(regexEscape(scope[1])) : scope[1].regex,
zeroWidth = scope[3] || false;
//processCurrent indicates that this is being called from a continuation
//which means that we need to process the current char, rather than peeking at the next
return function(context, continuation, buffer, line, column, processCurrent) {
var foundCloser = false;
buffer = buffer || "";
processCurrent = processCurrent ? 1 : 0;
function process(processCurrent) {
//check for escape sequences
var peekValue,
current = context.reader.current(),
i;
for (i = 0; i < escapeSequences.length; i++) {
peekValue = (processCurrent ? current : "") + context.reader.peek(escapeSequences[i].length - processCurrent);
if (peekValue === escapeSequences[i]) {
buffer += context.reader.read(peekValue.length - processCurrent);
return true;
}
}
peekValue = (processCurrent ? current : "") + context.reader.peek(closerLength - processCurrent);
if (closer.test(peekValue)) {
foundCloser = true;
return false;
}
buffer += processCurrent ? current : context.reader.read();
return true;
};
if (!processCurrent || process(true)) {
while (context.reader.peek() !== context.reader.EOF && process(false)) { }
}
if (processCurrent) {
buffer += context.reader.current();
context.reader.read();
} else {
buffer += zeroWidth || context.reader.peek() === context.reader.EOF ? "" : context.reader.read(closerLength);
}
if (!foundCloser) {
//we need to signal to the context that this scope was never properly closed
//this has significance for partial parses (e.g. for nested languages)
context.continuation = continuation;
}
return context.createToken(tokenName, buffer, line, column);
};
}
//called before processing the current
function switchToEmbeddedLanguageIfNecessary(context) {
var i,
embeddedLanguage;
for (i = 0; i < context.language.embeddedLanguages.length; i++) {
if (!languages[context.language.embeddedLanguages[i].language]) {
//unregistered language
continue;
}
embeddedLanguage = clone(context.language.embeddedLanguages[i]);
if (embeddedLanguage.switchTo(context)) {
embeddedLanguage.oldItems = clone(context.items);
context.embeddedLanguageStack.push(embeddedLanguage);
context.language = languages[embeddedLanguage.language];
context.items = merge(context.items, clone(context.language.contextItems));
break;
}
}
}
//called after processing the current
function switchBackFromEmbeddedLanguageIfNecessary(context) {
var current = last(context.embeddedLanguageStack),
lang;
if (current && current.switchBack(context)) {
context.language = languages[current.parentLanguage];
lang = context.embeddedLanguageStack.pop();
//restore old items
context.items = clone(lang.oldItems);
lang.oldItems = {};
}
}
function tokenize(unhighlightedCode, language, partialContext, options) {
var tokens = [],
context,
continuation,
token;
fireEvent("beforeTokenize", this, { code: unhighlightedCode, language: language });
context = {
reader: createCodeReader(unhighlightedCode),
language: language,
items: clone(language.contextItems),
token: function(index) { return tokens[index]; },
getAllTokens: function() { return tokens.slice(0); },
count: function() { return tokens.length; },
options: options,
embeddedLanguageStack: [],
defaultData: {
text: "",
line: 1,
column: 1
},
createToken: function(name, value, line, column) {
return {
name: name,
line: line,
value: isIe ? value.replace(/\n/g, "\r") : value,
column: column,
language: this.language.name
};
}
};
//if continuation is given, then we need to pick up where we left off from a previous parse
//basically it indicates that a scope was never closed, so we need to continue that scope
if (partialContext.continuation) {
continuation = partialContext.continuation;
partialContext.continuation = null;
tokens.push(continuation(context, continuation, "", context.reader.getLine(), context.reader.getColumn(), true));
}
while (!context.reader.isEof()) {
switchToEmbeddedLanguageIfNecessary(context);
token = parseNextToken(context);
//flush default data if needed (in pretty much all languages this is just whitespace)
if (token !== null) {
if (context.defaultData.text !== "") {
tokens.push(context.createToken("default", context.defaultData.text, context.defaultData.line, context.defaultData.column));
context.defaultData.text = "";
}
if (token[0] !== undefined) {
//multiple tokens
tokens = tokens.concat(token);
} else {
//single token
tokens.push(token);
}
}
switchBackFromEmbeddedLanguageIfNecessary(context);
context.reader.read();
}
//append the last default token, if necessary
if (context.defaultData.text !== "") {
tokens.push(context.createToken("default", context.defaultData.text, context.defaultData.line, context.defaultData.column));
}
fireEvent("afterTokenize", this, { code: unhighlightedCode, parserContext: context });
return context;
}
function createAnalyzerContext(parserContext, partialContext, options) {
var nodes = [],
prepareText = function() {
var nbsp, tab;
if (options.showWhitespace) {
nbsp = String.fromCharCode(0xB7);
tab = new Array(options.tabWidth).join(String.fromCharCode(0x2014)) + String.fromCharCode(0x2192);
} else {
nbsp = String.fromCharCode(0xA0);
tab = new Array(options.tabWidth + 1).join(nbsp);
}
return function(token) {
var value = token.value.split(" ").join(nbsp),
tabIndex,
lastNewlineColumn,
actualColumn,
tabLength;
//tabstop madness: replace \t with the appropriate number of characters, depending on the tabWidth option and its relative position in the line
while ((tabIndex = value.indexOf("\t")) >= 0) {
lastNewlineColumn = value.lastIndexOf(EOL, tabIndex);
actualColumn = lastNewlineColumn === -1 ? tabIndex : tabIndex - lastNewlineColumn - 1;
tabLength = options.tabWidth - (actualColumn % options.tabWidth); //actual length of the TAB character
value = value.substring(0, tabIndex) + tab.substring(options.tabWidth - tabLength) + value.substring(tabIndex + 1);
}
return value;
};
}();
return {
tokens: (partialContext.tokens || []).concat(parserContext.getAllTokens()),
index: partialContext.index ? partialContext.index + 1 : 0,
language: null,
getAnalyzer: EMPTY,
options: options,
continuation: parserContext.continuation,
addNode: function(node) { nodes.push(node); },
createTextNode: function(token) { return document.createTextNode(prepareText(token)); },
getNodes: function() { return nodes; },
resetNodes: function() { nodes = []; },
items: parserContext.items
};
}
//partialContext allows us to perform a partial parse, and then pick up where we left off at a later time
//this functionality enables nested highlights (language within a language, e.g. PHP within HTML followed by more PHP)
function highlightText(unhighlightedCode, languageId, partialContext) {
var language = languages[languageId],
analyzerContext;
partialContext = partialContext || { };
if (language === undefined) {
//use default language if one wasn't specified or hasn't been registered
language = languages[DEFAULT_LANGUAGE];
}
fireEvent("beforeHighlight", this, { code: unhighlightedCode, language: language, previousContext: partialContext });
analyzerContext = createAnalyzerContext(
tokenize.call(this, unhighlightedCode, language, partialContext, this.options),
partialContext,
this.options
);
analyze.call(this, analyzerContext, partialContext.index ? partialContext.index + 1 : 0);
fireEvent("afterHighlight", this, { analyzerContext: analyzerContext });
return analyzerContext;
}
function createContainer(ctx) {
var container = document.createElement("span");
container.className = ctx.options.classPrefix + ctx.language.name;
return container;
}
function analyze(analyzerContext, startIndex) {
var nodes,
lastIndex,
container,
i,
tokenName,
func,
language,
analyzer;
fireEvent("beforeAnalyze", this, { analyzerContext: analyzerContext });
if (analyzerContext.tokens.length > 0) {
analyzerContext.language = languages[analyzerContext.tokens[0].language] || languages[DEFAULT_LANGUAGE];;
nodes = [];
lastIndex = 0;
container = createContainer(analyzerContext);
for (i = startIndex; i < analyzerContext.tokens.length; i++) {
language = languages[analyzerContext.tokens[i].language] || languages[DEFAULT_LANGUAGE];
if (language.name !== analyzerContext.language.name) {
appendAll(container, analyzerContext.getNodes());
analyzerContext.resetNodes();
nodes.push(container);
analyzerContext.language = language;
container = createContainer(analyzerContext);
}
analyzerContext.index = i;
tokenName = analyzerContext.tokens[i].name;
func = "handle_" + tokenName;
analyzer = analyzerContext.getAnalyzer.call(analyzerContext) || analyzerContext.language.analyzer;
analyzer[func] ? analyzer[func](analyzerContext) : analyzer.handleToken(analyzerContext);
}
//append the last nodes, and add the final nodes to the context
appendAll(container, analyzerContext.getNodes());
nodes.push(container);
analyzerContext.resetNodes();
for (i = 0; i < nodes.length; i++) {
analyzerContext.addNode(nodes[i]);
}
}
fireEvent("afterAnalyze", this, { analyzerContext: analyzerContext });
}
return {
//matches the language of the node to highlight
matchSunlightNode: function() {
var regex;
return function(node) {
if (!regex) {
regex = new RegExp("(?:\\s|^)" + this.options.classPrefix + "highlight-(\\S+)(?:\\s|$)");
}
return regex.exec(node.className);
};
}(),
//determines if the node has already been highlighted
isAlreadyHighlighted: function() {
var regex;
return function(node) {
if (!regex) {
regex = new RegExp("(?:\\s|^)" + this.options.classPrefix + "highlighted(?:\\s|$)");
}
return regex.test(node.className);
};
}(),
//highlights a block of text
highlight: function(code, languageId) { return highlightText.call(this, code, languageId); },
//recursively highlights a DOM node
highlightNode: function highlightRecursive(node) {
var match,
languageId,
currentNodeCount,
j,
nodes,
k,
partialContext,
container,
codeContainer;
if (this.isAlreadyHighlighted(node) || (match = this.matchSunlightNode(node)) === null) {
return;
}
languageId = match[1];
currentNodeCount = 0;
fireEvent("beforeHighlightNode", this, { node: node });
for (j = 0; j < node.childNodes.length; j++) {
if (node.childNodes[j].nodeType === 3) {
//text nodes
partialContext = highlightText.call(this, node.childNodes[j].nodeValue, languageId, partialContext);
HIGHLIGHTED_NODE_COUNT++;
currentNodeCount = currentNodeCount || HIGHLIGHTED_NODE_COUNT;
nodes = partialContext.getNodes();
node.replaceChild(nodes[0], node.childNodes[j]);
for (k = 1; k < nodes.length; k++) {
node.insertBefore(nodes[k], nodes[k - 1].nextSibling);
}
} else if (node.childNodes[j].nodeType === 1) {
//element nodes
highlightRecursive.call(this, node.childNodes[j]);
}
}
//indicate that this node has been highlighted
node.className += " " + this.options.classPrefix + "highlighted";
//if the node is block level, we put it in a container, otherwise we just leave it alone
if (getComputedStyle(node, "display") === "block") {
container = document.createElement("div");
container.className = this.options.classPrefix + "container";
codeContainer = document.createElement("div");
codeContainer.className = this.options.classPrefix + "code-container";
//apply max height if specified in options
if (this.options.maxHeight !== false) {
codeContainer.style.overflowY = "auto";
codeContainer.style.maxHeight = this.options.maxHeight + (/^\d+$/.test(this.options.maxHeight) ? "px" : "");
}
container.appendChild(codeContainer);
node.parentNode.insertBefore(codeContainer, node);
node.parentNode.removeChild(node);
codeContainer.appendChild(node);
codeContainer.parentNode.insertBefore(container, codeContainer);
codeContainer.parentNode.removeChild(codeContainer);
container.appendChild(codeContainer);
}
fireEvent("afterHighlightNode", this, {
container: container,
codeContainer: codeContainer,
node: node,
count: currentNodeCount
});
}
};
}());
//public facing object
window.Sunlight = {
version: "1.18",
Highlighter: Highlighter,
createAnalyzer: function() { return create(defaultAnalyzer); },
globalOptions: globalOptions,
highlightAll: function(options) {
var highlighter = new Highlighter(options),
tags = document.getElementsByTagName("*"),
i;
for (i = 0; i < tags.length; i++) {
highlighter.highlightNode(tags[i]);
}
},
registerLanguage: function(languageId, languageData) {
var tokenName,
embeddedLanguages,
languageName;
if (!languageId) {
throw "Languages must be registered with an identifier, e.g. \"php\" for PHP";
}
languageData = merge(merge({}, languageDefaults), languageData);
languageData.name = languageId;
//transform keywords, operators and custom tokens into a hash map
languageData.keywords = createHashMap(languageData.keywords || [], "\\b", languageData.caseInsensitive);
languageData.operators = createHashMap(languageData.operators || [], "", languageData.caseInsensitive);
for (tokenName in languageData.customTokens) {
languageData.customTokens[tokenName] = createHashMap(
languageData.customTokens[tokenName].values,
languageData.customTokens[tokenName].boundary,
languageData.caseInsensitive
);
}
//convert the embedded language object to an easier-to-use array
embeddedLanguages = [];
for (languageName in languageData.embeddedLanguages) {
embeddedLanguages.push({
parentLanguage: languageData.name,
language: languageName,
switchTo: languageData.embeddedLanguages[languageName].switchTo,
switchBack: languageData.embeddedLanguages[languageName].switchBack
});
}
languageData.embeddedLanguages = embeddedLanguages;
languages[languageData.name] = languageData;
},
isRegistered: function(languageId) { return languages[languageId] !== undefined; },
bind: function(event, callback) {
if (!events[event]) {
throw "Unknown event \"" + event + "\"";
}
events[event].push(callback);
},
util: {
last: last,
regexEscape: regexEscape,
eol: EOL,
clone: clone,
escapeSequences: ["\\n", "\\t", "\\r", "\\\\", "\\v", "\\f"],
contains: contains,
matchWord: matchWord,
createHashMap: createHashMap,
createBetweenRule: createBetweenRule,
createProceduralRule: createProceduralRule,
getNextNonWsToken: function(tokens, index) { return getNextWhile(tokens, index, 1, function(token) { return token.name === "default"; }); },
getPreviousNonWsToken: function(tokens, index) { return getNextWhile(tokens, index, -1, function(token) { return token.name === "default"; }); },
getNextWhile: function(tokens, index, matcher) { return getNextWhile(tokens, index, 1, matcher); },
getPreviousWhile: function(tokens, index, matcher) { return getNextWhile(tokens, index, -1, matcher); },
whitespace: { token: "default", optional: true },
getComputedStyle: getComputedStyle
}
};
//register the default language
window.Sunlight.registerLanguage(DEFAULT_LANGUAGE, { punctuation: /(?!x)x/, numberParser: EMPTY });
}(this, document));