tiddlywiki 5.3.7 → 5.4.0

package/core/modules/parsers/parseutils.js

@@ -45,7 +45,7 @@ exports.parseWhiteSpace = function(source,pos) {
 			type: "whitespace",
 			start: pos,
 			end: p
-		}
+		};
 	}
 };
 
@@ -82,6 +82,7 @@ exports.parseTokenString = function(source,pos,token) {
 
 /*
 Look for a token matching a regex. Returns null if not found, otherwise returns {type: "regexp", match:, start:, end:,}
+Use the "Y" (sticky) flag to avoid searching the entire rest of the string
 */
 exports.parseTokenRegExp = function(source,pos,reToken) {
 	var node = {
@@ -106,13 +107,14 @@ exports.parseStringLiteral = function(source,pos) {
 		type: "string",
 		start: pos
 	};
-	var reString = /(?:"""([\s\S]*?)"""|"([^"]*)")|(?:'([^']*)')/g;
+	var reString = /(?:"""([\s\S]*?)"""|"([^"]*)")|(?:'([^']*)')|\[\[((?:[^\]]|\](?!\]))*)\]\]/y;
 	reString.lastIndex = pos;
 	var match = reString.exec(source);
 	if(match && match.index === pos) {
 		node.value = match[1] !== undefined ? match[1] :(
-			match[2] !== undefined ? match[2] : match[3]
-					);
+			match[2] !== undefined ? match[2] : (
+				match[3] !== undefined ? match[3] : match[4]
+			));
 		node.end = pos + match[0].length;
 		return node;
 	} else {
@@ -141,7 +143,14 @@ exports.parseParameterDefinition = function(paramString,options) {
 		var paramInfo = {name: paramMatch[1]},
 			defaultValue = paramMatch[2] || paramMatch[3] || paramMatch[4] || paramMatch[5];
 		if(defaultValue !== undefined) {
-			paramInfo["default"] = defaultValue;
+			// Check for an MVV reference ((varname))
+			var mvvDefaultMatch = /^\(\(([^)|]+)\)\)$/.exec(defaultValue);
+			if(mvvDefaultMatch) {
+				paramInfo.defaultType = "multivalue-variable";
+				paramInfo.defaultVariable = mvvDefaultMatch[1];
+			} else {
+				paramInfo["default"] = defaultValue;
+			}
 		}
 		params.push(paramInfo);
 		// Look for the next parameter
@@ -161,7 +170,7 @@ exports.parseMacroParameters = function(node,source,pos) {
 	}
 	node.end = pos;
 	return node;
-}
+};
 
 /*
 Look for a macro invocation parameter. Returns null if not found, or {type: "macro-parameter", name:, value:, start:, end:}
@@ -172,7 +181,7 @@ exports.parseMacroParameter = function(source,pos) {
 		start: pos
 	};
 	// Define our regexp
-	var reMacroParameter = /(?:([A-Za-z0-9\-_]+)\s*:)?(?:\s*(?:"""([\s\S]*?)"""|"([^"]*)"|'([^']*)'|\[\[([^\]]*)\]\]|((?:(?:>(?!>))|[^\s>"'])+)))/g;
+	const reMacroParameter = /(?:([A-Za-z0-9\-_]+)\s*:)?(?:\s*(?:"""([\s\S]*?)"""|"([^"]*)"|'([^']*)'|\[\[((?:[^\]]|\](?!\]))*)\]\]|((?:(?:>(?!>))|[^\s>"'])+)))/y;
 	// Skip whitespace
 	pos = $tw.utils.skipWhiteSpace(source,pos);
 	// Look for the parameter
@@ -183,16 +192,16 @@ exports.parseMacroParameter = function(source,pos) {
 	pos = token.end;
 	// Get the parameter details
 	node.value = token.match[2] !== undefined ? token.match[2] : (
-					token.match[3] !== undefined ? token.match[3] : (
-						token.match[4] !== undefined ? token.match[4] : (
-							token.match[5] !== undefined ? token.match[5] : (
-								token.match[6] !== undefined ? token.match[6] : (
-									""
-								)
-							)
-						)
+		token.match[3] !== undefined ? token.match[3] : (
+			token.match[4] !== undefined ? token.match[4] : (
+				token.match[5] !== undefined ? token.match[5] : (
+					token.match[6] !== undefined ? token.match[6] : (
+						""
 					)
-				);
+				)
+			)
+		)
+	);
 	if(token.match[1]) {
 		node.name = token.match[1];
 	}
@@ -205,28 +214,223 @@ exports.parseMacroParameter = function(source,pos) {
 Look for a macro invocation. Returns null if not found, or {type: "transclude", attributes:, start:, end:}
 */
 exports.parseMacroInvocationAsTransclusion = function(source,pos) {
-	var node = $tw.utils.parseMacroInvocation(source,pos);
-	if(node) {
-		var positionalName = 0,
-			transclusion = {
-				type: "transclude",
-				start: node.start,
-				end: node.end
-			};
-		$tw.utils.addAttributeToParseTreeNode(transclusion,"$variable",node.name);
-		$tw.utils.each(node.params,function(param) {
-			var name = param.name;
-			if(name) {
-				if(name.charAt(0) === "$") {
-					name = "$" + name;
-				}
-				$tw.utils.addAttributeToParseTreeNode(transclusion,{name: name,type: "string", value: param.value, start: param.start, end: param.end});
-			} else {
-				$tw.utils.addAttributeToParseTreeNode(transclusion,{name: (positionalName++) + "",type: "string", value: param.value, start: param.start, end: param.end});
+	var node = {
+		type: "transclude",
+		start: pos,
+		attributes: {},
+		orderedAttributes: []
+	};
+	// Define our regexps
+	var reVarName = /([^\s>"'=:]+)/y;
+	// Skip whitespace
+	pos = $tw.utils.skipWhiteSpace(source,pos);
+	// Look for a double opening angle bracket
+	var token = $tw.utils.parseTokenString(source,pos,"<<");
+	if(!token) {
+		return null;
+	}
+	pos = token.end;
+	// Get the variable name for the macro
+	token = $tw.utils.parseTokenRegExp(source,pos,reVarName);
+	if(!token) {
+		return null;
+	}
+	$tw.utils.addAttributeToParseTreeNode(node,"$variable",token.match[1]);
+	pos = token.end;
+	// Check that the tag is terminated by a space or >>, and that there is a closing >> somewhere ahead
+	if(!(source.charAt(pos) === ">" && source.charAt(pos + 1) === ">") ) {
+		if(source.indexOf(">>",pos) === -1) {
+			return null;
+		}
+	}
+	// Process attributes
+	pos = $tw.utils.parseMacroParametersAsAttributes(node,source,pos);
+	// Skip whitespace
+	pos = $tw.utils.skipWhiteSpace(source,pos);
+	// Look for a double closing angle bracket
+	token = $tw.utils.parseTokenString(source,pos,">>");
+	if(!token) {
+		return null;
+	}
+	node.end = token.end;
+	return node;
+};
+
+/*
+Look for an MVV (multi-valued variable) reference as a transclusion, i.e. ((varname)) or ((varname params))
+Returns null if not found, or a parse tree node of type "transclude" with isMVV: true
+*/
+exports.parseMVVReferenceAsTransclusion = function(source,pos) {
+	var node = {
+		type: "transclude",
+		isMVV: true,
+		start: pos,
+		attributes: {},
+		orderedAttributes: []
+	};
+	// Define our regexps
+	var reVarName = /([^\s>"'=:)]+)/y;
+	// Skip whitespace
+	pos = $tw.utils.skipWhiteSpace(source,pos);
+	// Look for a double opening parenthesis
+	var token = $tw.utils.parseTokenString(source,pos,"((");
+	if(!token) {
+		return null;
+	}
+	pos = token.end;
+	// Get the variable name
+	token = $tw.utils.parseTokenRegExp(source,pos,reVarName);
+	if(!token) {
+		return null;
+	}
+	$tw.utils.addAttributeToParseTreeNode(node,"$variable",token.match[1]);
+	pos = token.end;
+	// Skip whitespace
+	pos = $tw.utils.skipWhiteSpace(source,pos);
+	// Look for a double closing parenthesis
+	token = $tw.utils.parseTokenString(source,pos,"))");
+	if(!token) {
+		return null;
+	}
+	node.end = token.end;
+	return node;
+};
+
+/*
+Parse macro parameters as attributes. Returns the position after the last attribute
+*/
+exports.parseMacroParametersAsAttributes = function(node,source,pos) {
+	var position = 0,
+		attribute = $tw.utils.parseMacroParameterAsAttribute(source,pos);
+	while(attribute) {
+		if(!attribute.name) {
+			attribute.name = (position++) + "";
+			attribute.isPositional = true;
+		}
+		node.orderedAttributes.push(attribute);
+		node.attributes[attribute.name] = attribute;
+		pos = attribute.end;
+		// Get the next attribute
+		attribute = $tw.utils.parseMacroParameterAsAttribute(source,pos);
+	}
+	node.end = pos;
+	return pos;
+};
+
+/*
+Parse a macro parameter as an attribute. Returns null if not found, otherwise returns {name:, type: "filtered|string|indirect|macro", value|filter|textReference:, start:, end:,}, with the name being optional
+*/
+exports.parseMacroParameterAsAttribute = function(source,pos) {
+	var node = {
+		start: pos
+	};
+	// Define our regexps
+	var reAttributeName = /([^\/\s>"'`=:]+)/y,
+		reStrictIdentifier = /^[A-Za-z0-9\-_]+$/,
+		reUnquotedAttribute = /(?!<<)((?:(?:>(?!>))|[^\s>"'])+)/y,
+		reFilteredValue = /\{\{\{([\S\s]+?)\}\}\}/y,
+		reIndirectValue = /\{\{([^\}]+)\}\}/y,
+		reSubstitutedValue = /(?:```([\s\S]*?)```|`([^`]|[\S\s]*?)`)/y;
+	// Skip whitespace
+	pos = $tw.utils.skipWhiteSpace(source,pos);
+	// Get the attribute name and the separator token
+	var nameToken = $tw.utils.parseTokenRegExp(source,pos,reAttributeName),
+		namePos = nameToken && $tw.utils.skipWhiteSpace(source,nameToken.end),
+		separatorToken = nameToken && $tw.utils.parseTokenRegExp(source,namePos,/=|:/y),
+		isNewStyleSeparator = false; // If there is no separator then we don't allow new style values
+	// Colon separator requires a strict identifier name to avoid mis-parsing values like $:/foo
+	if(nameToken && separatorToken && separatorToken.match[0] === ":" && !reStrictIdentifier.test(nameToken.match[1])) {
+		nameToken = null;
+		separatorToken = null;
+	}
+	// If we have a name and a separator then we have a named attribute
+	if(nameToken && separatorToken) {
+		node.name = nameToken.match[1];
+		// key value separator is `=` or `:`
+		node.assignmentOperator = separatorToken.match[0];
+		pos = separatorToken.end;
+		isNewStyleSeparator = (node.assignmentOperator === "=");
+	}
+	// Skip whitespace
+	pos = $tw.utils.skipWhiteSpace(source,pos);
+
+	do {
+		// Look for a string literal
+		var stringLiteral = $tw.utils.parseStringLiteral(source,pos);
+		if(stringLiteral) {
+			pos = stringLiteral.end;
+			node.type = "string";
+			node.value = stringLiteral.value;
+			// Mark the value as having been quoted in the source
+			node.quoted = true;
+			break;
+		}
+
+		if(isNewStyleSeparator) {
+			// Look for a filtered value
+			var filteredValue = $tw.utils.parseTokenRegExp(source,pos,reFilteredValue);
+			if(filteredValue) {
+				pos = filteredValue.end;
+				node.type = "filtered";
+				node.filter = filteredValue.match[1];
+				break;
+			}
+
+			// Look for an indirect value
+			var indirectValue = $tw.utils.parseTokenRegExp(source,pos,reIndirectValue);
+			if(indirectValue) {
+				pos = indirectValue.end;
+				node.type = "indirect";
+				node.textReference = indirectValue.match[1];
+				break;
+			}
+
+			// Look for a macro invocation value
+			var macroInvocation = $tw.utils.parseMacroInvocationAsTransclusion(source,pos);
+			if(macroInvocation) {
+				pos = macroInvocation.end;
+				node.type = "macro";
+				node.value = macroInvocation;
+				break;
 			}
-		});
-		return transclusion;
+
+			// Look for an MVV reference value
+			var mvvReference = $tw.utils.parseMVVReferenceAsTransclusion(source,pos);
+			if(mvvReference) {
+				pos = mvvReference.end;
+				node.type = "macro";
+				node.value = mvvReference;
+				node.isMVV = true;
+				break;
+			}
+
+			// Look for a substituted value
+			var substitutedValue = $tw.utils.parseTokenRegExp(source,pos,reSubstitutedValue);
+			if(substitutedValue) {
+				pos = substitutedValue.end;
+				node.type = "substituted";
+				node.rawValue = substitutedValue.match[1] || substitutedValue.match[2];
+				break;
+			}
+		}
+
+		// Look for a unquoted value
+		var unquotedValue = $tw.utils.parseTokenRegExp(source,pos,reUnquotedAttribute);
+		if(unquotedValue) {
+			pos = unquotedValue.end;
+			node.type = "string";
+			node.value = unquotedValue.match[1];
+			break; // redundant, but leaving for consistency
+		}
+
+	} while(false);
+
+	// Bail if we don't have a value
+	if(!node.type) {
+		return null;
 	}
+	// Update the end position
+	node.end = pos;
 	return node;
 };
 
@@ -240,7 +444,7 @@ exports.parseMacroInvocation = function(source,pos) {
 		params: []
 	};
 	// Define our regexps
-	var reMacroName = /([^\s>"'=]+)/g;
+	const reMacroName = /([^\s>"'=]+)/y;
 	// Skip whitespace
 	pos = $tw.utils.skipWhiteSpace(source,pos);
 	// Look for a double less than sign
@@ -277,7 +481,7 @@ exports.parseFilterVariable = function(source) {
 			params: [],
 		},
 		pos = 0,
-		reName = /([^\s"']+)/g;
+		reName = /([^\s"']+)/y;
 	// If there is no whitespace or it is an empty string then there are no macro parameters
 	if(/^\S*$/.test(source)) {
 		node.name = source;
@@ -295,18 +499,18 @@ exports.parseFilterVariable = function(source) {
 };
 
 /*
-Look for an HTML attribute definition. Returns null if not found, otherwise returns {type: "attribute", name:, type: "filtered|string|indirect|macro", value|filter|textReference:, start:, end:,}
+Look for an HTML attribute definition. Returns null if not found, otherwise returns {name:, type: "filtered|string|indirect|macro", value|filter|textReference:, start:, end:,}
 */
 exports.parseAttribute = function(source,pos) {
 	var node = {
 		start: pos
 	};
 	// Define our regexps
-	var reAttributeName = /([^\/\s>"'`=]+)/g,
-		reUnquotedAttribute = /([^\/\s<>"'`=]+)/g,
-		reFilteredValue = /\{\{\{([\S\s]+?)\}\}\}/g,
-		reIndirectValue = /\{\{([^\}]+)\}\}/g,
-		reSubstitutedValue = /(?:```([\s\S]*?)```|`([^`]|[\S\s]*?)`)/g;
+	const reAttributeName = /([^\/\s>"'`=]+)/y,
+		reUnquotedAttribute = /([^\/\s<>"'`=]+)/y,
+		reFilteredValue = /\{\{\{([\S\s]+?)\}\}\}/y,
+		reIndirectValue = /\{\{([^\}]+)\}\}/y,
+		reSubstitutedValue = /(?:```([\s\S]*?)```|`([^`]|[\S\s]*?)`)/y;
 	// Skip whitespace
 	pos = $tw.utils.skipWhiteSpace(source,pos);
 	// Get the attribute name
@@ -345,19 +549,20 @@ exports.parseAttribute = function(source,pos) {
 					node.type = "indirect";
 					node.textReference = indirectValue.match[1];
 				} else {
-					// Look for a unquoted value
-					var unquotedValue = $tw.utils.parseTokenRegExp(source,pos,reUnquotedAttribute);
-					if(unquotedValue) {
-						pos = unquotedValue.end;
-						node.type = "string";
-						node.value = unquotedValue.match[1];
+					// Look for a macro invocation value
+					var macroInvocation = $tw.utils.parseMacroInvocationAsTransclusion(source,pos);
+					if(macroInvocation) {
+						pos = macroInvocation.end;
+						node.type = "macro";
+						node.value = macroInvocation;
 					} else {
-						// Look for a macro invocation value
-						var macroInvocation = $tw.utils.parseMacroInvocation(source,pos);
-						if(macroInvocation) {
-							pos = macroInvocation.end;
+						// Look for an MVV reference value
+						var mvvReference = $tw.utils.parseMVVReferenceAsTransclusion(source,pos);
+						if(mvvReference) {
+							pos = mvvReference.end;
 							node.type = "macro";
-							node.value = macroInvocation;
+							node.value = mvvReference;
+							node.isMVV = true;
 						} else {
 							var substitutedValue = $tw.utils.parseTokenRegExp(source,pos,reSubstitutedValue);
 							if(substitutedValue) {
@@ -365,8 +570,19 @@ exports.parseAttribute = function(source,pos) {
 								node.type = "substituted";
 								node.rawValue = substitutedValue.match[1] || substitutedValue.match[2];
 							} else {
-								node.type = "string";
-								node.value = "true";
+								// Look for a unquoted value
+								var unquotedValue = $tw.utils.parseTokenRegExp(source,pos,reUnquotedAttribute);
+								if(unquotedValue) {
+									pos = unquotedValue.end;
+									node.type = "string";
+									node.value = unquotedValue.match[1];
+								} else if(source.charAt(pos) === "<" && source.charAt(pos + 1) === "<" && source.indexOf(">>",pos) !== -1) {
+									// Value looks like a macro invocation (starts with << with a closing >> ahead) but does not parse as one. Return null so the enclosing tag fails to parse rather than silently binding the attribute to "true" and treating the remainder as further attributes (restores v5.3.8 behaviour)
+									return null;
+								} else {
+									node.type = "string";
+									node.value = "true";
+								}
 							}
 						}
 					}
@@ -374,6 +590,7 @@ exports.parseAttribute = function(source,pos) {
 			}
 		}
 	} else {
+		// If there is no equals sign or colon, then this is an attribute with no value, defaulting to "true"
 		node.type = "string";
 		node.value = "true";
 	}

package/core/modules/parsers/pdfparser.js

@@ -11,11 +11,10 @@ The PDF parser embeds a PDF viewer
 
 var ImageParser = function(type,text,options) {
 	var element = {
-			type: "element",
-			tag: "iframe",
-			attributes: {}
-		},
-		src;
+		type: "element",
+		tag: "iframe",
+		attributes: {}
+	};
 	if(options._canonical_uri) {
 		element.attributes.src = {type: "string", value: options._canonical_uri};
 	} else if(text) {

package/core/modules/parsers/videoparser.js

@@ -11,14 +11,13 @@ The video parser parses a video tiddler into an embeddable HTML element
 
 var VideoParser = function(type,text,options) {
 	var element = {
-			type: "element",
-			tag: "video",
-			attributes: {
-				controls: {type: "string", value: "controls"},
-				style: {type: "string", value: "width: 100%; object-fit: contain"}
-			}
-		},
-		src;
+		type: "element",
+		tag: "video",
+		attributes: {
+			controls: {type: "string", value: "controls"},
+			style: {type: "string", value: "width: 100%; object-fit: contain"}
+		}
+	};
 	if(options._canonical_uri) {
 		element.attributes.src = {type: "string", value: options._canonical_uri};
 	} else if(text) {

package/core/modules/parsers/wikiparser/rules/codeblock.js

@@ -46,10 +46,10 @@ exports.parse = function() {
 	}
 	// Return the $codeblock widget
 	return [{
-			type: "codeblock",
-			attributes: {
-					code: {type: "string", value: text, start: codeStart, end: this.parser.pos},
-					language: {type: "string", value: this.match[1], start: languageStart, end: languageEnd}
-			}
+		type: "codeblock",
+		attributes: {
+			code: {type: "string", value: text, start: codeStart, end: this.parser.pos},
+			language: {type: "string", value: this.match[1], start: languageStart, end: languageEnd}
+		}
 	}];
 };

package/core/modules/parsers/wikiparser/rules/commentblock.js

@@ -22,7 +22,7 @@ Note that the syntax for comments is simplified to an opening "<!--" sequence an
 "use strict";
 
 exports.name = "commentblock";
-exports.types = {block:true, pragma:true};
+exports.types = {block: true, pragma: true};
 
 exports.init = function(parser) {
 	this.parser = parser;
@@ -43,9 +43,18 @@ exports.findNextMatch = function(startPos) {
 	return undefined;
 };
 
+
 exports.parse = function() {
 	// Move past the match
 	this.parser.pos = this.endMatchRegExp.lastIndex;
-	// Don't return any elements
-	return [];
+	// Return a node representing the comment that is not rendered
+	var commentStart = this.match.index;
+	var commentEnd = this.endMatch.index + this.endMatch[0].length;
+	return [{
+		type: "void",
+		children: [],
+		text: this.parser.source.slice(commentStart, commentEnd),
+		start: commentStart,
+		end: commentEnd
+	}];
 };

package/core/modules/parsers/wikiparser/rules/commentinline.js

@@ -40,6 +40,13 @@ exports.findNextMatch = function(startPos) {
 exports.parse = function() {
 	// Move past the match
 	this.parser.pos = this.endMatchRegExp.lastIndex;
-	// Don't return any elements
-	return [];
+	// Return a node representing the inline comment
+	var commentStart = this.match.index;
+	var commentEnd = this.endMatch.index + this.endMatch[0].length;
+	return [{
+		type: "void",
+		text: this.parser.source.slice(commentStart, commentEnd),
+		start: commentStart,
+		end: commentEnd
+	}];
 };

package/core/modules/parsers/wikiparser/rules/conditional.js

@@ -95,7 +95,7 @@ exports.parseIfClause = function(filterCondition) {
 			hasLineBreak = !!$tw.utils.parseTokenRegExp(this.parser.source,this.parser.pos,/([^\S\n\r]*\r?\n(?:[^\S\n\r]*\r?\n|$))/g);
 			// If we found an else then we need to parse the body looking for the endif
 			var reEndString = "\\<\\%\\s*(endif)\\s*\\%\\>",
-			ex;
+				ex;
 			if(hasLineBreak) {
 				ex = this.parser.parseBlocksTerminatedExtended(reEndString);
 			} else {

package/core/modules/parsers/wikiparser/rules/emphasis/strikethrough.js

@@ -39,7 +39,7 @@ exports.parse = function() {
 	// Return the classed span
 	return [{
 		type: "element",
-		tag: "strike",
+		tag: "s",
 		children: tree
 	}];
 };

package/core/modules/parsers/wikiparser/rules/entity.js

@@ -26,8 +26,6 @@ exports.init = function(parser) {
 Parse the most recent match
 */
 exports.parse = function() {
-	// Get all the details of the match
-	var entityString = this.match[1];
 	// Move past the macro call
 	this.parser.pos = this.matchRegExp.lastIndex;
 	// Return the entity

package/core/modules/parsers/wikiparser/rules/extlink.js

@@ -28,11 +28,11 @@ exports.init = function(parser) {
 
 exports.parse = function() {
 	// Move past the match
-    var start = this.parser.pos;
+	var start = this.parser.pos;
 	this.parser.pos = this.matchRegExp.lastIndex;
 	// Create the link unless it is suppressed
 	if(this.match[0].substr(0,1) === "~") {
-		return [{type: "text", text: this.match[0].substr(1)}];
+		return [{type: "text", text: this.match[0].substr(1), start: start, end: this.parser.pos}];
 	} else {
 		return [{
 			type: "element",

package/core/modules/parsers/wikiparser/rules/fnprocdef.js

@@ -6,15 +6,15 @@ module-type: wikirule
 Wiki pragma rule for function, procedure and widget definitions
 
 ```
-\function name(param:defaultvalue,param2:defaultvalue)
+\function name(param:"defaultvalue", param2:"defaultvalue")
 definition text
 \end
 
-\procedure name(param:defaultvalue,param2:defaultvalue)
+\procedure name(param:"defaultvalue", param2:"defaultvalue")
 definition text
 \end
 
-\widget $mywidget(param:defaultvalue,param2:defaultvalue)
+\widget $mywidget(param:"defaultvalue", param2:"defaultvalue")
 definition text
 \end
 ```
@@ -32,7 +32,7 @@ Instantiate parse rule
 exports.init = function(parser) {
 	this.parser = parser;
 	// Regexp to match
-	this.matchRegExp = /\\(function|procedure|widget)\s+([^(\s]+)\((\s*([^)]*))?\)(\s*\r?\n)?/mg;
+	this.matchRegExp = /\\(function|procedure|widget)\s+([^(\s]+)\((\s*([^)]*(?:\)\)[^)]*)*))?\)(\s*\r?\n)?/mg;
 };
 
 /*

package/core/modules/parsers/wikiparser/rules/hardlinebreaks.js

@@ -50,6 +50,8 @@ exports.parse = function() {
 			}
 		}
 	} while(match && !match[1]);
-	// Return the nodes
+	// Mark first and last node, and return the nodes
+	if(tree[0]) tree[0].isRuleStart = true;
+	if(tree[tree.length-1]) tree[tree.length-1].isRuleEnd = true;
 	return tree;
 };