Source: becke-ch--regex--s0-0-v1--base--pl--lib.js

  1. /*
  2.  * Copyright (c) 2017. becke.ch - All Rights Reserved.
  3.  * Use is subject to (MIT-style) License terms.
  4.  * You may obtain a copy of the License at http://becke.ch/tool/becke-ch--regex--s0-v1/becke-ch--regex--s0-v1--license.txt
  5.  */
  7. /**
  8.  * Created by raoul-becke--s0-v1 on 08.12.16. A JavaScript Regular Expression library, extending the standard RegExp
  9.  * class with missing functionality.
  10.  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
  11.  * @see http://www.ecma-international.org/ecma-262/6.0/#sec-regexp-regular-expression-objects
  12.  */
  14. //Fixes issue for browsers (IE, Safari - respective in general WebKit based browsers e.g. JavaFX) not supporting
  15. // JavaScript "Symbol"
  16. Symbol = (typeof Symbol === "undefined") ? [] : Symbol;
  18. /**
  19.  * This class is an extension of the standard {@linkcode RegExp} class adding missing functionality.
  20.  * For further descriptions see the corresponding overridden methods.
  21.  * @param {string|RegExp} [pattern]
  22.  * @param {string} [options]
  23.  * @constructor
  24.  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
  25.  * @see http://www.ecma-international.org/ecma-262/6.0/#sec-regexp-regular-expression-objects
  26.  */
  27. function Regex(pattern, options) {
  28.     var patternInstanceofRegExp = false;
  29.     if (pattern instanceof RegExp) {
  30.         pattern = pattern.source;
  31.         patternInstanceofRegExp = true;
  32.     }
  33.     if (pattern) {
  34.         this.regexGroupStructure = getRegexCompleteGroupingStructure(pattern);
  35.         if (patternInstanceofRegExp) {
  36.             this.source = pattern;
  37.         } else {
  38.             this.source = this.regexGroupStructure[2][0];
  39.         }
  40.         try {
  41.             this.regex = new RegExp(this.regexGroupStructure[0][2], options);
  42.         } catch (e) {
  43.             new RegExp(pattern, options);
  44.         }
  45.     } else {
  46.         this.regex = new RegExp(pattern, options);
  47.         this.source = this.regex.source;
  48.     }
  49.     this.flags = this.regex.flags;
  50.     this.global = this.regex.global;
  51.     this.ignoreCase = this.regex.ignoreCase;
  52.     this.multiline = this.regex.multiline;
  53.     this.sticky = this.regex.sticky;
  54.     this.unicode = this.regex.unicode;
  55.     this.lastIndex = this.regex.lastIndex;
  56. }
  58. Regex.prototype = Object.create(RegExp.prototype, {
  59.     flags: {
  60.         value: null,
  61.         enumerable: true,
  62.         configurable: true,
  63.         writable: true
  64.     },
  65.     global: {
  66.         value: null,
  67.         enumerable: true,
  68.         configurable: true,
  69.         writable: true
  70.     },
  71.     ignoreCase: {
  72.         value: null,
  73.         enumerable: true,
  74.         configurable: true,
  75.         writable: true
  76.     },
  77.     multiline: {
  78.         value: null,
  79.         enumerable: true,
  80.         configurable: true,
  81.         writable: true
  82.     },
  83.     source: {
  84.         value: null,
  85.         enumerable: true,
  86.         configurable: true,
  87.         writable: true
  88.     },
  89.     sticky: {
  90.         value: null,
  91.         enumerable: true,
  92.         configurable: true,
  93.         writable: true
  94.     },
  95.     unicode: {
  96.         value: null,
  97.         enumerable: true,
  98.         configurable: true,
  99.         writable: true
  100.     }
  101. });
  103. Regex.prototype.constructor = Regex;
  105. /**
  106.  * Returns the same string format as {@linkcode RegExp#toString} for the initial pattern that was provided to the
  107.  * {@linkcode Regex} constructor.<br>
  108.  * The string is constructed as follows: "/"+{@linkcode Regex#source}+"/"+{@linkcode Regex#flags}
  109.  * @return {string}
  110.  */
  111. Regex.prototype.toString = function () {
  112.     return ('/' + this.source + '/' + this.flags);
  113. }
  115. /**
  116.  * Simply invokes the inherited method {@linkcode RegExp#test}.
  117.  * @param {string} [str]
  118.  * @return {boolean}
  119.  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test
  120.  * @see http://www.ecma-international.org/ecma-262/6.0/#sec-regexp.prototype.test
  121.  */
  122. Regex.prototype.test = function (str) {
  123.     return this.regex.test(str);
  124. }
  126. /**
  127.  * Simply invokes the inherited method {@linkcode RegExp[Symbol.search]}.
  128.  * @param {string} str
  129.  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@search
  130.  * @see http://www.ecma-international.org/ecma-262/6.0/#sec-regexp.prototype-@@search
  131.  * @alias Regex.search
  132.  */
  133. Regex.prototype[Symbol.search] = function (str) {
  134.     return this.regex[Symbol.search](str);
  135. }
  137. /**
  138.  * Simply invokes the inherited method {@linkcode RegExp[Symbol.split]}.
  139.  * @param {string} str
  140.  * @param {number} [limit]
  141.  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@split
  142.  * @see http://www.ecma-international.org/ecma-262/6.0/#sec-regexp.prototype-@@split
  143.  * @alias Regex.split
  144.  */
  145. Regex.prototype[Symbol.split] = function (str, limit) {
  146.     return this.regex[Symbol.split](str);
  147. }
  149. /**
  150.  * Full indexed exec method: Based on {@linkcode RegExp#exec} but instead of simply getting "index" in the return which
  151.  * only tells the starting of the first group (0 group) we are getting "index[0..n]" which tells us the starting index
  152.  * of each matching group.<br>
  153.  * <code>
  154.  * Syntax: <b>(new Regex(pattern, flags)).exec(string) = {string[0..n], index:number[0..n], input:string}</b><br>
  155.  * Example:<br>
  156.  * //Retrieve content and position of: opening-, closing tags and body content for: non-nested html-tags.
  157.  * var pattern = '(&lt;([^ &gt;]+)[^&gt;]*&gt;)([^&lt;]*)(&lt;\\/\\2&gt;)';<br>
  158.  * var str = '&lt;html&gt;&lt;code class="html plain"&gt;first&lt;/code&gt;&lt;div class="content"&gt;second&lt;/div&gt;&lt;/html&gt;';<br>
  159.  * var regex = new Regex(pattern, 'g');<br>
  160.  * var result = regex.exec(str);<br>
  161.  * <br>
  162.  * console.log(5 === result.length);<br>
  163.  * console.log('&lt;code class="html plain"&gt;first&lt;/code&gt;'=== result[0]);<br>
  164.  * console.log('&lt;code class="html plain"&gt;'=== result[1]);<br>
  165.  * console.log('first'=== result[3]);<br>
  166.  * console.log('&lt;/code&gt;'=== result[4]);<br>
  167.  * console.log(5=== result.index.length);<br>
  168.  * console.log(6=== result.index[0]);<br>
  169.  * console.log(6=== result.index[1]);<br>
  170.  * console.log(31=== result.index[3]);<br>
  171.  * console.log(36=== result.index[4]);<br>
  172.  * </code>
  173.  * <br>
  174.  * @param {string} [str]
  175.  * @return {Object} {string[0..n], index:number[0..n], input:string}
  176.  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec
  177.  * @see http://www.ecma-international.org/ecma-262/6.0/#sec-regexp.prototype.exec
  178.  */
  179. Regex.prototype.exec = function (str) {
  180.     var result = [];
  181.     result.index = [];
  182.     var resultRegex = this.regex.exec(str);
  183.     this.lastIndex = this.regex.lastIndex;
  185.     if (!resultRegex) {
  186.         return resultRegex;
  187.     }
  188.     result[0] = resultRegex[0];
  189.     result.index[0] = resultRegex.index;
  190.     result.input = str;
  192.     var execInternal = function (strPosition, regexGroupStructureChildren) {
  193.         var currentStrPos = strPosition;
  194.         for (var i = 0; i < regexGroupStructureChildren.length; i++) {
  195.             var index = regexGroupStructureChildren[i][0];
  196.             var originalIndex = regexGroupStructureChildren[i][1];
  197.             if (originalIndex) {
  198.                 result[originalIndex] = resultRegex[index];
  199.                 if (typeof result[originalIndex] === "undefined") {
  200.                     result.index[originalIndex] = undefined;
  201.                 } else {
  202.                     result.index[originalIndex] = currentStrPos;
  203.                 }
  204.             }
  205.             if (regexGroupStructureChildren[i][3]) {
  206.                 execInternal(currentStrPos, regexGroupStructureChildren[i][3]);
  207.             }
  208.             if (typeof resultRegex[index] !== "undefined") {
  209.                 currentStrPos += resultRegex[index].length;
  210.             }
  211.         }
  212.     };
  213.     if (this.regexGroupStructure && this.regexGroupStructure[0][3]) {
  214.         execInternal(resultRegex.index, this.regexGroupStructure[0][3]);
  215.     }
  216.     return result;
  217. };
  219. /**
  220.  * Full detailed match. Based on {@linkcode RegExp[Symbol.match]} with some improvements regarding the return value. Analogue to the base
  221.  * method {@linkcode RegExp[Symbol.match]} internally the method {@linkcode Regex#exec} is called. And there are 2
  222.  * improvements related to this: First improvement is that {@linkcode Regex#exec} returns the index for all matching
  223.  * groups and Second improvement is that we always return a 2-dimensional array independent of whether the global 'g'
  224.  * flag is set or not. If the 'g' flag is not set then first dimension only contains one element which is the result
  225.  * of {@linkcode Regex#exec} and if the flag is set the size of the first dimension equals the number of matches we had
  226.  * and each match contains the {@linkcode Regex#exec} result for the corresponding execution.
  227.  * @param [str] {String}
  228.  * @return {Object} Array[{string[0..n], index:number[0..n], input:string}]
  229.  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@match
  230.  * @see http://www.ecma-international.org/ecma-262/6.0/#sec-regexp.prototype-@@match
  231.  * @alias Regex.match
  232.  */
  233. Regex.prototype[Symbol.match] = function (str) {
  234.     this.lastIndex = 0;
  235.     this.regex.lastIndex = 0;
  237.     var resultExec = this.exec(str);
  238.     if (!resultExec) {
  239.         return null;
  240.     }
  242.     var resultExecArray = [];
  244.     while (resultExec) {
  245.         resultExecArray.push(resultExec);
  246.         if (resultExec[0].length === 0) {
  247.             this.regex.lastIndex++;
  248.         }
  249.         if (!this.global) {
  250.             break;
  251.         }
  252.         resultExec = this.exec(str);
  253.     }
  255.     this.lastIndex = 0;
  256.     this.regex.lastIndex = 0;
  257.     return resultExecArray;
  258. }
  260. /**
  261.  * Group based search & replace. Based on {@linkcode Regex.prototype[Symbol.replace]} but instead of only being able to provide a
  262.  * single "replacement substring" or "replacement function" for replacement of the entire match (aka matching-group[0])
  263.  * we can provide an array [0..n] of "replacement substring" or "replacement function" elements for replacement of
  264.  * each matching group [0..n].
  265.  * <br>
  266.  * Important: If we don't want a group to be replaced we provide the corresponding "replacement substring/function"
  267.  * array element as undefined or null!
  268.  * <br>
  269.  * Important: If we provide a "replacement substring/function" for a parent group-element then (obviously) no
  270.  * replacement is performed on its child-group-elements. E.g. if we provide a "replacement substring/function"
  271.  * for group 0 then the entire match is replaced and (obviously) no replacement of the further child-groups
  272.  * takes place!
  273.  * <br>
  274.  * <br>
  275.  * <code>
  276.  * Syntax: <b>(new Regex(pattern))[Symbol.replace](string, [array of replacement strings])</b><br>
  277.  * Alternative Syntax: For browsers supporting "Symbol": Chrome & Firefox: string.replace(new Regex(pattern), [array of replacement strings])<br>
  278.  * Example:<br>
  279.  * //Convert plain text to html: Replace special characters (multiple spaces, tabs, ...) in plain text with their html "equivalent":<br>
  280.  * var CONVERT_TEXT_SPECIAL_CHARACTER_TO_HTML_ESCAPE_CHARACTER_PATTERN = "( {2})|(\t)|(&)|(<)|(>)|(\n)";<br>
  281.  * var CONVERT_TEXT_SPECIAL_CHARACTER_TO_HTML_ESCAPE_CHARACTER_PATTERN_REPLACE_STRING = [undefined, "&amp;nbsp;&amp;nbsp;", "&amp;emsp;", "&amp;amp;", "&amp;lt;", "&amp;gt;", "&lt;br&gt;"];<br>
  282.  * var regex = new Regex(CONVERT_TEXT_SPECIAL_CHARACTER_TO_HTML_ESCAPE_CHARACTER_PATTERN, 'g');<br>
  283.  * var result = regex[Symbol.replace](myPlainText,CONVERT_TEXT_SPECIAL_CHARACTER_TO_HTML_ESCAPE_CHARACTER_PATTERN_REPLACE_STRING);<br>
  284.  * //Alternative Syntax: For browsers supporting "Symbol": Chrome & Firefox<br>
  285.  * var resultAlternative = myPlainText.replace(regex,CONVERT_TEXT_SPECIAL_CHARACTER_TO_HTML_ESCAPE_CHARACTER_PATTERN_REPLACE_STRING);
  286.  * </code>
  287.  * <br>
  288.  * <br>
  289.  * Special (in addition to the standard search and replace): We support in the "new substring" as well $0 as replacement
  290.  * pattern which is basically the entire match.
  291.  * And accordingly for the "new function" we call it as well with p0 as parameter which is the entire match.
  292.  *
  293.  * @param [str] {String}
  294.  * @param [newSubstringFunctionArray] {String[]|function[]|String|function}
  295.  * @return {string}
  296.  * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/@@replace
  297.  * @see http://www.ecma-international.org/ecma-262/6.0/#sec-regexp.prototype-@@replace
  298.  * @alias Regex.replace
  299.  */
  300. Regex.prototype[Symbol.replace] = function (str, newSubstringFunctionArray) {
  301.     this.lastIndex = 0;
  302.     this.regex.lastIndex = 0;
  303.     if (!str) {
  304.         return str;
  305.     }
  306.     // if (!newSubstringFunctionArray && newSubstringFunctionArray !== "") {
  307.     //     return newSubstringFunctionArray;
  308.     //     // newSubstringFunctionArray = '' + newSubstringFunctionArray;
  309.     //     // console.log(newSubstringFunctionArray);
  310.     // }
  312.     var resultExec = this.exec(str);
  313.     if (!resultExec) {
  314.         return str;
  315.     }
  317.     if (!(newSubstringFunctionArray instanceof Array)) {
  318.         newSubstringFunctionArray = [newSubstringFunctionArray];
  319.     }
  321.     var resultString = '';
  322.     var resultStringPosition = 0;
  324.     var computeSubstringFunction = function (newSubstringFunctionIndex) {
  325.         var computedString = '';
  326.         var charAt = '';
  327.         var newSubstringFunction = newSubstringFunctionArray[newSubstringFunctionIndex];
  328.         // if(!newSubstringFunction){
  329.         //     newSubstringFunction += '';
  330.         // }
  331.         if (typeof newSubstringFunction === 'string') {
  332.             for (var i = 0; i < newSubstringFunction.length; i++) {
  333.                 charAt = newSubstringFunction.charAt(i);
  334.                 if (charAt === '$') {
  335.                     i++;
  336.                     charAt = newSubstringFunction.charAt(i);
  337.                     if (charAt === '$') {
  338.                         computedString += '$';
  339.                     } else if (charAt === '&') {
  340.                         computedString += resultExec[newSubstringFunctionIndex];
  341.                     } else if (charAt === '`') {
  342.                         computedString += str.substring(0, resultExec.index[newSubstringFunctionIndex]);
  343.                     } else if (charAt === "'") {
  344.                         computedString += str.substring(resultExec.index[newSubstringFunctionIndex] + resultExec[newSubstringFunctionIndex].length);
  345.                     } else if (charAt >= '0' && charAt <= '9') {
  346.                         var int = charAt;
  347.                         i++;
  348.                         charAt = newSubstringFunction.charAt(i);
  349.                         while (charAt >= '0' && charAt <= '9') {
  350.                             int += charAt;
  351.                             i++;
  352.                             charAt = newSubstringFunction.charAt(i);
  353.                         }
  354.                         i--;
  355.                         if (resultExec[int]) {
  356.                             computedString += resultExec[int];
  357.                         } else {
  358.                             computedString += '$' + int;
  359.                         }
  360.                     } else {
  361.                         //strange not sure whether this is correct - initially it was: computedString += charAt;
  362.                         //but unit tests in NPM told differently!...
  363.                         computedString += '$' + charAt;
  364.                     }
  365.                 } else {
  366.                     computedString += charAt;
  367.                 }
  368.             }
  369.         } else if (newSubstringFunction instanceof Function) {
  370.             var args = [resultExec[newSubstringFunctionIndex]];
  371.             for (var j = 0; j < resultExec.length; j++) {
  372.                 args.push(resultExec[j]);
  373.             }
  374.             for (var k = 0; j < resultExec.index.length; k++) {
  375.                 args.push(resultExec.index[k]);
  376.             }
  377.             args.push(str);
  378.             computedString += newSubstringFunction.apply(this, args);
  379.         }
  380.         return computedString;
  381.     }
  383.     var traverseRegexGroupStructure = function (regexGroupStructureChildren) {
  384.         for (var i = 0; i < regexGroupStructureChildren.length; i++) {
  385.             var originalIndex = regexGroupStructureChildren[i][1];
  386.             if (originalIndex) {
  387.                 if (newSubstringFunctionArray[originalIndex] || newSubstringFunctionArray[originalIndex] === "") {
  388.                     if (resultExec[originalIndex] || resultExec[originalIndex] === "") {
  389.                         resultString += str.substring(resultStringPosition, resultExec.index[originalIndex]) + computeSubstringFunction(originalIndex);
  390.                         resultStringPosition = resultExec.index[originalIndex] + resultExec[originalIndex].length;
  391.                     }
  392.                 } else if (regexGroupStructureChildren[i][3]) {
  393.                     traverseRegexGroupStructure(regexGroupStructureChildren[i][3]);
  394.                 }
  395.             } else {
  396.                 traverseRegexGroupStructure(regexGroupStructureChildren[i][3]);
  397.             }
  398.         }
  399.     };
  400.     while (resultExec) {
  401.         if (newSubstringFunctionArray[0] || newSubstringFunctionArray[0] === "") {
  402.             resultString += str.substring(resultStringPosition, resultExec.index[0]) + computeSubstringFunction(0);
  403.             resultStringPosition = resultExec.index[0] + resultExec[0].length;
  404.         } else if (this.regexGroupStructure && this.regexGroupStructure[0][3]) {
  405.             traverseRegexGroupStructure(this.regexGroupStructure[0][3]);
  406.         }
  407.         // 20170415 - avoid infinite loop according to specification!
  408.         if (resultExec[0].length === 0) {
  409.             this.regex.lastIndex++;
  410.         }
  411.         if (!this.global) {
  412.             break;
  413.         }
  414.         resultExec = this.exec(str);
  415.     }
  417.     this.lastIndex = 0;
  418.     this.regex.lastIndex = 0;
  419.     return resultString + str.substring(resultStringPosition, str.length);
  420. }
  422. /**
  423.  * Takes the regular expression "regex" as input and puts all the non-grouped regex characters before a group
  424.  * opening "(") into additional groups: "(xyz)" so in the end all relevant parts of the regular expression
  425.  * (relevant in the sense that they are required to calculate the starting position of each group) are grouped.
  426.  * AND finally returns the group structure of this regex:
  427.  * [[index, originalIndex, 'regexForThisGroup', [[child01Index, child01OriginalIndex, 'regexForThisChild01Group', [...]], [child02Index, child02OriginalIndex, ..., [...]], ...]]].
  428.  * The array elements are:
  429.  * - index: This is the group index in the regular expression
  430.  * - originalIndex: This is the groups index in the initial/original regular expression. "originalIndex" is "undefined"
  431.  * if this group was the result of the group completion.
  432.  * - regexForThisGroup: The regular expression of this group including its parantheses
  433.  * - child-array: An array containing the child regular expressions
  434.  *
  435.  * SPECIAL: indexMap: The first element contains one more array element: [1]: indexMap: This array maps the
  436.  * original-index [0..n] to the actual-index [0..m]
  437.  *
  438.  * SPECIAL: source: The first element contains one more array element: [2]: source: This is the initial regular
  439.  * expression pattern and the only reason this is required is because in RegExp.source the slash "/" needs to be
  440.  * escaped.
  441.  *
  442.  * Rule for group parsing: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
  443.  * And: http://www.ecma-international.org/ecma-262/6.0/#sec-regexp-regular-expression-objects
  444.  * The capturing groups are numbered according to the order of left parentheses of capturing groups, starting from 1.
  445.  * The matched substring can be recalled from the resulting array's elements [1], ..., [n] or from the predefined
  446.  * RegExp object's properties $1, ..., $9.
  447.  * The good thing is that the regular expression rules around groups (and as well in most other parts of the regular
  448.  * expression) did not change between the different ECMA Script versions respective did not have any impact on the
  449.  * group parsing and therefore this function is compatible between the different browsers!
  450.  *
  451.  * @param {String} [regex]
  452.  * @returns {*}
  453.  */
  454. function getRegexCompleteGroupingStructure(regex) {
  455.     if (!regex) {
  456.         console.error('The "regex" is empty! Returning empty array!');
  457.         return [];
  458.     }
  459.     var indexMap = [];
  460.     var source = [''];
  461.     var containsBackReference = [];
  462.     containsBackReference[0] = false;
  463.     var getRegexCompleteGroupingStructureInternalResult = getRegexCompleteGroupingStructureInternal(regex, [0, 0, 0], true, indexMap, source, containsBackReference);
  464.     if (containsBackReference[0]) {
  465.         var fixIndexOnGroupingStructure = function (groupingStructureElement) {
  466.             var regexForThisGroup = '';
  467.             var charAt;
  468.             for (var i = 0; i < groupingStructureElement[2].length; i++) {
  469.                 charAt = groupingStructureElement[2].charAt(i);
  470.                 regexForThisGroup += charAt;
  471.                 if (charAt === '\\') {
  472.                     if (i + 1 === groupingStructureElement[2].length) {
  473.                         continue;
  474.                     }
  475.                     i++;
  476.                     charAt = groupingStructureElement[2].charAt(i);
  477.                     var int = '';
  478.                     while (charAt >= '0' && charAt <= '9') {
  479.                         int += charAt;
  480.                         i++;
  481.                         charAt = groupingStructureElement[2].charAt(i);
  482.                     }
  483.                     if (int) {
  484.                         regexForThisGroup += indexMap[int];
  485.                         i--;
  486.                     } else {
  487.                         regexForThisGroup += charAt;
  488.                     }
  489.                     continue;
  490.                 }
  491.                 if (charAt === '[') {
  492.                     if (i + 1 === groupingStructureElement[2].length) {
  493.                         continue;
  494.                     }
  495.                     i++;
  496.                     charAt = groupingStructureElement[2].charAt(i);
  497.                     while ((charAt !== ']' || (groupingStructureElement[2].charAt(i - 1) === '\\' && groupingStructureElement[2].charAt(i - 2) !== '\\')) && i < groupingStructureElement[2].length) {
  498.                         regexForThisGroup += charAt;
  499.                         i++;
  500.                         charAt = groupingStructureElement[2].charAt(i);
  501.                     }
  502.                     regexForThisGroup += charAt;
  503.                     continue;
  504.                 }
  505.             }
  506.             groupingStructureElement[2] = regexForThisGroup;
  507.             for (var j = 0; j < groupingStructureElement[3].length; j++) {
  508.                 fixIndexOnGroupingStructure(groupingStructureElement[3][j]);
  509.             }
  510.         }
  511.         fixIndexOnGroupingStructure(getRegexCompleteGroupingStructureInternalResult);
  512.     }
  513.     return [getRegexCompleteGroupingStructureInternalResult, indexMap, source];
  514. }
  515. /**
  516.  * Description see getRegexCompleteGroupingStructure.
  517.  * @param regex
  518.  * @param posIndexOrigIndex - this array has 3 values:
  519.  * [0]:position: while iterating through the regular expression the parsing position is incremented starting at 0
  520.  * [1]:index: the index of the current group we are parsing
  521.  * [2]:original index: the original index the group had before we added additional groups
  522.  * @param isCapturingGroup - tells us whether this group of characters enclosed within parantheses is a capturing group
  523.  * or not. If not it could be a non capturing group (?:xyz) or an assertion which starts as well with a group bracket
  524.  * "(" character but is followed with a "?=" or "?!" and tells us that this is not a capturing group
  525.  * @param indexMap this array maps the original-index [0..n] to the actual-index [0..m]
  526.  * @param source This is the initial regular expression pattern and the only reason this is required is because in
  527.  * RegExp.source the slash "/" needs to be escaped.
  528.  * @returns {*}
  529.  */
  530. function getRegexCompleteGroupingStructureInternal(regex, posIndexOrigIndex, isCapturingGroup, indexMap, source, containsBackReference) {
  531.     var groupStructure;
  532.     if (isCapturingGroup) {
  533.         groupStructure = [posIndexOrigIndex[1], posIndexOrigIndex[2], '', []];
  534.         indexMap[posIndexOrigIndex[2]] = posIndexOrigIndex[1];
  535.     } else {
  536.         groupStructure = [undefined, undefined, '', []];
  537.     }
  538.     var tmpStr = '';
  539.     var charAt;
  540.     for (posIndexOrigIndex[0]; posIndexOrigIndex[0] < regex.length; posIndexOrigIndex[0]++) {
  541.         charAt = regex.charAt(posIndexOrigIndex[0]);
  542.         if (charAt === '\\') {
  543.             //handle escape character
  544.             if (posIndexOrigIndex[0] + 1 === regex.length) {
  545.                 tmpStr += '\\';
  546.                 source[0] += '\\';
  547.                 continue;
  548.             }
  549.             posIndexOrigIndex[0]++;
  550.             charAt = regex.charAt(posIndexOrigIndex[0]);
  551.             //check whether we have a back-reference and adjust it according to the shift in the index-map
  552.             var int = '';
  553.             //Back references above \9 behave strange and different in every language. In
  554.             // Java-Script they are treated as back-reference if the group is existing otherwise they are treated
  555.             // as character escape sequence.
  556.             while (charAt >= '0' && charAt <= '9') {
  557.                 int += charAt;
  558.                 posIndexOrigIndex[0]++;
  559.                 charAt = regex.charAt(posIndexOrigIndex[0]);
  560.             }
  561.             if (int) {
  562.                 if (indexMap[int]) {
  563.                     //if a group exists then back-reference to the group
  564.                     //20170416 - bug the index map can change later if additional surrounding paranthesis are added
  565.                     //Therefore this calculation needs to be done in the end!
  566.                     //tmpStr += '\\' + indexMap[int];
  567.                     tmpStr += '\\' + int;
  568.                     containsBackReference[0] = true;
  569.                 } else {
  570.                     if (int.indexOf('8') >= 0 || int.indexOf('9') >= 0) {
  571.                         //if it is a non octal digit then treat it as simple number
  572.                         tmpStr += int;
  573.                     } else {
  574.                         //otherwise it is a character escape
  575.                         tmpStr += '\\' + 'x' + ("0" + (parseInt(int, 8).toString(16))).slice(-2).toUpperCase();
  576.                     }
  577.                 }
  578.                 source[0] += '\\' + int;
  579.                 posIndexOrigIndex[0]--;
  580.             } else {
  581.                 tmpStr += '\\' + charAt;
  582.                 source[0] += '\\' + charAt;
  583.             }
  584.             continue;
  585.         }
  586.         if (charAt === '[') {
  587.             //parse character set
  588.             tmpStr += '[';
  589.             source[0] += '[';
  590.             if (posIndexOrigIndex[0] + 1 === regex.length) {
  591.                 continue;
  592.             }
  593.             posIndexOrigIndex[0]++;
  594.             charAt = regex.charAt(posIndexOrigIndex[0]);
  595.             while ((charAt !== ']' || (regex.charAt(posIndexOrigIndex[0] - 1) === '\\' && regex.charAt(posIndexOrigIndex[0] - 2) !== '\\')) && posIndexOrigIndex[0] < regex.length) {
  596.                 tmpStr += charAt;
  597.                 source[0] += charAt;
  598.                 posIndexOrigIndex[0]++;
  599.                 charAt = regex.charAt(posIndexOrigIndex[0]);
  600.             }
  601.             tmpStr += charAt;
  602.             source[0] += charAt;
  603.             continue;
  604.         }
  605.         if (charAt === '|') {
  606.             //finalize pending tmp group string if any
  607.             //20170327 - this is not necessary
  608.             // if (tmpStr && groupStructure[3].length > 0) {
  609.             //     //complete grouping: put trailing and pending characters sequences into groups
  610.             //     posIndexOrigIndex[1]++;
  611.             //     tmpStr = '(' + tmpStr + ')';
  612.             //     groupStructure[3].push([posIndexOrigIndex[1], , tmpStr, []]);
  613.             // }
  614.             groupStructure[2] += tmpStr + '|';
  615.             tmpStr = '';
  616.             source[0] += '|';
  617.             continue;
  618.         }
  619.         if (charAt === ')') {
  620.             //handle group ending
  621.             //20170327 - not required to group here because it is already contained in a parent group
  622.             // if (tmpStr && groupStructure[3].length > 0) {
  623.             //     //complete grouping: put trailing and pending characters sequences into groups
  624.             //     posIndexOrigIndex[1]++;
  625.             //     tmpStr = '(' + tmpStr + ')';
  626.             //     groupStructure[3].push([posIndexOrigIndex[1], , tmpStr, []]);
  627.             // }
  628.             groupStructure[2] += tmpStr + ')';
  629.             source[0] += ')';
  630.             return groupStructure;
  631.         }
  632.         if (charAt === '(') {
  633.             //handle group start
  634.             if (tmpStr) {
  635.                 //complete grouping: put trailing and pending characters sequences into non remembering groups
  636.                 posIndexOrigIndex[1]++;
  637.                 tmpStr = '(' + tmpStr + ')';
  638.                 groupStructure[3].push([posIndexOrigIndex[1], undefined, tmpStr, []]);
  639.             }
  640.             posIndexOrigIndex[0]++;
  641.             var regexGroupStructureInternal;
  642.             var idx = posIndexOrigIndex[1] + 1;
  643.             isCapturingGroup = true;
  644.             // check whether group is an assertion
  645.             if (regex.charAt(posIndexOrigIndex[0]) === '?' && posIndexOrigIndex[0] + 1 < regex.length && (regex.charAt(posIndexOrigIndex[0] + 1) === '=' || regex.charAt(posIndexOrigIndex[0] + 1) === '!' || regex.charAt(posIndexOrigIndex[0] + 1) === ':')) {
  646.                 //Handle assertion
  647.                 posIndexOrigIndex[0]++;
  648.                 var assertionChar = regex.charAt(posIndexOrigIndex[0]);
  649.                 posIndexOrigIndex[0]++;
  650.                 //we only set isCapturingGroup to false in case it is a non capturing group. For assertion groups
  651.                 //i.e. positive-/negative-lookahead the parser steps back after the parsing of the lookahead and
  652.                 //therefore (see if statement further down) we don't need to set the assertion groups into additional
  653.                 //paranthesis.
  654.                 //In other words at the end of a lookahead or a lookbehind, the regex engine hasn't moved on the string.
  655.                 // You can chain three more lookaheads after the first, and the regex engine still won't move.
  656.                 if (assertionChar === ':') {
  657.                     isCapturingGroup = false;
  658.                 }
  659.                 source[0] += '(?' + assertionChar;
  660.                 regexGroupStructureInternal = getRegexCompleteGroupingStructureInternal(regex, posIndexOrigIndex, false, indexMap, source, containsBackReference);
  661.                 regexGroupStructureInternal[2] = '(?' + assertionChar + regexGroupStructureInternal[2];
  662.             } else {
  663.                 posIndexOrigIndex[1]++;
  664.                 posIndexOrigIndex[2]++;
  665.                 source[0] += '(';
  666.                 regexGroupStructureInternal = getRegexCompleteGroupingStructureInternal(regex, posIndexOrigIndex, true, indexMap, source, containsBackReference);
  667.                 regexGroupStructureInternal[2] = '(' + regexGroupStructureInternal[2];
  668.             }
  670.             //20170327 - special handling if we have a capturing group with a quantifier then we need to
  671.             //put the quantified group into additional paranthesis otherwise only the first group matches!
  672.             var quantifierStart = posIndexOrigIndex[0];
  673.             var quantifierString = '';
  674.             if (posIndexOrigIndex[0] + 1 < regex.length) {
  675.                 //parse quantifier
  676.                 charAt = regex.charAt(posIndexOrigIndex[0] + 1);
  677.                 if (charAt === '*') {
  678.                     posIndexOrigIndex[0]++;
  679.                     quantifierString = '*';
  680.                 } else if (charAt === '+') {
  681.                     posIndexOrigIndex[0]++;
  682.                     quantifierString = '+';
  683.                 } else if (charAt === '?') {
  684.                     posIndexOrigIndex[0]++;
  685.                     quantifierString = '?';
  686.                 } else if (charAt === '{') {
  687.                     posIndexOrigIndex[0]++;
  688.                     quantifierString = '{';
  689.                     posIndexOrigIndex[0]++;
  690.                     charAt = regex.charAt(posIndexOrigIndex[0]);
  691.                     while (charAt >= '0' && charAt <= '9' && posIndexOrigIndex[0] < regex.length) {
  692.                         quantifierString += charAt;
  693.                         posIndexOrigIndex[0]++;
  694.                         charAt = regex.charAt(posIndexOrigIndex[0]);
  695.                     }
  696.                     if (charAt === '}') {
  697.                         quantifierString += '}';
  698.                     } else {
  699.                         if (charAt === ',') {
  700.                             quantifierString += ',';
  701.                             posIndexOrigIndex[0]++;
  702.                             charAt = regex.charAt(posIndexOrigIndex[0]);
  703.                             while (charAt >= '0' && charAt <= '9' && posIndexOrigIndex[0] < regex.length) {
  704.                                 quantifierString += charAt;
  705.                                 posIndexOrigIndex[0]++;
  706.                                 charAt = regex.charAt(posIndexOrigIndex[0]);
  707.                             }
  708.                             if (charAt === '}') {
  709.                                 quantifierString += '}';
  710.                             } else {
  711.                                 quantifierString = '';
  712.                             }
  713.                         } else {
  714.                             quantifierString = '';
  715.                         }
  716.                     }
  717.                 }
  718.                 if (quantifierString.length > 0) {
  719.                     regexGroupStructureInternal[2] += quantifierString;
  720.                     source[0] += quantifierString;
  721.                     if (regex.charAt(posIndexOrigIndex[0] + 1) === '?') {
  722.                         posIndexOrigIndex[0]++;
  723.                         regexGroupStructureInternal[2] += '?';
  724.                         source[0] += '?';
  725.                     }
  726.                 } else {
  727.                     posIndexOrigIndex[0] = quantifierStart;
  728.                 }
  729.             }
  730.             //20170327 - special handling if we have a non capturing group then we need to put this group into
  731.             // additional paranthesis otherwise we don't know the size of the group !
  732.             if (quantifierString.length > 0 || !isCapturingGroup) {
  733.                 incrementRegexGroupStructureIndex(regexGroupStructureInternal, indexMap);
  734.                 regexGroupStructureInternal = [idx, undefined, '(' + regexGroupStructureInternal[2] + ')', [regexGroupStructureInternal]];
  735.                 posIndexOrigIndex[1]++;
  736.             }
  738.             groupStructure[2] += tmpStr + regexGroupStructureInternal[2];
  739.             groupStructure[3].push(regexGroupStructureInternal);
  740.             tmpStr = '';
  741.         } else {
  742.             charAt = regex.charAt(posIndexOrigIndex[0]);
  743.             tmpStr += charAt;
  744.             if (charAt === '/') {
  745.                 source[0] += '\\' + charAt;
  746.             } else {
  747.                 source[0] += charAt;
  748.             }
  749.         }
  750.     }
  751.     //we only get here in the top-most iteration i.e. for matching group 0 which has no enclosing paranthesis
  752.     groupStructure[2] += tmpStr;
  753.     return groupStructure;
  754. }
  756. function incrementRegexGroupStructureIndex(regexGroupStructure, indexMap) {
  757.     if (regexGroupStructure[0]) {
  758.         regexGroupStructure[0]++;
  759.         if (regexGroupStructure[1]) {
  760.             indexMap[regexGroupStructure[1]] = regexGroupStructure[0];
  761.         }
  762.     }
  763.     for (var i = 0; i < regexGroupStructure[3].length; i++) {
  764.         incrementRegexGroupStructureIndex(regexGroupStructure[3][i], indexMap);
  765.     }
  766. }
  768. function initialize() {
  769.     if (!(typeof module === "undefined")) {
  770.         module.exports = Regex;
  771.     }
  772. }
  773. initialize();