CaoPig：搬运自H萌娘User:Irukaza/tools/wikihighlight.js

2026-08-01T08:45:51Z

搬运自H萌娘User:Irukaza/tools/wikihighlight.js

新页面

//<pre> Disable signature replacing
CodeMirror.defineMode('mediawiki', function() {
function arrayRemove(array, object) {
var index = array.indexOf(object);
if (index !== -1) array.splice(index, 1);
}

var module = {};
var config = {
protocols: [
'bitcoin:', 'ftp://', 'ftps://', 'geo:', 'git://', 'gopher://', 'http://',
'https://', 'irc://', 'ircs://', 'magnet:', 'mailto:', 'mms://', 'news:',
'nntp://', 'redis://', 'sftp://', 'sip:', 'sips:', 'sms:', 'ssh://',
'svn://', 'tel:', 'telnet://', 'urn:', 'worldwind://', 'xmpp:',
// Note '//'' should not be included here
],
linktrail: false
};

var EXT_LINK_ADDR = /(?:[0-9.]+|\[[0-9a-fA-F:.]+\]|[^\]\[<>"\s])/; // Match host name, include IPv4, IPv6 and Domain name
var EXT_LINK_PROTOCOL_NOREL = new RegExp(config.protocols.join('|'));
var EXT_LINK_PROTOCOL = new RegExp(config.protocols.join('|') + '|//');
var EXT_LINK_URL = /(?:[0-9.]+|\[[0-9a-fA-F:.]+\]|[^\]\[<>"\s])[^\]\[<>"\s]*/;

var ALLOWED_TAGS = {
bdi: true,
ins: true,
u: true,
font: true,
big: true,
small: true,
sub: true,
sup: true,
h1: true,
h2: true,
h3: true,
h4: true,
h5: true,
h6: true,
cite: true,
code: true,
strike: true,
tt: true,
var: true,
div: true,
center: true,
blockquote: true,
ol: true,
ul: true,
dl: true,
table: true,
caption: true,
pre: true,
ruby: true,
rb: true,
rp: true,
rt: true,
rtc: true,
p: true,
span: true,
abbr: true,
dfn: true,
kbd: true,
samp: true,
data: true,
time: true,
mark: true,
br: false,
wbr: false,
hr: false,
li: true,
dt: true,
dd: true,
td: true,
th: true,
tr: true,
// These tags are added here but they are not html
noinclude: true,
includeonly: true,
onlyinclude: true,
style: true,
script: true
};

function generateStyleMixinTagHandler(style) {
return {
open: function(stream, state) {
state.mixinStyle.push(style);
},
close: function(stream, state) {
var index = state.mixinStyle.indexOf(style);
if (index !== -1) state.mixinStyle.splice(index, 1);
}
};
}

ALLOWED_TAGS['s'] = ALLOWED_TAGS['strike'] = ALLOWED_TAGS['del'] = generateStyleMixinTagHandler('strikethrough'); // Alias
ALLOWED_TAGS['b'] = ALLOWED_TAGS['strong'] = generateStyleMixinTagHandler('strong'); // Alias
ALLOWED_TAGS['i'] = ALLOWED_TAGS['em'] = generateStyleMixinTagHandler('em'); // Alias

ALLOWED_TAGS['nowiki'] = {
open: function(stream, state) {
state.unclosedTags.pop();
state.handler = parseNowikiTag;
},
canSelfClose: true
// close never reached
};

ALLOWED_TAGS['pre'] = {
open: function(stream, state) {
state.mixinStyle.push('mw-pre');
state.unclosedTags.pop();
state.handler = parsePreTag;
},
canSelfClose: true
// close never reached
};

// Extension:Cite
ALLOWED_TAGS['ref'] = true;
ALLOWED_TAGS['references'] = false;

// Other extensions
ALLOWED_TAGS['categorytree'] = true;
ALLOWED_TAGS['charinsert'] = true;
ALLOWED_TAGS['choose'] = true;
ALLOWED_TAGS['dynamicpagelist'] = true;
ALLOWED_TAGS['flashmp3'] = true;
ALLOWED_TAGS['gallery'] = true;
ALLOWED_TAGS['imagemap'] = true;
ALLOWED_TAGS['indicator'] = true;
ALLOWED_TAGS['inputbox'] = true;
ALLOWED_TAGS['poem'] = true;
ALLOWED_TAGS['poll'] = true;
ALLOWED_TAGS['sm2'] = true;

// Utility
function tagCanSelfClose(tagname) {
var tag = ALLOWED_TAGS[tagname];
if (tag === false) {
return true;
}
if (typeof tag !== 'object') {
return false;
}
if ('canSelfClose' in tag) {
return tag.canSelfClose;
}
return false;
}

function makeStyle(style, state) {
if (state.bold) {
style += ' strong';
}
if (state.italic) {
style += ' em';
}
style += ' ' + state.mixinStyle.join(' ');
return style;
}

function parseWikitext(stream, state) {
var sol = stream.sol();

var match = stream.match(EXT_LINK_PROTOCOL_NOREL);
if (match) {
if (stream.match(EXT_LINK_ADDR, false)) {
// The URL must looks like a URL
state.stack.push(state.handler);
state.handler = parseFreeExternalLink;
return 'mw-extlink';
} else {
// Does not look like URL, backUp
stream.backUp(match[0].length);
}
}

stream.backUp(1);
var sow = !/\w/.exec(stream.next());

if (sow) {
match = stream.match(/(?:ISBN|RFC|PMID)\s+/);
if (match) {
if (match[0].startsWith('ISBN')) {
var match2 = stream.match(/(?:97[89][- ]?)?(?:[0-9][- ]?){9}[0-9Xx]\b/);
if (match2) {
return 'mw-isbn';
}
} else {
var match2 = stream.match(/[0-9]+\b/);
if (match2) {
if (match[0].startsWith('RFC')) {
return 'mw-rfc';
} else {
return 'mw-pmid';
}
}
}
stream.backUp(match[0].length);
}
}

if (sol) {
// Table
if (stream.match(/\s*(:*)\s*(?=\{\|)/)) {
state.stack.push(state.handler);
state.handler = parseTableStart;
return 'mw-ident';
}
switch (stream.peek()) {
case '-':
if (stream.match(/-{4,}/)) {
return 'mw-hr';
}
break;
case '#': // TODO #REDIRECT
case '*':
case ';':
case ':':
stream.match(/[*#;:]*/);
return 'mw-ident';
case ' ':
stream.next();
return 'line-cm-mw-pre';
case '=':
match = stream.match(/(={1,6})(?=.+?\1\s*$)/);
if (match) {
state.handler = makeParseSectionHeader(match[1].length);
return 'mw-section line-cm-mw-section-' + match[1].length;
}
break;
}
}

switch (stream.peek()) {
case '\'':
if (stream.match(/'+(?=''''')/)) { // more than 5 apostrophes, only last five are considered
return makeStyle('', state);
}
if (stream.match(/'(?='''(?!'))/)) { // 4 apostrophes, only last three are considered
return makeStyle('', state);
}
if (stream.match("'''")) {
if (!state.bold) {
state.bold = true;
return 'mw-bold-start';
} else {
state.bold = false;
return 'mw-bold-end';
}
} else if (stream.match("''")) {
if (!state.italic) {
state.italic = true;
return 'mw-italic-start';
} else {
state.italic = false;
return 'mw-italic-end';
}
}
// TODO Mismatch Recovery
break;
case '~':
var match = stream.match(/~{3,5}/);
if (match) {
return 'mw-signature';
}
break;
case '_':
if (sow) {
var match = stream.match(/\b__[A-Z_]+?__/);
if (match) {
return 'mw-magic-word';
}
}
break;
case '{':
if (stream.match('{{')) {
state.stack.push(state.handler);
state.handler = parseTemplateName;
return 'mw-template-start';
}
break;
case '[':
if (stream.match('[[')) {
if (!stream.match(/[^\|\[\]]+(?:\|.*?)?\]\]/, false)) { // Not a link
return makeStyle('', state);
}
state.stack.push(state.handler);
state.handler = parseLinkTarget;
return 'mw-link-start';
} else {
stream.next();
var match = stream.match(EXT_LINK_PROTOCOL);
if (match) {
if (stream.match(EXT_LINK_ADDR, false) && stream.match(/.+?]/, false)) {
// The URL must looks like a URL
state.stack.push(state.handler);
state.handler = parseExternalLink;
// Still have to back up the URL, rendered differently
stream.backUp(match[0].length);
return 'mw-extlink-start';
} else {
// Does not look like URL, backUp
stream.backUp(match[0].length);
}
}
// Bug reported by AnnAngela
// [{{}} does not render correctly
return makeStyle('', state);
}
break;
case '&':
return parseEntityOnly(stream, state);
case '<':
if (stream.match('')) {
state.handler = state.stack.pop();
} else {
stream.next();
}
return 'mw-comment';
}

function parseTableStart(stream, state) {
stream.match('{|');
state.handler = state.stack.pop();
return 'mw-table-start';
}

function makeParseOpenTag(tagname, selfClose) {
return function(stream, state) {
if (stream.match(/\/?>/)) {
if (!selfClose) {
state.handler = parseWikitext;
if (typeof(ALLOWED_TAGS[tagname]) === 'object') {
ALLOWED_TAGS[tagname].open(stream, state);
}
} else {
state.handler = state.stack.pop();
}
return 'mw-tag-open';
} else {
stream.next();
return 'mw-tag-attr';
}
};
}

function parseEntityOnly(stream, state) {
if (stream.next() === '&') {
var success;
if (stream.eat('#')) {
if (stream.eat('x')) {
success = stream.eatWhile(/[a-fA-F\d]/);
} else {
success = stream.eatWhile(/[\d]/);
}
} else {
success = stream.eatWhile(/[\w\.\-:]/);
}
if (success) {
success = stream.eat(';');
}
if (success) {
return makeStyle('mw-entity', state);
}
}
return makeStyle('', state);
}

/* Internal link parsing */

function parseLinkTarget(stream, state) {
stream.match(/.+?(?=\||\]\])/);
if (stream.peek() === '|') {
state.handler = parseLinkPipe;
} else {
state.handler = parseLinkEnd;
}
return 'mw-link-target';
}

function parseLinkEnd(stream, state) {
stream.match(']]');
if (config.linktrail) {
state.handler = parseLinkTrail;
} else {
state.handler = state.stack.pop();
}
return 'mw-link-end';
}

function parseLinkTrail(stream, state) {
stream.match(/\w*/);
state.handler = state.stack.pop();
return 'mw-link-trail';
}

function parseLinkPipe(stream, state) {
stream.match('|');
state.handler = parseLinkText;
return 'mw-link-pipe';
}

function parseLinkText(stream, state) {
if (stream.match(']]', false)) {
// Maybe just return directly?
state.handler = parseLinkEnd;
return '';
}
var ret = parseWikitext(stream, state);
return ret + ' mw-link-text';
}

// External link parsing
function parseExternalLink(stream, state) {
var match = stream.match(EXT_LINK_URL);
var text = match[0];

// {{, ~~~, '' will start their effect, so detect and correct
var match = new RegExp("\\{\\{|~~~|''").exec(text);
if (match) {
// Pushback the wrongly included part
stream.backUp(text.length - match.index);
text = text.substring(0, match.index);
}

state.handler = parseExternalLinkText;
return 'mw-extlink-target';
}

function parseExternalLinkText(stream, state) {
if (stream.eat(']')) {
state.handler = state.stack.pop();
return 'mw-extlink-end';
}
var ret = parseWikitext(stream, state);
return ret + ' mw-link-text';
}

// Template

function parseTemplateName(stream, state) {
if (stream.eat('|')) {
if (stream.match(/[^\|\{\}]*=/, false)) {
state.handler = parseTemplateArgName;
} else {
state.handler = parseTemplateArg;
}
return 'mw-template-pipe';
}
if (stream.match('}}')) {
state.handler = state.stack.pop();
return 'mw-template-end';
}
stream.next();
return 'mw-template-name';
}

function parseTemplateArg(stream, state) {
if (stream.eat('|')) {
if (stream.match(/[^\|\{\}]*=/, false)) {
state.handler = parseTemplateArgName;
}
return 'mw-template-pipe';
}
if (stream.match('}}')) {
state.handler = state.stack.pop();
return 'mw-template-end';
}
var ret = parseWikitext(stream, state);
return ret + ' mw-template-arg';
}

function parseTemplateArgName(stream, state) {
if (stream.eat('=')) {
state.handler = parseTemplateArg;
return 'mw-template-assign';
}
// The below two cases are rare cases, where simple regex for detecting = fails
if (stream.eat('|')) {
if (!stream.match(/[^\|\{\}]*=/, false)) {
state.handler = parseTemplateArg;
}
return 'mw-template-pipe';
}
if (stream.match('}}')) {
state.handler = state.stack.pop();
return 'mw-template-end';
}
var ret = parseWikitext(stream, state);
return ret + ' mw-template-argname';
}

// Tag handlers

function parseNowikiTag(stream, state) {
if (stream.match(/<\/nowiki\s*>/)) {
state.handler = state.stack.pop();
return 'mw-tag-close';
}
return parseEntityOnly(stream, state);
}

function parsePreTag(stream, state) {
if (stream.match(/<\/pre\s*>/)) {
state.handler = state.stack.pop();
arrayRemove(state.mixinStyle, 'mw-pre');
return 'mw-tag-close';
}
return parseEntityOnly(stream, state);
}

module.startState = function() {
return {
handler: parseWikitext,
bold: false,
italic: false,
mixinStyle: [],
unclosedTags: [],
stack: []
};
};

module.copyState = function(state) {
return {
handler: state.handler,
bold: state.bold,
italic: state.italic,
mixinStyle: state.mixinStyle.slice(),
unclosedTags: state.unclosedTags.slice(),
stack: state.stack.slice()
}
};

module.token = function(stream, state) {
if (stream.sol()) {
state.bold = false;
state.italic = false;
}
try {
return state.handler(stream, state);
} catch (e) {
stream.next();
state.handler = parseWikitext;
console.error('Error in WikiHighlight', e.stack || e);
return null;
}
}

return module;
});

$(function() {
var target = $('#wpTextbox1');
if(target.length) {
var cm = CodeMirror.fromTextArea(target[0], {
lineNumbers: true,
lineWrapping: true,
mode: 'mediawiki'
});
cm.on('change', function () {
target.trigger('input');
});
$.valHooks['textarea'] = {
get: function(elem){ if(elem === target[0]) return cm.getValue(); else return elem.value; },
set: function(elem, value){ if(elem === target[0]) cm.setValue(value); else elem.value = value; }
};
var origTextSelection = $.fn.textSelection;
$.fn.textSelection = function(command, options) {
if (cm.getTextArea() !== this[0]) {
return origTextSelection.call(this, command, options);
}
var fn, retval;

fn = {
/**
* Get the contents of the textarea
*/
getContents: function() {
return cm.doc.getValue();
},

setContents: function(newContents) {
cm.doc.setValue(newContents);
},

/**
* Get the currently selected text in this textarea. Will focus the textarea
* in some browsers (IE/Opera)
*/
getSelection: function() {
return cm.doc.getSelection();
},

/**
* Inserts text at the beginning and end of a text selection, optionally
* inserting text at the caret when selection is empty.
*/
encapsulateSelection: function(options) {
return this.each(function() {
var insertText,
selText,
selectPeri = options.selectPeri,
pre = options.pre,
post = options.post,
startCursor = cm.doc.getCursor(true),
endCursor = cm.doc.getCursor(false);

if (options.selectionStart !== undefined) {
// fn[command].call( this, options );
fn.setSelection({
start: options.selectionStart,
end: options.selectionEnd
}); // not tested
}

selText = cm.doc.getSelection();
if (!selText) {
selText = options.peri;
} else if (options.replace) {
selectPeri = false;
selText = options.peri;
} else {
selectPeri = false;
while (selText.charAt(selText.length - 1) === ' ') {
// Exclude ending space char
selText = selText.substring(0, selText.length - 1);
post += ' ';
}
while (selText.charAt(0) === ' ') {
// Exclude prepending space char
selText = selText.substring(1, selText.length);
pre = ' ' + pre;
}
}

/**
* Do the splitlines stuff.
*
* Wrap each line of the selected text with pre and post
*/
function doSplitLines(selText, pre, post) {
var i,
insertText = '',
selTextArr = selText.split('\n');

for (i = 0; i < selTextArr.length; i++) {
insertText += pre + selTextArr[i] + post;
if (i !== selTextArr.length - 1) {
insertText += '\n';
}
}
return insertText;
}

if (options.splitlines) {
selectPeri = false;
insertText = doSplitLines(selText, pre, post);
} else {
insertText = pre + selText + post;
}

if (options.ownline) {
if (startCursor.ch !== 0) {
insertText = '\n' + insertText;
pre += '\n';
}

if (cm.doc.getLine(endCursor.line).length !== endCursor.ch) {
insertText += '\n';
post += '\n';
}
}

cm.doc.replaceSelection(insertText);

if (selectPeri) {
cm.doc.setSelection(
cm.doc.posFromIndex(cm.doc.indexFromPos(startCursor) + pre.length),
cm.doc.posFromIndex(cm.doc.indexFromPos(startCursor) + pre.length + selText.length)
);
}
});
},

/**
* Get the position (in resolution of bytes not necessarily characters)
* in a textarea
*/
getCaretPosition: function(options) {
var caretPos = cm.doc.indexFromPos(cm.doc.getCursor(true)),
endPos = cm.doc.indexFromPos(cm.doc.getCursor(false));
if (options.startAndEnd) {
return [caretPos, endPos];
}
return caretPos;
},

setSelection: function(options) {
return this.each(function() {
cm.doc.setSelection(cm.doc.posFromIndex(options.start), cm.doc.posFromIndex(options.end));
});
},

/**
* Scroll a textarea to the current cursor position. You can set the cursor
* position with setSelection()
*/
scrollToCaretPosition: function() {
return this.each(function() {
cm.scrollIntoView(null);
});
}
};

switch (command) {
// case 'getContents': // no params
// case 'setContents': // no params with defaults
// case 'getSelection': // no params
case 'encapsulateSelection':
options = $.extend({
pre: '', // Text to insert before the cursor/selection
peri: '', // Text to insert between pre and post and select afterwards
post: '', // Text to insert after the cursor/selection
ownline: false, // Put the inserted text on a line of its own
replace: false, // If there is a selection, replace it with peri instead of leaving it alone
selectPeri: true, // Select the peri text if it was inserted (but not if there was a selection and replace==false, or if splitlines==true)
splitlines: false, // If multiple lines are selected, encapsulate each line individually
selectionStart: undefined, // Position to start selection at
selectionEnd: undefined // Position to end selection at. Defaults to start
}, options);
break;
case 'getCaretPosition':
options = $.extend({
// Return [start, end] instead of just start
startAndEnd: false
}, options);
// FIXME: We may not need character position-based functions if we insert markers in the right places
break;
case 'setSelection':
options = $.extend({
// Position to start selection at
start: undefined,
// Position to end selection at. Defaults to start
end: undefined,
// Element to start selection in (iframe only)
startContainer: undefined,
// Element to end selection in (iframe only). Defaults to startContainer
endContainer: undefined
}, options);

if (options.end === undefined) {
options.end = options.start;
}
if (options.endContainer === undefined) {
options.endContainer = options.startContainer;
}
// FIXME: We may not need character position-based functions if we insert markers in the right places
break;
case 'scrollToCaretPosition':
options = $.extend({
force: false // Force a scroll even if the caret position is already visible
}, options);
break;
}

retval = fn[command].call(this, options);

return retval;
};
};
});
//</pre>

Wikihighlight.js - 版本历史

CaoPig：​搬运自H萌娘User:Irukaza/tools/wikihighlight.js

CaoPig：搬运自H萌娘User:Irukaza/tools/wikihighlight.js