isml-linter 5.38.2 → 5.39.0

package/src/isml_tree/IsmlNode.js

@@ -1,47 +1,47 @@
 const MAX_TEXT_DISPLAY_SIZE = 30;
 
-const ConfigUtils = require('../util/ConfigUtils');
-const Constants   = require('../Constants');
-const SfccTags    = require('../enums/SfccTags');
-const ParseUtils  = require('./ParseUtils');
-const MaskUtils   = require('./MaskUtils');
+const ConfigUtils      = require('../util/ConfigUtils');
+const Constants        = require('../Constants');
+const SfccTagContainer = require('../enums/SfccTagContainer');
+const ParseUtils       = require('./ParseUtils');
+const MaskUtils        = require('./MaskUtils');
 
 let ID_COUNTER = 0;
 
 class IsmlNode {
 
     /**
-     * @param {String} value           node opening tag value, including attributes
+     * @param {String} head            node opening tag value, including attributes
      * @param {Number} lineNumber      node starting line number
      * @param {Number} columnNumber    node starting column number
      * @param {Number} globalPos       node starting position since the beginning of the file
      * @param {Boolean} isEmbeddedNode whether the node is part of an embedded "sub tree", as a tag attribute
      */
-    constructor(value = '(root)', lineNumber = 0, columnNumber, globalPos, isEmbeddedNode) {
-        this.id                 = ID_COUNTER++;
-        this.value              = value;         // '<div class="my_class">'
-        this.lineNumber         = lineNumber;    // 7
-        this.columnNumber       = columnNumber;  // 12
-        this.endLineNumber      = lineNumber + ParseUtils.getLineBreakQty(value.trim()); // 9
-        this.globalPos          = globalPos;     // 184
-        this.depth              = 0;             // Isml dom tree node depth
-        this.suffixValue        = '';            // '</div>'
-        this.suffixLineNumber   = null;            // 9
-        this.suffixColumnNumber = null;            // 12
-        this.suffixGlobalPos    = null;            // 207
-        this.parent             = null;          // Parent isml node;
-        this.children           = [];            // Child isml nodes;
-        this.childNo            = 0;
-        this.isEmbeddedNode     = !!isEmbeddedNode;
-    }
-
-    // Suffix is the element corresponding closing tag, such as </div>
-    setSuffix(value, lineNumber, columnNumber, globalPos) {
-        this.suffixValue         += value;
-        this.suffixLineNumber    = lineNumber;
-        this.suffixColumnNumber  = columnNumber;
-        this.suffixGlobalPos     = globalPos;
-        this.suffixEndLineNumber = lineNumber;
+    constructor(head = '(root)', lineNumber = 0, columnNumber, globalPos, isEmbeddedNode) {
+        this.id               = ID_COUNTER++;
+        this.head             = head;          // '<div class="my_class">'
+        this.lineNumber       = lineNumber;    // 7
+        this.columnNumber     = columnNumber;  // 12
+        this.endLineNumber    = lineNumber + ParseUtils.getLineBreakQty(head.trim()); // 9
+        this.globalPos        = globalPos;     // 184
+        this.depth            = 0;             // Isml dom tree node depth
+        this.tail             = '';            // '</div>'
+        this.tailLineNumber   = null;          // 9
+        this.tailColumnNumber = null;          // 12
+        this.tailGlobalPos    = null;          // 207
+        this.parent           = null;          // Parent isml node;
+        this.children         = [];            // Child isml nodes;
+        this.childNo          = 0;
+        this.isEmbeddedNode   = !!isEmbeddedNode;
+    }
+
+    // Tail is the element corresponding closing tag, such as </div>
+    setTail(value, lineNumber, columnNumber, globalPos) {
+        this.tail              += value;
+        this.tailLineNumber    = lineNumber;
+        this.tailColumnNumber  = columnNumber;
+        this.tailGlobalPos     = globalPos;
+        this.tailEndLineNumber = lineNumber;
     }
 
     // Returns a string. Examples: 'div', 'isprint', 'doctype';
@@ -50,9 +50,9 @@ class IsmlNode {
             return 'text';
         }
 
-        const value = this.value.trim();
+        const head = this.head.trim();
 
-        if (value.startsWith('<!--')) {
+        if (head.startsWith('<!--')) {
             return 'html_comment';
         } else if (this.isDocType()) {
             return 'doctype';
@@ -60,9 +60,9 @@ class IsmlNode {
             return 'dynamic_element';
         } else if (this.isContainer()) {
             return 'multi_clause';
-        } else if (!value) {
+        } else if (!head) {
             return 'empty';
-        } else if (value === '(root)') {
+        } else if (head === '(root)') {
             return 'root';
         } else if (!this.isTag()) {
             return 'text';
@@ -70,23 +70,23 @@ class IsmlNode {
 
         const regex = /<[a-zA-Z\d_]*(\s|>|\/)/g;
 
-        return value.match(regex)[0].slice(1, -1);
+        return head.match(regex)[0].slice(1, -1);
     }
 
     getLastLineNumber() {
-        return this.suffixLineNumber ?
-            this.suffixLineNumber :
+        return this.tailLineNumber ?
+            this.tailLineNumber :
             this.endLineNumber;
     }
 
     isDocType() {
-        return this.value.toLowerCase().trim().startsWith('<!doctype ');
+        return this.head.toLowerCase().trim().startsWith('<!doctype ');
     }
 
     // Checks if the node type is dynamically set, such in:
     // <${aPdictVariable} />
     isDynamicElement() {
-        return this.value.trim().startsWith('<${');
+        return this.head.trim().startsWith('<${');
     }
 
     isInSameLineAsParent() {
@@ -98,7 +98,7 @@ class IsmlNode {
     }
 
     isMultiLineOpeningTag() {
-        return this.isTag() && ParseUtils.getLineBreakQty(this.value.trim()) > 0;
+        return this.isTag() && ParseUtils.getLineBreakQty(this.head.trim()) > 0;
     }
 
     isInSameLineAsPreviousSibling() {
@@ -135,28 +135,28 @@ class IsmlNode {
     }
 
     addChild(newNode) {
-        if (newNode.value.trim()) {
+        if (newNode.head.trim()) {
             newNode.depth        = this.depth + 1;
             newNode.parent       = this;
             newNode.childNo      = this.children.length;
             this.children.push(newNode);
             this.newestChildNode = newNode;
         } else {
-            this.suffixValue = newNode.value + this.suffixValue;
+            this.tail = newNode.head + this.tail;
         }
 
         newNode.isEmbeddedNode = this.isEmbeddedNode;
     }
 
-    getLastChild()        { return this.children[this.children.length - 1]; }
+    getLastChild()   { return this.children[this.children.length - 1]; }
     getChildrenQty() { return this.children.length;                    }
-    hasChildren()         { return this.children.length > 0;                }
+    hasChildren()    { return this.children.length > 0;                }
 
     getIndentationSize() {
         return getNodeIndentationSize(this, true);
     }
 
-    getSuffixIndentationSize() {
+    getTailIndentationSize() {
         return getNodeIndentationSize(this, false);
     }
 
@@ -174,14 +174,14 @@ class IsmlNode {
     }
 
     isTag() {
-        const value = this.value.trim();
+        const value = this.head.trim();
 
         return value.startsWith('<') &&
             value.endsWith('>');
     }
 
     isHtmlTag() {
-        const value = this.value.trim();
+        const value = this.head.trim();
 
         return value.startsWith('<') &&
             !value.startsWith('<is') &&
@@ -189,11 +189,11 @@ class IsmlNode {
     }
 
     isIsmlTag() {
-        return this.value.trim().startsWith('<is');
+        return this.head.trim().startsWith('<is');
     }
 
     isStandardIsmlTag() {
-        return !!SfccTags[this.getType()];
+        return !!SfccTagContainer[this.getType()];
     }
 
     isCustomIsmlTag() {
@@ -217,14 +217,14 @@ class IsmlNode {
     // For an unwrapped ${someVariable} element, returns true;
     // For tags and hardcoded strings          , returns false;
     isExpression() {
-        const value = this.value.trim();
+        const value = this.head.trim();
 
         return value.startsWith('${') &&
             value.endsWith('}');
     }
 
     isIsmlComment() {
-        const value = this.value.trim();
+        const value = this.head.trim();
 
         return value === '<iscomment>';
     }
@@ -234,14 +234,14 @@ class IsmlNode {
     }
 
     isHtmlComment() {
-        const value = this.value.trim();
+        const value = this.head.trim();
 
         return value.startsWith('<!--') &&
             value.endsWith('-->');
     }
 
     isConditionalComment() {
-        const value = this.value.trim();
+        const value = this.head.trim();
 
         return value.startsWith('<!--[');
     }
@@ -281,7 +281,7 @@ class IsmlNode {
     }
 
     getTrailingValue() {
-        return this.suffixValue || this.value;
+        return this.tail || this.head;
     }
 
     // Checks if node is HTML 5 void element;
@@ -298,9 +298,9 @@ class IsmlNode {
             this.isDocType() ||
             this.isVoidElement() ||
             this.isHtmlComment() ||
-            this.isTag() && this.value.trim().endsWith('/>')) ||
+            this.isTag() && this.head.trim().endsWith('/>')) ||
             this.isCustomIsmlTag() ||
-            this.isIsmlTag() && SfccTags[this.getType()] && SfccTags[this.getType()]['self-closing'];
+            this.isIsmlTag() && SfccTagContainer[this.getType()] && SfccTagContainer[this.getType()]['self-closing'];
     }
 
     isOfType(type) {
@@ -320,7 +320,7 @@ class IsmlNode {
     }
 
     isEmpty() {
-        return !this.value.trim();
+        return !this.head.trim();
     }
 
     isFirstChild() {
@@ -331,7 +331,7 @@ class IsmlNode {
         const firstChild = this.parent.children[0];
 
         return this.lineNumber === firstChild.lineNumber &&
-            this.value === firstChild.value;
+            this.head === firstChild.head;
     }
 
     isLastChild()  {
@@ -370,7 +370,7 @@ class IsmlNode {
         }
 
         if (!this.isRoot() && !this.isContainer()) {
-            stream += this.value;
+            stream += this.head;
         }
 
         for (let i = 0; i < this.children.length; i++) {
@@ -379,7 +379,7 @@ class IsmlNode {
         }
 
         if (!this.isRoot() && !this.isContainer()) {
-            stream += this.suffixValue;
+            stream += this.tail;
         }
 
         return stream;
@@ -410,11 +410,11 @@ class IsmlNode {
 */
 
 const getAttributes = node => {
-    const trimmedValue             = node.value.trim();
-    const nodeValue                = trimmedValue.substring(1, trimmedValue.length - 1);
-    const firstSpaceAfterTagPos    = ParseUtils.getFirstEmptyCharPos(trimmedValue);
-    const leadingEmptySpaceQty     = ParseUtils.getNextNonEmptyCharPos(nodeValue);
-    const afterTagContent          = nodeValue.substring(leadingEmptySpaceQty + firstSpaceAfterTagPos);
+    const trimmedHead              = node.head.trim();
+    const nodeHead                 = trimmedHead.substring(1, trimmedHead.length - 1);
+    const firstSpaceAfterTagPos    = ParseUtils.getFirstEmptyCharPos(trimmedHead);
+    const leadingEmptySpaceQty     = ParseUtils.getNextNonEmptyCharPos(nodeHead);
+    const afterTagContent          = nodeHead.substring(leadingEmptySpaceQty + firstSpaceAfterTagPos);
     const stringifiedAttributeList = getStringifiedAttributeArray(afterTagContent);
     const attributeList            = [];
 
@@ -428,13 +428,13 @@ const getAttributes = node => {
 
 // Used for debugging purposes only;
 const getDisplayText = node => {
-    let displayText = node.value;
+    let displayText = node.head;
 
     displayText = displayText
         .replace(new RegExp(Constants.EOL, 'g'), '')
         .replace(/ +(?= )/g, '');
 
-    if (node.value.length > MAX_TEXT_DISPLAY_SIZE - 3) {
+    if (node.head.length > MAX_TEXT_DISPLAY_SIZE - 3) {
         displayText = displayText.substring(0, MAX_TEXT_DISPLAY_SIZE - 3) + '...';
     }
 
@@ -478,7 +478,12 @@ const getStringifiedAttributeArray = content => {
     }
 
     for (let i = 0; i < maskedAttributeList.length; i++) {
-        const fullAttribute = content.substring(attrStartPosList[i], attrStartPosList[i] + maskedAttributeList[i].length);
+        let fullAttribute = content.substring(attrStartPosList[i] - 1, attrStartPosList[i] + maskedAttributeList[i].length).trim();
+
+        if (fullAttribute.endsWith('/')) {
+            fullAttribute = fullAttribute.slice(0, -1) + ' ';
+        }
+
         result.push(fullAttribute);
     }
 
@@ -490,16 +495,16 @@ const parseAttribute = (node, attributeList, index) => {
     const isAttributeANestedIsmlTag             = attribute.startsWith('<is');
     const isExpressionAttribute                 = attribute.startsWith('${') && attribute.endsWith('}');
     const trimmedAttribute                      = attribute.trim();
-    const trimmedNodeValue                      = node.value.trim();
-    const localPos                              = getAttributeLocalPos(trimmedNodeValue, trimmedAttribute);
-    const leadingContent                        = trimmedNodeValue.substring(0, localPos);
+    const trimmedNodeHead                       = node.head.trim();
+    const localPos                              = getAttributeLocalPos(trimmedNodeHead, trimmedAttribute);
+    const leadingContent                        = trimmedNodeHead.substring(0, localPos);
     const leadingLineBreakQty                   = ParseUtils.getLineBreakQty(leadingContent);
     const isInSameLineAsTagName                 = leadingLineBreakQty === 0;
     const assignmentCharPos                     = trimmedAttribute.indexOf('=');
     const name                                  = assignmentCharPos >= 0 ? trimmedAttribute.substring(0, assignmentCharPos) : trimmedAttribute;
     const value                                 = assignmentCharPos >= 0 ? trimmedAttribute.substring(assignmentCharPos + 2, trimmedAttribute.length - 1) : null;
     const valueList                             = getAttributeValueList(value);
-    const attrLocalPos                          = trimmedNodeValue.indexOf(trimmedAttribute);
+    const attrLocalPos                          = trimmedNodeHead.indexOf(trimmedAttribute);
     const valueLocalPos                         = trimmedAttribute.indexOf(value);
     const lineNumber                            = node.lineNumber + leadingLineBreakQty;
     const globalPos                             = node.globalPos + localPos + leadingLineBreakQty - lineNumber + 1;
@@ -513,7 +518,7 @@ const parseAttribute = (node, attributeList, index) => {
         leadingContent.length - leadingContent.lastIndexOf(Constants.EOL);
 
     const isFirstInLine = !isInSameLineAsTagName
-        && trimmedNodeValue
+        && trimmedNodeHead
             .split(Constants.EOL)
             .find(attrLine => attrLine.indexOf(attributeNameFirstLine) >= 0)
             .trim()
@@ -570,26 +575,26 @@ const parseAttribute = (node, attributeList, index) => {
 /**
  * Two attributes can have the same name, and that is handled here;
  */
-const getAttributeLocalPos = (trimmedNodeValue, trimmedAttribute) => {
+const getAttributeLocalPos = (trimmedNodeHead, trimmedAttribute) => {
     const maskedTrimmedAttribute = MaskUtils.maskQuoteContent(trimmedAttribute);
-    const maskedTrimmedNodeValue = MaskUtils.maskQuoteContent(trimmedNodeValue);
+    const maskedTrimmedNodeHead  = MaskUtils.maskQuoteContent(trimmedNodeHead);
 
-    let attributeLocalPos    = maskedTrimmedNodeValue.indexOf(maskedTrimmedAttribute);
-    const isCorrectAttribute = trimmedNodeValue.indexOf(trimmedAttribute) === attributeLocalPos;
-    let remainingNodeValue   = maskedTrimmedNodeValue.substring(attributeLocalPos + 1);
+    let attributeLocalPos    = maskedTrimmedNodeHead.indexOf(maskedTrimmedAttribute);
+    const isCorrectAttribute = trimmedNodeHead.indexOf(trimmedAttribute) === attributeLocalPos;
+    let remainingNodeHead    = maskedTrimmedNodeHead.substring(attributeLocalPos + 1);
 
     while (!isCorrectAttribute) {
-        const tempLocalPos = remainingNodeValue.indexOf(maskedTrimmedAttribute) + 1;
+        const tempLocalPos = remainingNodeHead.indexOf(maskedTrimmedAttribute) + 1;
 
         attributeLocalPos += tempLocalPos;
 
-        const remainingContent = trimmedNodeValue.substring(attributeLocalPos);
+        const remainingContent = trimmedNodeHead.substring(attributeLocalPos);
 
         if (remainingContent.startsWith(trimmedAttribute)) {
             break;
         }
 
-        remainingNodeValue = remainingNodeValue.substring(tempLocalPos);
+        remainingNodeHead = remainingNodeHead.substring(tempLocalPos);
     }
 
     return attributeLocalPos;
@@ -601,7 +606,7 @@ const getNodeIndentationSize = (node, isNodeHead) => {
         return 0;
     }
 
-    const content                    = isNodeHead ? node.value : node.suffixValue;
+    const content                    = isNodeHead ? node.head : node.tail;
     const precedingEmptySpacesLength = content.search(/\S|$/);
     const fullPrecedingEmptySpaces   = content.substring(0, precedingEmptySpacesLength);
     const lineBreakLastPos           = Math.max(fullPrecedingEmptySpaces.lastIndexOf(Constants.EOL), 0);

package/src/isml_tree/MaskUtils.js

@@ -20,7 +20,6 @@ const maskIgnorableContent = (content, shouldMaskBorders, templatePath) => {
     maskedContent = maskInBetweenIsscriptTags(maskedContent);
     maskedContent = maskInBetweenForTagWithAttributes(maskedContent, 'script', 'type=\'text/javascript\'');
     maskedContent = maskInBetweenForTagWithAttributes(maskedContent, 'script', 'type="text/javascript"');
-    maskedContent = maskQuoteContent(maskedContent);
     maskedContent = maskInBetweenForTagWithAttributes(maskedContent, 'isscript');
 
     checkTagBalance(maskedContent, content, templatePath);
@@ -28,6 +27,7 @@ const maskIgnorableContent = (content, shouldMaskBorders, templatePath) => {
     maskedContent = maskInBetweenForTagWithAttributes(maskedContent, 'script');
     maskedContent = maskInBetweenForTagWithAttributes(maskedContent, 'style');
     maskedContent = maskInBetween2(maskedContent, '<', '>');
+    maskedContent = maskQuoteContent(maskedContent);
     maskedContent = maskIsifTagContent(maskedContent);
     maskedContent = maskIsprintTagContent(maskedContent);
 
@@ -306,7 +306,7 @@ const maskIsifTagContent = content => {
         if (remainingContent.startsWith(closingTag)) {
             isWithinIsifTag = false;
             maskedContent   += closingTag;
-            i               += closingTag.length;
+            i               += closingTag.length - 1;
         }
     }
 

package/src/isml_tree/ParseUtils.js

@@ -4,12 +4,12 @@
  * simply analyze it and return relevant information;
  */
 
-const path           = require('path');
-const Constants      = require('../Constants');
-const ExceptionUtils = require('../util/ExceptionUtils');
-const SfccTags       = require('../enums/SfccTags');
-const GeneralUtils   = require('../util/GeneralUtils');
-const MaskUtils      = require('./MaskUtils');
+const path             = require('path');
+const Constants        = require('../Constants');
+const ExceptionUtils   = require('../util/ExceptionUtils');
+const SfccTagContainer = require('../enums/SfccTagContainer');
+const GeneralUtils     = require('../util/GeneralUtils');
+const MaskUtils        = require('./MaskUtils');
 
 const getNextNonEmptyChar = content => {
     return content.replace(new RegExp(Constants.EOL, 'g'), '').trim()[0];
@@ -89,14 +89,14 @@ const checkBalance = (node, templatePath) => {
     if (!node.isRoot() &&
         node.parent && !node.parent.isContainer() &&
         (node.isHtmlTag() || node.isIsmlTag()) &&
-        !node.isSelfClosing() && !node.suffixValue
+        !node.isSelfClosing() && !node.tail
         && !node.parent.isOfType('iscomment')
     ) {
         throw ExceptionUtils.unbalancedElementError(
             node.getType(),
             node.lineNumber,
             node.globalPos,
-            node.value.trim().length,
+            node.head.trim().length,
             templatePath
         );
     }
@@ -174,6 +174,8 @@ const parseTagOrExpressionElement = (state, newElement) => {
 
     if (isTag) {
         newElement.tagType = getElementType(trimmedElement);
+
+        newElement.isCustomTag = newElement.type === 'ismlTag' && !SfccTagContainer[newElement.tagType];
     }
 
     newElement.isSelfClosing = isSelfClosing(trimmedElement);
@@ -193,13 +195,13 @@ const parseTextElement = (state, newElement) => {
 
 const getElementType = trimmedElement => {
     if (trimmedElement.startsWith('</')) {
-        const suffixElementType = trimmedElement.slice(2, -1);
+        const tailElementType = trimmedElement.slice(2, -1);
 
-        if (suffixElementType.startsWith('${')) {
+        if (tailElementType.startsWith('${')) {
             return 'dynamic_element';
         }
 
-        return suffixElementType;
+        return tailElementType;
     } else {
 
         const typeValueLastPos = Math.min(...[
@@ -229,10 +231,10 @@ function isSelfClosing(trimmedElement) {
     const isHtmlComment        = trimmedElement.startsWith('<!--') && trimmedElement.endsWith('-->');
     const isClosingTag         = trimmedElement.endsWith('/>');
     const isIsmlTag            = trimmedElement.startsWith('<is');
-    const isStandardIsmlTag    = !!SfccTags[elementType];
+    const isStandardIsmlTag    = !!SfccTagContainer[elementType];
     const isCustomIsmlTag      = isIsmlTag && !isStandardIsmlTag;
     const isExpression         = trimmedElement.startsWith('${') && trimmedElement.endsWith('}');
-    const isSfccSelfClosingTag = SfccTags[elementType] && SfccTags[elementType]['self-closing'];
+    const isSfccSelfClosingTag = SfccTagContainer[elementType] && SfccTagContainer[elementType]['self-closing'];
 
     // 'isif' tag is never self-closing;
     if (['isif'].indexOf(elementType) >= 0) {

package/src/isml_tree/TreeBuilder.js

@@ -1,6 +1,7 @@
 const fs             = require('fs');
 const IsmlNode       = require('./IsmlNode');
 const ParseUtils     = require('./ParseUtils');
+const MaskUtils      = require('./MaskUtils');
 const ContainerNode  = require('./ContainerNode');
 const ExceptionUtils = require('../util/ExceptionUtils');
 const GeneralUtils   = require('../util/GeneralUtils');
@@ -13,6 +14,9 @@ const parse = (content, templatePath, isCrlfLineBreak, isEmbeddedNode) => {
 
     for (let i = 0; i < elementList.length; i++) {
         const element = elementList[i];
+
+        validateNodeHead(element, templatePath);
+
         const newNode = new IsmlNode(element.value, element.lineNumber, element.columnNumber, element.globalPos, isEmbeddedNode);
 
         const containerResult = parseContainerElements(element, currentParent, newNode, templatePath);
@@ -38,7 +42,7 @@ const parseContainerElements = (element, currentParent, newNode, templatePath) =
             currentParent.getType(),
             currentParent.lineNumber,
             currentParent.globalPos,
-            currentParent.value.trim().length,
+            currentParent.head.trim().length,
             templatePath
         );
     }
@@ -84,12 +88,12 @@ const parseContainerElements = (element, currentParent, newNode, templatePath) =
                 currentParent.getType(),
                 currentParent.lineNumber,
                 currentParent.globalPos,
-                currentParent.value.trim().length,
+                currentParent.head.trim().length,
                 templatePath
             );
         }
 
-        currentParent.setSuffix(element.value, element.lineNumber, element.columnNumber, element.globalPos);
+        currentParent.setTail(element.value, element.lineNumber, element.columnNumber, element.globalPos);
         currentParent = currentParent.parent.parent;
 
         return {
@@ -115,8 +119,15 @@ const parseNonContainerElements = (element, currentParent, newNode, templatePath
         }
     } else if (element.isClosingTag) {
 
+        const parentLastChild = currentParent.getLastChild();
+
         if (element.tagType === currentParent.getType()) {
-            currentParent.setSuffix(element.value, element.lineNumber, element.columnNumber, element.globalPos);
+            currentParent.setTail(element.value, element.lineNumber, element.columnNumber, element.globalPos);
+
+        } else if (element.isCustomTag && element.tagType === parentLastChild.getType()) {
+            parentLastChild.setTail(element.value, element.lineNumber, element.columnNumber, element.globalPos);
+
+            currentParent = parentLastChild;
 
         } else if (element.isClosingTag && currentParent.isRoot()) {
             throw ExceptionUtils.unbalancedElementError(
@@ -158,22 +169,22 @@ const postProcess = (node, data = {}) => {
     for (let i = 0; i < node.children.length; i++) {
         const child = node.children[i];
 
-        if (child.value.indexOf('template="util/modules"') >= 0) {
+        if (child.head.indexOf('template="util/modules"') >= 0) {
             data.moduleDefinition = {
-                value      : child.value,
+                value      : child.head,
                 lineNumber : child.lineNumber,
                 globalPos  : child.globalPos,
-                length     : child.value.trim().length
+                length     : child.head.trim().length
             };
         }
 
         if (child.isCustomIsmlTag()) {
             data.customModuleArray = data.customModuleArray || [];
             data.customModuleArray.push({
-                value      : child.value,
+                value      : child.head,
                 lineNumber : child.lineNumber,
                 globalPos  : child.globalPos,
-                length     : child.value.trim().length
+                length     : child.head.trim().length
             });
         }
 
@@ -211,10 +222,10 @@ const build = (templatePath, content, isCrlfLineBreak) => {
 
 /**
  * In the main part of tree build, a node A might hold the next node B's indentation in the last part of
- * A, be it in its value or suffix value. This function removes that trailing indentation from A and
+ * A, be it in its value or tail value. This function removes that trailing indentation from A and
  * adds it to B as a leading indentation;
  */
-function rectifyNodeIndentation(node, child) {
+const rectifyNodeIndentation = (node, child) => {
     const previousSibling = child.getPreviousSibling();
 
     if (child.isContainer()) {
@@ -222,21 +233,39 @@ function rectifyNodeIndentation(node, child) {
     }
 
     if (previousSibling && previousSibling.isOfType('text')) {
-        const trailingLineBreakQty = ParseUtils.getTrailingEmptyCharsQty(previousSibling.value);
+        const trailingLineBreakQty = ParseUtils.getTrailingEmptyCharsQty(previousSibling.head);
 
-        previousSibling.value = previousSibling.value.substring(0, previousSibling.value.length - trailingLineBreakQty);
-        child.value           = ParseUtils.getBlankSpaceString(trailingLineBreakQty) + child.value;
+        previousSibling.head = previousSibling.head.substring(0, previousSibling.head.length - trailingLineBreakQty);
+        child.head           = ParseUtils.getBlankSpaceString(trailingLineBreakQty) + child.head;
     }
 
     if (child.isLastChild() && child.isOfType('text')) {
         let trailingLineBreakQty = 0;
 
-        trailingLineBreakQty = ParseUtils.getTrailingEmptyCharsQty(child.value);
-        child.value          = child.value.substring(0, child.value.length - trailingLineBreakQty);
+        trailingLineBreakQty = ParseUtils.getTrailingEmptyCharsQty(child.head);
+        child.head           = child.head.substring(0, child.head.length - trailingLineBreakQty);
+
+        node.tail = ParseUtils.getBlankSpaceString(trailingLineBreakQty) + node.tail;
+    }
+};
+
+const validateNodeHead = (element, templatePath) => {
+
+    if (element.type !== 'text') {
+        const trimmedElement = element.value.trim();
+        const maskedElement  = MaskUtils.maskQuoteContent(trimmedElement);
 
-        node.suffixValue = ParseUtils.getBlankSpaceString(trailingLineBreakQty) + node.suffixValue;
+        if (maskedElement.endsWith('_')) {
+            throw ExceptionUtils.unbalancedQuotesError(
+                element.tagType,
+                element.lineNumber,
+                element.globalPos,
+                trimmedElement.length,
+                templatePath
+            );
+        }
     }
-}
+};
 
 module.exports.build = build;
 module.exports.parse = parse;