@slyte/html-parser 2.0.0-alpha

package/dist/js/HandleMustache.js

@@ -0,0 +1,707 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	// The require scope
+/******/ 	const __webpack_require__ = {};
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter/value functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			if(Array.isArray(definition)) {
+/******/ 				var i = 0;
+/******/ 				while(i < definition.length) {
+/******/ 					var key = definition[i++];
+/******/ 					var binding = definition[i++];
+/******/ 					if(!__webpack_require__.o(exports, key)) {
+/******/ 						if(binding === 0) {
+/******/ 							Object.defineProperty(exports, key, { enumerable: true, value: definition[i++] });
+/******/ 						} else {
+/******/ 							Object.defineProperty(exports, key, { enumerable: true, get: binding });
+/******/ 						}
+/******/ 					} else if(binding === 0) { i++; }
+/******/ 				}
+/******/ 			} else {
+/******/ 				for(var key in definition) {
+/******/ 					if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 						Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 					}
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+let __webpack_exports__ = {};
+/*!*******************************!*\
+  !*** ./src/HandleMustache.js ***!
+  \*******************************/
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+let errorType = ["Empty Mustache Not allowed", "missing ',' in helper function parameters", "Unexpected token ", "Misplaced ','", "Callback invocation is not supported", "Only helper function calls are allowed", "Syntax error encountered while accessing object", "Syntax Error invalid '.' Dot operator", `String started and never closed`, "Syntax Error unmatched ", " Array Without indexing ", "Syntax Error"],
+    capturedError = undefined;
+function isAlpha(str){
+    return /^[a-zA-Z]$/.test(str);
+} 
+function isAlphaNumeric(str) {
+    return /^[a-zA-Z0-9]$/.test(str);
+}
+function isNumeric(code) {
+    return /^[0-9]$/.test(code);
+}
+
+function validKeysString(val) {
+    return isAlphaNumeric(val) || "!@#$%^&*_+-=".indexOf(val) != -1;
+}
+
+function isValidSquareBracket(val) {
+    return isAlphaNumeric(val) || val == "]" || val == ")" || val == "_" || val == "$" || val == " ";
+}
+
+function isValidDot(val) {
+    return isValidSquareBracket(val) || "!@#$%^&*_+-=".indexOf(val) != -1;
+}
+
+function updateSqBracket(val) {
+    for (let i = 0; i < val.length; i++) {
+        val[i]++;
+    }
+    return val;
+}
+
+function isValidVariableName(name) {
+    return /^[a-zA-Z_$][a-zA-Z_$0-9]*$/.test(name);
+}
+function createErroObj(errType,errorIndex,offset = "",bool = false){
+    return {
+        bool,
+        errType,
+        errorIndex,
+        err : errorType[errType] + offset
+    }
+}
+function getObservedAttributes(str, check) {
+    let observedAttributes = [],
+        string = "",
+        variableStarted = false,
+        doubleQuoteStringStarted = false,
+        singleQuoteStringStarted = false,
+        dotStarted = false;
+
+    for (let i = 0; i < str.length; i++) {
+        if (str[i] == "'" && str[i - 1] != "\\") {
+            doubleQuoteStringStarted = !doubleQuoteStringStarted;
+        } else if (str[i] == '"' && str[i - 1] != "\\") {
+            singleQuoteStringStarted = !singleQuoteStringStarted;
+        } else if (!doubleQuoteStringStarted && !singleQuoteStringStarted) {
+            if (isAlphaNumeric(str[i]) || str[i] == '_') {
+                variableStarted = true;
+                string += str[i];
+            } else {
+                if (str[i] == " ") {
+                    continue;
+                }
+
+                if (dotStarted) {
+                    string = ""
+                    if (str[i] != ".") {
+                        dotStarted = false;
+                    } else {
+                        continue;
+                    }
+                }
+                if (str[i] == ".") {
+                    dotStarted = true;
+                }
+                if (string.length > 0 && str[i] != '(' && isValidVariableName(string)) {
+
+                    check.observedAttributes[string] = true;
+                }
+                variableStarted = false;
+            }
+        }
+        if (!variableStarted) {
+            string = "";
+        }
+    }
+    return observedAttributes
+}
+
+function checkForMixedCase(val) {
+    let seenDoubleQuotes = false,
+        seenSingleQuotes = false,
+        mustacheStarted = false,
+        mixedCase = false,
+        slashCount = 0,
+        mustacheSpots = [],
+        res = "",
+        mus={};
+    for (let i = 0; i < val.length; i++) {
+        if (mustacheStarted ) {
+            if(((seenDoubleQuotes || seenSingleQuotes) || val[i].match(/\S/))){
+                res += val[i];
+            }
+            else if (val[i+1] && val[i].match(/\s/) && /^\s*\+\+|--|[+\-*/%\w]|\*\*/.test(val[i+1])) {
+                res += val[i];
+            }
+        } 
+        if (val[i - 1] != "\\" && val[i] == "{" && val[i + 1] == "{" && !seenDoubleQuotes && !seenSingleQuotes) {
+            if(mustacheStarted){
+                let dynamicValue;
+                if(mus && mus.index && mus.index[0]!=undefined){
+                    dynamicValue = val.substring(mus.index[0], i);
+                }
+                return {
+                    bool:false,
+                    dynamicValue,
+                    errorIndex:i,
+                    err:"Invalid dynamic value inside dynamic value `{{`"
+                };
+            }
+            if (!mixedCase && i != 0) {
+                mixedCase = true
+            }
+            mus = {}
+            mus.index = [i];
+            mustacheStarted = true;
+        }
+        if (val[i] == "}" && val[i + 1] == "}" && !seenDoubleQuotes && !seenSingleQuotes && mustacheStarted) {
+            if (!mixedCase && i + 1 != val.length - 1) {
+                mixedCase = true
+            }
+            mus.index[1] = i + 1;
+            mus.orgMus = val.substring(mus.index[0],mus.index[1]+1);
+            mus.mus = "{"+res+"}";
+            res = "";
+            mustacheSpots.push(mus);
+            mustacheStarted = false;
+        }
+        if (val[i] == "\\") {
+            slashCount++;
+        }
+        if (val[i - 1] != "\\" || (val[i - 1] == "\\" && slashCount % 2 == 0)) {
+            if (val[i] == "'" && !seenDoubleQuotes && mustacheStarted) {
+                seenSingleQuotes = !seenSingleQuotes;
+            }
+            if (val[i] == '"' && !seenSingleQuotes && mustacheStarted) {
+                seenDoubleQuotes = !seenDoubleQuotes;
+            }
+        }
+        if (val[i] != "\\") {
+            slashCount = 0;
+        }
+
+    }
+    return {
+        bool:true,
+        mixedCase: mixedCase,
+        mustacheSpots: mustacheSpots
+    };
+}
+
+function getLineAndColIndex(val, obj, mSpot) {
+    let beforeContextSplit = val.substring(0, mSpot).split("\n");
+    return {
+        colIndex: (beforeContextSplit.length - 1) ? beforeContextSplit[beforeContextSplit.length - 1].length  : obj.colIndex + mSpot,
+        lineIndex: obj.lineIndex + beforeContextSplit.length - 1 
+    };
+}
+
+function syntaxCheckWorkerNew(val, check = undefined, errorObj = {mustacheSyntax:{arr:[],obj:{}}}, index = {},attr) {
+    if (!check.Compile) {
+        // console.error("Error: `can't get trimAttr scope`");
+        return {
+            text: val
+        };
+    } else {
+        let syn = undefined,
+            observedAttributes = undefined,
+            mixedCaseCheck = false,
+            origMustache = val;
+        if (val.indexOf("{{") !== -1) {
+            attr && (val = val.trim().replace(/^@nbsp@|@nbsp@$/gm,""));
+            let tempCopy, valCopy = val,
+                res = checkForMixedCase(val);
+            if (res.bool) {
+                const {
+                    mixedCase,
+                    mustacheSpots
+                } = res;
+                mixedCaseCheck = mixedCase;
+                if (mustacheSpots.length && mustacheSpots.length > 0) {
+                    for (let j = 0; j < mustacheSpots.length; j++) {
+                        let mustache = mustacheSpots[j].mus,
+                            x = mustache,
+                            spots = mustacheSpots[j].index;
+                        if(mustache.match(/\&|\||\!|\=|\+|-|\*|\/|<|>|\?|:|%/gm)){
+                            x = check.Compile.trimAttr(mustache, [], {}, undefined, "", check);
+                            
+                        }
+                        val = val.replace(mustacheSpots[j].orgMus, () => {
+                            return x;
+                        });
+                        tempCopy = x;
+                        syn = processAttr(x);
+                        if (!syn.bool) {
+                            if (errorObj.hasOwnProperty("mustacheSyntax")) {
+                                syn = Object.assign(syn, getLineAndColIndex(val, index, spots[0]));
+                                syn.dynamicValue = x;
+                                syn.fileName = check.fileName;
+                                syn.musEnd = getLineAndColIndex(val, index, spots[1]);
+                                errorObj.mustacheSyntax.arr.push(syn);
+                                if (errorObj.mustacheSyntax.obj[errorType[syn.errType]]) {
+                                    errorObj.mustacheSyntax.obj[errorType[syn.errType]].push(check.fileName)
+                                } else {
+                                    errorObj.mustacheSyntax.obj[errorType[syn.errType]] = [check.fileName]
+                                }
+                            }
+                        }
+                        if (check && check.emberFlag && ((syn && syn.bool) || (!capturedError))) {
+                            getObservedAttributes(tempCopy, check);
+                        }
+
+                    }
+                } else {
+                    syn = processAttr(val);
+                    if (!syn.bool) {
+                        syn.dynamicValue = val;
+                        if ( errorObj.hasOwnProperty("mustacheSyntax") ) {
+                            syn = Object.assign(syn, getLineAndColIndex(val, index, val.indexOf("{{")));
+                            syn.fileName = check.fileName;
+                            errorObj.mustacheSyntax.arr.push(syn);
+                            if (errorObj.mustacheSyntax.obj[errorType[syn.errType]]) {
+                                errorObj.mustacheSyntax.obj[errorType[syn.errType]].push(check.fileName)
+                            } else {
+                                errorObj.mustacheSyntax.obj[errorType[syn.errType]] = [check.fileName]
+                            }
+                        }
+                    }
+                }
+            }
+            else{
+                res = Object.assign(res, getLineAndColIndex(val, index, val.indexOf("{{")));
+                if(!res.dynamicValue){
+                    res.dynamicValue = val;
+                }
+                res.fileName = check.fileName;
+                errorObj.mustacheSyntax.arr.push(res);
+                if (errorObj.mustacheSyntax.obj[res.err]) {
+                    errorObj.mustacheSyntax.obj[res.err].push(check.fileName)
+                } else {
+                    errorObj.mustacheSyntax.obj[res.err] = [check.fileName]
+                }
+            }
+        }
+        if (!check.fromInternal && check.withoutTemplateConversion) {
+            val = origMustache;
+        }
+        val = val.replace(/@nbsp@/gm, "&nbsp;");
+        let res = {
+            text: val,
+            type: syn ? ((mixedCaseCheck) ? "Mixed" : syn.type) : syn,
+            "observedAttributes": (observedAttributes && observedAttributes.length > 0) ? observedAttributes : undefined
+        }
+        if(res.type == "helper"){
+            res.capturedHelper = syn.capturedHelper;
+        }
+        return res;
+    }
+}
+
+function processAttr(val) {
+    let parsingMustache,
+        mustacheIndex = 0,
+        typeStarted,
+        type = null,
+        mustache = 0,
+        retObj = {
+            mustache: 0,
+            bool: true,
+            err: null,
+            errorIndex: 0
+        },
+        valueBeforeSpace = undefined,
+        stringStartIndex = 0,
+        seenTextBeforeNextcomma = undefined,
+        seenTokenBefore = false,
+        stringStartCheck = false,
+        dotStarted = false,
+        IdentifierStarted = false,
+        hashStarted = false,
+        prevToken = "",
+        capturedToken = "",
+        capturedHelper;
+    if (val == '{{}}') {
+        return createErroObj(0,0);
+    }
+    for (let i = 0; i < val.length; i++) {
+        if (parsingMustache) {
+            if ((validKeysString(val[i]))) {
+                if ((!stringStarted && !dotStarted && "!@%^&*+-=".indexOf(val[i]) != -1) || (val[i - 1] == " " && seenTokenBefore) || (stringStartCheck && val[i - 1] == " ")) {
+                    return createErroObj(2, i, val[i]);
+                }
+                if (!stringStarted) {
+                    seenTokenBefore = true;
+                    capturedToken+=val[i];
+                }
+
+            } else if (val[i] != " ") {
+                if (!stringStarted && (val[i] == "'" || val[i] == '"')) {
+                    if (val[i - 1] == " " && seenTokenBefore) {
+                        return createErroObj(2, i, val[i]);
+                    }
+                }
+                if (!stringStarted && val[i] == ".") {
+                    dotStarted = true;
+                } else {
+                    dotStarted = false;
+                }
+                stringStartCheck = false;
+                seenTokenBefore = false;
+                if(capturedToken){
+                    prevToken = capturedToken;
+                }
+                capturedToken="";
+            }
+            if (seenTextBeforeNextcomma == false && val[i] != " " && val[i] != ",") {
+                seenTextBeforeNextcomma = true;
+            }
+            if (sqBrackets.length > 0 && ![" ", "]", "["].includes(val[i])) {
+                sqBrackets = updateSqBracket(sqBrackets);
+            }
+            if (spaceStarted && val[i] == "," && !stringStarted) {
+                spaceStarted = false;
+                valueBeforeSpace = undefined;
+            }
+            if (!stringStarted && !commaSeen && (isAlphaNumeric(val[i]) || val[i]=="#") && ((valueBeforeSpace && isAlphaNumeric(valueBeforeSpace)) || (valueBeforeSpace && ["'", '"'].includes(valueBeforeSpace)) || ["'", '"'].includes(val[i - 1]))) {
+                return createErroObj(2, i, val[i]);
+            }
+            if (spaceStarted && ![",", " "].includes(val[i]) && !stringStarted && !commaSeen && paranthesis != 0) {
+
+                if (val[i] == "(" || val[i] == "[" || ((val[i] == ")" || val[i]=="'" || val[i] == '"')  && paranthesis >= 1) || (val[i] == "]" && squareBracketCount >= 1) || isAlphaNumeric(val[i]) || val[i] == "_") {
+                    spaceStarted = false;
+                    valueBeforeSpace = undefined;
+                }
+                else {
+                    return createErroObj(2, i, val[i]);
+                }
+            } else if (!stringStarted && "," == val[i] && paranthesis == 0) {
+                return createErroObj(3, i);
+            } else if (!stringStarted && val[i] == ',') {
+                seenTextBeforeNextcomma = false;
+                commaSeen = true;
+            }
+            if (checkThis) {
+                if (![",", " ", "}"].includes(val[i])) {
+                    if ([")", "]"].includes(checkThis) || (['"', "'"].includes(checkThis) && !stringStarted)) {
+                        if (((val[i] == ")" && paranthesis >= 0) || (val[i] == "]" && sqBrackets.length > 0) || (val[i] == '[') || (val[i] == '.'))) {
+                            checkThis = undefined;
+                        }
+                        else if (!commaSeen && !spaceStarted && !stringStarted && !(!stringStarted && checkThis == '"') && !(!stringStarted && checkThis == "'")) {
+                            if (paranthesis > 0 && checkThis == ']') {
+                                return createErroObj(4, i);
+                            } else {
+                                if (val[i] == '(' && checkThis == ')') {
+                                    return createErroObj(11, i);
+                                }
+                                if (val[i] == ']' && checkThis == ')') {
+                                    return createErroObj(5, i);
+                                }
+                                if ((val[i] == ']' && checkThis != ']') || (val[i] == ')' && checkThis != ')')) {
+                                    return createErroObj(11, i);
+                                }
+                                if (val[i - 1] == ')') {
+                                    return createErroObj(2,i,val[i]);
+                                }
+
+                            }
+                        }
+                    } else if (checkThis == '.') {
+                        if (val[i].toUpperCase() != val[i].toLowerCase() || "!@#$%^&*_+-={[".indexOf(val[i]) != -1 || isNumeric(val[i])) {
+                            checkThis = undefined;
+                        } else if (!spaceStarted) {
+                            return createErroObj(6, i);
+                        }
+                    }
+                } else if (!stringStarted && val[i] == "," && paranthesis == 0) {
+                    return createErroObj(11, i);
+
+                } else if (!stringStarted && val[i] == ',') {
+                    checkThis = undefined;
+                }
+            }
+            if (paranthesis == 0 && val[i - 1] == ')' && ['.', '['].includes(val[i])) {
+                type = "Extra Helper";
+            }
+            if(hashStarted){
+                if(!(isAlpha(val[i]) || val[i] == "_")){
+                    return {
+                        bool: false,
+                        err: `Invalid character '${val[i]}' after #`,
+                        errorIndex: i + 1
+                    };
+                }
+                hashStarted = false;
+            }
+            if (val[i] == "\\") {
+                i = i + 1;
+            } else if (val[i] == "'") {
+                if (lastString != '"') {
+                    if (!stringStarted) {
+                        if(!(paranthesis>0 || (squareBracket && squareBracket.length>0))){
+                            return createErroObj(2, i, "'");
+                        }
+                        stringStarted = true;
+                        stringStartIndex = i;
+                        lastString = "'";
+                    } else {
+                        let count = undefined;
+                        if (val[i - 1] == "\\") {
+                            count = 0;
+                            for (let j = i - 1; j >= 0; j--) {
+                                if (val[j] == "\\") {
+                                    count++;
+                                } else {
+                                    break;
+                                }
+                            }
+                        }
+                        if (count == undefined || count % 2 == 0) {
+                            stringStarted = false;
+                            stringStartCheck = true;
+                            lastString = undefined;
+                        }
+                    }
+
+                }
+            } else if (val[i] == '"') {
+                if (lastString != "'") {
+                    if (!stringStarted) {
+                        if(!(paranthesis>0 || (squareBracket && squareBracket.length>0))){
+                            return createErroObj(2, i, '"');
+                        }
+                        stringStarted = true;
+                        stringStartIndex = i;
+                        lastString = '"'
+                    } else {
+                        let count = undefined;
+                        if (val[i - 1] == "\\") {
+                            count = 0;
+                            for (let j = i - 1; j >= 0; j--) {
+                                if (val[j] == "\\") {
+                                    count++;
+                                } else {
+                                    break;
+                                }
+                            }
+                        }
+                        if (count == undefined || count % 2 == 0) {
+                            stringStarted = false;
+                            stringStartCheck = true;
+                            lastString = undefined;
+                        }
+                    }
+                }
+            } else if (val[i] == "{" && !stringStarted && dotStarted) {
+                return createErroObj(2, i, "'{' bracket ");
+            } else if (val[i] == "{" && stringStarted && val[i - 1] == "{") {
+                retObj.mustache++;
+            } else if (val[i] == "}" && val[i - 1] == "}" && !stringStarted) {
+                if (curlyBracket.length) {
+                    return createErroObj(9, i, "'(' bracket ");
+                }
+                if (squareBracket.length) {
+                    return createErroObj(9, i, "'[' bracket ");
+                }
+                parsingMustache = false;
+
+            } else if (val[i] == "[" && !stringStarted) {
+                if (isValidSquareBracket(val[i - 1])) {
+                    squareBracket.push("[");
+                    sqBrackets.push(0);
+                }
+                if (!typeStarted) {
+                    typeStarted = 1
+                }
+                if (typeStarted == 1) {
+                    if (!squareBracketCount && squareBracketCount != 0) {
+                        squareBracketCount = 1
+                    } else {
+                        squareBracketCount += 1;
+                    }
+
+                    if (squareBracketCount > 1) {
+                        type = "Multi-dimensional array"
+                    }
+
+                }
+
+            } else if (val[i] == "]" && !stringStarted) {
+                let check;
+                if (squareBracket.length) {
+                    squareBracket.pop();
+                    check = sqBrackets.pop();
+                } else {
+                    return createErroObj(9, i, "']' bracket ");
+                }
+                if (check == 0) {
+                    return createErroObj(10, i);
+                }
+                squareBracketCount -= 1;
+
+            } else if (val[i] == "(" && !stringStarted) {
+                if (i > 0 && (isAlphaNumeric(val[i - 1]) || val[i] == '_')) {
+                    curlyBracket.push('(');
+                } else {
+                    return createErroObj(2, i, val[i]);
+                }
+                paranthesis += 1
+                if (paranthesisLog == 0) {
+                    continue;
+                }
+                if (!typeStarted) {
+                    typeStarted = 2
+                }
+                if (typeStarted == 1 && squareBracketCount > 0) {
+                    type = "Multi-dimensional array"
+                }
+                if (typeStarted == 3 && sqBrackets.length == 0) {
+                    return createErroObj(5, dotIndex);
+                }
+                if (typeStarted == 2) {
+                    if (!paranthesisLog && paranthesisLog != 0) {
+                        paranthesisLog = 1
+                    } else {
+                        paranthesisLog += 1;
+                    }
+                    if(paranthesisLog == 1){
+                        if(!capturedHelper){
+                            capturedHelper = prevToken;
+                        }
+                    }
+                    if (paranthesisLog > 1) {
+                        type = "helper";
+                    }
+                }
+            } else if (val[i] == ")" && !stringStarted) {
+                if (curlyBracket.length) {
+                    curlyBracket.pop();
+                } else {
+                    return createErroObj(9, i, "')' bracket ");
+                }
+                paranthesis -= 1;
+                paranthesisLog -= 1;
+                if (!typeStarted) {
+                    typeStarted = 2;
+                }
+                if (typeStarted == 2) {
+                    if (paranthesisLog == 0 && !type) {
+                        type = "helper";
+                    }
+                }
+            } else if (val[i] == "." && !stringStarted) {
+
+                if (!isValidDot(val[i - 1])) {
+                    return createErroObj(7, i);
+                }
+                if (!typeStarted) {
+                    typeStarted = 3;
+                }
+                if (typeStarted == 1 && sqBrackets.length > 0) {
+                    type = "Multi-dimensional array"
+                }
+                dotIndex = i;
+            } else if (val[i] == "#" && !stringStarted) {
+                if(dotStarted || IdentifierStarted){
+                    return createErroObj(2, i, "'#' operator");
+                }
+                hashStarted = true;
+            } 
+            if((isAlphaNumeric(val[i]) || val[i] == "_") && !stringStarted){
+                if(val[i + 1] == "'" || val[i + 1] == '"'){
+                    return createErroObj(2, i + 1, val[i + 1]);
+                }
+                IdentifierStarted = true;
+            } else {
+                IdentifierStarted = false;
+            }
+            if (!stringStarted && commaSeen && ![" ", ","].includes(val[i])) {
+                commaSeen = false;
+                seenTextBeforeNextcomma = undefined;
+                spaceStarted = false;
+                valueBeforeSpace = undefined;
+            }
+            if (paranthesis > 0) {
+                if (val[i + 1] == " " && !stringStarted) {
+                    spaceStarted = true;
+                    valueBeforeSpace = val[i];
+                    continue;
+                }
+                if (spaceStarted) {
+                    continue;
+                }
+
+            };
+            if (!stringStarted && paranthesis >= 0 && [")", "]", ".", "'", '"'].includes(val[i])) {
+                checkThis = val[i];
+
+            }
+
+        } else if ((val[i] == "{" && val[i - 1] == "{" && val[i - 2] != "\\")) {
+            mustache++;
+            var curlyBracket = [],
+                squareBracket = [],
+                stringStarted, lastString,
+                paranthesis = 0,
+                squareBracketCount,
+                spaceStarted, checkThis, paranthesisLog,
+                sqBrackets = [],
+                commaSeen,
+                dotIndex;
+            typeStarted = null;
+            type = null;
+            parsingMustache = true;
+            checkThis = undefined;
+            mustacheIndex = i;
+        }
+    }
+    if (stringStarted) {
+        return createErroObj(8, stringStartIndex);
+    }
+    if (parsingMustache) {
+        return createErroObj(9, mustacheIndex, "'{' bracket");
+    }
+    if (!type) {
+        type = "Normal Data"
+    }
+    if (mustache > 1) {
+        type = "mixed mustache";
+    }
+    retObj.type = type;
+    if(type == "helper"){
+        retObj.capturedHelper = capturedHelper;
+    }
+    return retObj;
+}
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (syntaxCheckWorkerNew);
+Object(window["html-parser"]).HandleMustache = __webpack_exports__["default"];
+/******/ })()
+;