erp_app 3.1.16 → 4.0.0

data/public/javascripts/erp_app/ckeditor/plugins/sourcepopup/codemirror/editor/contrib/regex/js/parseregex.js

@@ -1,847 +0,0 @@
-/* Simple parser for Regular Expressions */
-/* Thanks to Marijn for patiently addressing some questions and to 
- * Steven Levithan for XRegExp http://xregexp.com/ for pointing the way to the regexps for the regex (I
- * only discovered his own regex syntax editor RegexPal later on) */
-
-/*
-// Possible future to-dos:
-0) Unicode plugin fix for astral and update for Unicode 6.0.0
-1) Allow parsing of string escaped regular expressions (e.g., \\ as \ and regular \n as an actual newline) and
-     could potentially integrate into parsing for other languages where known (e.g., string inside RegExp constructor)
-2) If configured, allow parsing of replace strings (e.g., $1, \1)
-3) Shared classes
-      a) As with ranges and unicode classes, could also try to supply equivalents which list all
-              characters inside a whole character class
-      b) Add common classes for ranges, inside char. classes, and allow for alternation of colors
-4) Groups
-      a) detect max's (or even inner_group_mode) from CSS if specified as "max-available"
-          _cssPropertyExists('span.regex-max-available') || _cssPropertyExists('.regex-max-available');
-      b) Remove inner_group_mode and just always both uniform and type-based styles? (first improve
-            inner_group_mode performance when on)
-5) Expand configuration for different flavors of regex or language implementations corresponding to config
-     options
-6) Allow free-spacing mode to work with newlines?
-*/
-
-/**
- * OPTIONS (SETUP):
- * "possible_flags": {String} All flags to support (as a string of joined characters); default is 'imgxs';
- *                                                      if 'literal' is on, this will check for validity against the literal flags, but
- *                                                      use the literal flags
- * "flags": {String} List of flags to use on this query; will be added to any literals; default is ''
- * "literal": {Boolean} Whether inside a literal or not
- * "literal_initial": {String} The initial character to surround regular expression (optionally followed by flags);
- *                                                  A forward slash ("/"), by default
- *
- * OPTIONS (STYLING)
- * "inner_group_mode": {'type'|'uniform'} Indicates how (if at all) to style content inside groups; if by "type",
- *                                                                              the class will be assigned by type; if "uniform", a class named
- *                                                                              "regex-group-<lev>-<seq>" where <lev> is the nesting level and
- *                                                                              <seq> is the sequence number; the "uniform" option allows grouped
- *                                                                              content to be styled consistently (but potentially differently from
- *                                                                              the parentheses themselves) no matter the type of group
- * "max_levels": {Number|String} Maximum number of nesting levels before class numbers repeat
- * "max_alternating": {Number|String} Maximum number of alternating sequences at the same level before
- *                                                                          class numbers repeat
- *
- * OPTIONS (PATTERNS)
- * "flavor": {'all'|'ecma-262-ed5'|'ecma-262-ed3'} Sets defaults for the following patterns according to the regex flavor
- *
- * "unicode_mode": {'simple'|'validate'|'store'} Mode for handling Unicode classes; unless 'simple' is chosen, may
- *                                                                                      affect performance given initial need to load and subsequent need
- *                                                                                      to parse and validate (i.e., selectively color), and, if 'store' is chosen,
- *                                                                                      also makes these (many) additional values on the token object, e.g.,
- *                                                                                      for use by activeTokens for adding tooltips; Default is 'simple' which
- *                                                                                      simply checks that the values are plausible;
- *                                                                                      Note: To include Unicode validation, you must include your
- *                                                                                                      CodeMirror parserfile in this sequence:
- *                                                                                          parserfile: ["parseregex.js", "parseregex-unicode.js"]
- * "unicode_classes": {Boolean} Whether to accept all Unicode classes (unless overridden); default is true
- * "unicode_blocks": {Boolean} Whether to accept Unicode blocks (overrides unicode_classes default); e.g., \p{InArabic}
- * "unicode_scripts": {Boolean} Whether to accept Unicode scripts (overrides unicode_classes default); e.g., \p{Hebrew}
- * "unicode_categories": {Boolean} Whether to accept Unicode categories (overrides unicode_classes default); e.g., \p{Ll} (for lower-case letters)
- * "named_backreferences": {Boolean} Whether to accept named backreferences; default is true
- * "empty_char_class": {Boolean} Whether to allow [] or [^] as character classes; default is true
- * "mode_modifier": {Boolean} Whether to allow (?imsx) mode modifiers
- *
- * NOTE
- * You can add the following to your CodeMirror configuration object in order to get simple tooltips showing the
- *     character equivalent of an escape sequence:
-     activeTokens : function (spanNode, tokenObject, editor) {
-        if (tokenObject.equivalent) {
-            spanNode.title = tokenObject.equivalent;
-        }
-    },
-....or this more advanced one which adds ranges (though you may wish to change the character limit, being
-    aware that browsers have a limitation on tooltip size, unless you were to also use a tooltip library which used
-    this information to expand the visible content):
-    activeTokens : (function () {
-        var charLimit = 500;
-        var lastEquivalent, rangeBegan, lastRangeHyphen;
-
-        function _buildTitle (beginChar, endChar) {
-            var beginCode = beginChar.charCodeAt(0), endCode = endChar.charCodeAt(0);
-            var title = '';
-            if (endCode - beginCode <= charLimit) {
-                for (var i = beginCode; i <= endCode; i++) {
-                    title += String.fromCharCode(i);
-                }
-            }
-            return title;
-        }
-
-        return function (spanNode, token, editor) {
-            var content = token.content;
-            if (lastEquivalent && token.style === 'regex-class-range-hyphen') {
-                rangeBegan = true;
-                lastRangeHyphen = spanNode;
-            }
-            else if (rangeBegan) {
-                var beginChar = lastEquivalent;
-                var endChar = (token.equivalent || content);
-                lastRangeHyphen.title = _buildTitle(beginChar, endChar);
-                rangeBegan = false;
-                lastEquivalent = null;
-                //editor.reparseBuffer(); // title must be redrawn since already added previously (do below instead as locking up on undo?); too intensive to call this, but keeping here for record
-            }
-            else if (content === ']') {
-                rangeBegan = false;
-            }
-            else {
-                rangeBegan = false;
-                // Fix: 'regex-unicode-class-inside' not supported and should not be since it wouldn't make sense as a starting range?
-                lastEquivalent = token.equivalent || content;
-            }
-
-            if (token.display) {
-                spanNode.title = token.display;
-            }
-            else if (token.equivalent) {
-                if (token.unicode) {
-                    var range = /(.)-(.)/g;
-                    spanNode.title = token.equivalent.replace(range,
-                        function (n0, n1, n2) {
-                            return _buildTitle(n1, n2);
-                        }
-                    );
-                    // editor.reparseBuffer(); // too intensive to call this, but keeping here for record
-                }
-                else {
-                    spanNode.title = token.equivalent;
-                    // editor.reparseBuffer(); // too intensive to call this, but keeping here for record
-                }
-            }
-        };
-    }()),
- */
-
-
-var RegexParser = Editor.Parser = (function() {
-    
-    var regexConfigBooleanOptions = ['unicode_blocks', 'unicode_scripts', 'unicode_categories',
-                                                        'unicode_classes', 'named_backreferences', 'empty_char_class', 'mode_modifier'],
-        regexConfigStringOptions = ['unicode_mode'],  // Just for record-keeping
-        possibleFlags = 'imgxs',
-        config = {}, ucl;
-    // Resettable
-    var initialFound, endFound, charClassRangeBegun, negatedCharClass, mode_modifier_begun, flags = '',
-        groupTypes, groupCounts;
-        
-    config.literal_initial = '/';
-    
-    // Adapted from tokenize.js (not distinctly treating whitespace except for newlines)
-    function noWSTokenizer (source, state) {
-      var tokenizer = {
-        state: state,
-        take: function(type) {
-          if (typeof(type) == "string")
-            type = {style: type, type: type};
-          type.content = (type.content || "") + source.get();
-          type.value = type.content + source.get();
-          return type;
-        },
-        next: function () {
-          if (!source.more()) throw StopIteration;
-          var type;
-          if (source.equals("\n")) {
-            source.next();
-            return this.take("whitespace");
-          }
-          while (!type)
-            type = this.state(source, function(s) {tokenizer.state = s;});
-          return this.take(type);
-        }
-      };
-      return tokenizer;
-    }
-    
-    // Private static utilities
-    function _expandRange (type, name) { // More efficient than unpack in targeting only which we need (though ideally would not need to convert at all)
-        var codePt = /\w{4}/g,
-            unicode = RegexParser.unicode, group = unicode[type];
-        if (group.hasOwnProperty(name)) {
-            // group[name] = group[name].replace(codePt, '\\u$&'); // We shouldn't need this unless we start validating against a matching string
-            return group[name].replace(codePt,
-                function (n0) {
-                    if (n0 === '002D') {
-                        return 'U+' + n0; // Leave genuine hyphens unresolved so they won't get confused with range hyphens
-                    }
-                    return String.fromCharCode(parseInt('0x' + n0, 16)); // Fix: Would be more efficient to store as Unicode characters like this from the start
-                });
-        }
-        return false;
-    }
-
-    function _copyObj (obj, deep) {
-        var ret = {};
-        for (var p in obj) {
-            if (obj.hasOwnProperty(p)) {
-                if (deep && typeof obj[p] === 'object' && obj[p] !== null) {
-                    ret[p] = _copyObj(obj[p], deep);
-                }
-                else {
-                    ret[p] = obj[p];
-                }
-            }
-        }
-        return ret;
-    }
-
-    function _forEach (arr, h) {
-        for (var i = 0, arrl = arr.length; i < arrl; i++) {
-            h(arr[i], i);
-        }
-    }
-    function _setOptions (arr, value) {
-        arr = typeof arr === 'string' ? [arr] : arr;
-        _forEach(arr, function (item) {
-            config[item] = value;
-        });
-    }
-
-    function _cssPropertyExists (selectorText) {
-        var i = 0, j = 0, dsl = 0, crl = 0, ss, d = document,
-            _getPropertyFromStyleSheet =
-                function (ss, selectorText) {
-                    var rules = ss.cssRules ? ss.cssRules : ss.rules; /* Mozilla or IE */
-                    for (j = 0, crl = rules.length; j < crl; j++) {
-                        var rule = rules[j];
-                        try {
-                            if (rule.type === CSSRule.STYLE_RULE && rule.selectorText === selectorText) {
-                                return true;
-                            }
-                        }
-                        catch (err) { /* IE */
-                            if (rule.selectorText === selectorText) {
-                                return true;
-                            }
-                        }
-                    }
-                    return false;
-                };
-
-        var value;
-        for (i = 0, dsl = d.styleSheets.length; i < dsl; i++) {
-            ss = d.styleSheets[i];
-            value = _getPropertyFromStyleSheet(ss, selectorText);
-            if (value) {
-                break;
-            }
-        }
-        return value;
-    }
-
-    function _addFlags (f) {
-        if ((/[^a-z]/).test(f)) { // Could insist on particular flags
-            throw 'Invalid flag supplied to the regular expression parser';
-        }
-        flags += f;
-    }
-    function _setPossibleFlags (f) {
-        if ((/[^a-z]/).test(f)) { // Could insist on particular flags
-            throw 'Invalid flag supplied to the regular expression parser';
-        }
-        possibleFlags = f;
-    }
-    function _esc (s) {
-        return s.replace(/"[.\\+*?\[\^\]$(){}=!<>|:\-]/g, '\\$&');
-    }
-
-    var tokenizeRegex = (function() {
-        // Private utilities
-        function _hasFlag (f) {
-            return flags.indexOf(f) > -1;
-        }
-        function _lookAheadMatches (source, regex) {
-            var matches = source.lookAheadRegex(regex, true);
-            if (matches && matches.length > 1) { // Allow us to return the position of a match out of alternates
-                for (var i = matches.length - 1; i >= 0; i--) {
-                    if (matches[i] != null) {
-                        return i;
-                    }
-                }
-            }
-            return 0;
-        }
-
-        function validateUnicodeClass (negated, place, source) {
-            var neg = ' regex-' + negated + 'unicode', ret = 'regex-unicode-class-' + place + neg,
-                name, unicode = RegexParser.unicode;
-            if (!unicode) {
-                throw 'Unicode plugin of the regular expression parser not properly loaded';
-            }
-            if (config.unicode_categories) {
-                var categories = source.lookAheadRegex(/^\\[pP]{\^?([A-Z][a-z]?)}/, true);
-                if (categories) {
-                    name = categories[1];
-                    if (unicode.categories[name]) {
-                        return ret + '-category-' + place + neg + '-category-' + name + '-' + place;
-                    }
-                    return 'regex-bad-sequence';
-                }
-            }
-            if (config.unicode_blocks) {
-                var blocks = source.lookAheadRegex(/^\\[pP]{\^?(In[A-Z][^}]*)}/, true);
-                if (blocks) {
-                    name = blocks[1];
-                    if (unicode.blocks[name]) {
-                        return ret + '-block-' + place + neg + '-block-' + name + '-' + place;
-                    }
-                    return 'regex-bad-sequence';
-                }
-            }
-            if (config.unicode_scripts) {
-                var scripts = source.lookAheadRegex(/^\\[pP]{\^?([^}]*)}/, true);
-                if (scripts) {
-                    name = scripts[1];
-                    if (unicode.scripts[name]) {
-                        return ret + '-script-' + place + neg + '-script-' + name + '-' + place;
-                    }
-                    return 'regex-bad-sequence';
-                }
-            }
-            return false;
-        }
-
-        function unicode_class (source, place) {
-            var ret = 'regex-unicode-class-' + place + ' ', negated = '';
-            if (source.lookAheadRegex(/^\\P/) || source.lookAheadRegex(/^\\p{\^/)) {
-                negated = 'negated';
-            }
-            else if (source.lookAheadRegex(/^\\P{\^/)) { // Double-negative
-                return false;
-            }
-            switch (config.unicode_mode) {
-                case 'validate': case 'store':
-                    return validateUnicodeClass(negated, place, source);
-                case 'simple': // Fall-through
-                default:
-                    // generic: /^\\[pP]{\^?[^}]*}/
-                    if (config.unicode_categories && source.lookAheadRegex(/^\\[pP]{\^?[A-Z][a-z]?}/, true)) {
-                        return ret + 'regex-' + negated + 'unicode-category';
-                    }
-                    if (config.unicode_blocks && source.lookAheadRegex(/^\\[pP]{\^?In[A-Z][^}]*}/, true)) {
-                        return ret + 'regex-' + negated + 'unicode-block';
-                    }
-                    if (config.unicode_scripts && source.lookAheadRegex(/^\\[pP]{\^?[^}]*}/, true)) {
-                        return ret + 'regex-' + negated + 'unicode-script';
-                    }
-                    break;
-            }
-            return false;
-        }
-
-        // State functions
-        // Changed [\s\S] to [^\n] to avoid accidentally grabbing a terminating (auto-inserted place-holder?) newline
-        var inside_class_meta = /^\\(?:([0-3][0-7]{0,2}|[4-7][0-7]?)|(x[\dA-Fa-f]{2})|(u[\dA-Fa-f]{4})|(c[A-Za-z])|(-\\]^)|([bBdDfnrsStvwW0])|([^\n]))/;
-        function inside_class (source, setState) {
-            var ret;
-            if (source.lookAhead(']', true)) {
-                // charClassRangeBegun = false; // Shouldn't be needed
-                setState(customOutsideClass);
-                return 'regex-class-end';
-            }
-            if (negatedCharClass && source.lookAhead('^', true)) {
-                negatedCharClass = false;
-                return 'regex-class-negator';
-            }
-            if (source.lookAhead('-', true)) {
-                if (!charClassRangeBegun) {
-                    ret = 'regex-class-initial-hyphen';
-                }
-                else if (source.equals(']')) {
-                    ret = 'regex-class-final-hyphen';
-                }
-                else {
-                    return 'regex-class-range-hyphen';
-                }
-            }
-            else if (!source.equals('\\')) {
-                var ch = source.next();
-                if (config.literal && ch === config.literal_initial) {
-                    return 'regex-bad-character';
-                }
-                ret = 'regex-class-character';
-            }
-            else if ((ucl = unicode_class(source, 'inside'))) {
-                ret = ucl;
-            }
-            else if (source.lookAheadRegex(/^\\(\n|$)/)) { // Treat an ending backslash like a bad 
-                                                                                              //    character to avoid auto-adding of extra text
-                source.next();
-                ret = 'regex-bad-character';
-            }
-            else {
-                switch (_lookAheadMatches(source, inside_class_meta)) {
-                    case 1:
-                        ret = 'regex-class-octal';
-                        break;
-                    case 2:
-                        ret = 'regex-class-hex';
-                        break;
-                    case 3:
-                        ret = 'regex-class-unicode-escape';
-                        break;
-                    case 4:
-                        ret = 'regex-class-ascii-control';
-                        break;
-                    case 5:
-                        ret = 'regex-class-escaped-special';
-                        break;
-                    case 6:
-                        ret = 'regex-class-special-escape';
-                        break;
-                    case 7:
-                        ret = 'regex-class-extra-escaped';
-                        break;
-                    default:
-                        throw 'Unexpected character inside class, beginning ' + 
-                                        source.lookAheadRegex(/^[\s\S]+$/)[0] + ' and of length '+
-                                        source.lookAheadRegex(/^[\s\S]+$/)[0].length; // Shouldn't reach here
-                }
-            }
-            // Fix: Add this as a token property in the parser instead?
-            if (charClassRangeBegun) {
-                charClassRangeBegun = false;
-                ret += '-end-range';
-            }
-            else if (source.equals('-')) {
-                charClassRangeBegun = true;
-                ret += '-begin-range';
-            }
-            return ret;
-        }
-
-        // Changed [\s\S] to [^\n] to avoid accidentally grabbing a terminating (auto-inserted place-holder?) newline
-        var outside_class_meta = /^(?:\\(?:(0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?)|([1-9]\d*)|(x[\dA-Fa-f]{2})|(u[\dA-Fa-f]{4})|(c[A-Za-z])|([bBdDfnrsStvwW0])|([?*+])|([.\\[$|{])|([^\n]))|([?*+]\??)|({\d+(?:,\d*)?}\??))/;
-        function outside_class (source, setState) {
-            if ((ucl = unicode_class(source, 'outside'))) {
-                return ucl;
-            }
-            switch (_lookAheadMatches(source, outside_class_meta)) {
-                case 1:
-                    return 'regex-octal';
-                case 2:
-                    return 'regex-ascii';
-                case 3:
-                    return 'regex-hex';
-                case 4:
-                    return 'regex-unicode-escape';
-                case 5:
-                    return 'regex-ascii-control';
-                case 6:
-                    return 'regex-special-escape';
-                case 7:
-                    return 'regex-quantifier-escape'; // Fix: could probably just merge with escaped-special
-                case 8:
-                    return 'regex-escaped-special';
-                case 9:
-                    return 'regex-extra-escaped';
-                case 10:
-                    return 'regex-quantifiers';
-                case 11:
-                    return 'regex-repetition';
-                default:
-                    if (config.literal && source.lookAhead(config.literal_initial, true)) {
-                        if (!initialFound) {
-                            initialFound = true;
-                            return 'regex-literal-begin';
-                        }
-                        endFound = true;
-                        setState(beginFlags);
-                        return 'regex-literal-end';
-                    }
-                    if (source.lookAhead('|', true)) {
-                        return 'regex-alternator';
-                    }
-                    if (source.lookAheadRegex(/^\\$/, true)) {
-                        return 'regex-bad-character';
-                    }
-                    source.next();
-                    return 'regex-character';
-            }
-        }
-        function beginFlags (source, setState) {
-            var endFlags = source.lookAheadRegex(new RegExp('^[' + possibleFlags + ']*', ''), true);
-            if (endFlags == null) {
-                // Unrecognized flag used in regular expression literal
-                return 'regex-bad-character';
-            }
-            // Already confirmed validity earlier
-            setState(finished);
-            return 'regex-flags';
-        }
-        function finished () {
-            throw StopIteration;
-        }
-
-        function customOutsideClass (source, setState) {
-            if (config.named_backreferences && source.lookAheadRegex(/^\\k<([\w$]+)>/, true)) {
-                return 'regex-named-backreference';
-            }
-            if (_hasFlag('x') && source.lookAheadRegex(/^(?:#.*)+?/, true)) { // Fix: lookAheadRegex will avoid new lines; added extra '?' at end
-                // Regex should be /^(?:\s+|#.*)+?/  but this was problematic
-                return 'regex-free-spacing-mode';
-            }
-
-            if (source.lookAhead('[', true)) {
-                if (source.lookAheadRegex(/^\^?]/, true)) {
-                    return config.empty_char_class ? 'regex-empty-class' : 'regex-bad-character';
-                }
-                if (source.equals('^')) {
-                    negatedCharClass = true;
-                }
-                setState(inside_class);
-                return 'regex-class-begin';
-            }
-
-            // Unmatched ending parentheses
-            if (source.lookAhead(')', true)) {
-                return 'regex-ending-group';
-            }
-            if (source.lookAhead('(', true)) {
-                if (config.mode_modifier && mode_modifier_begun) {
-                    var mode_modifier = source.lookAheadRegex(/^\?([imsx]+)\)/, true);
-                    if (mode_modifier) { // We know it should exist if we're here
-                        // addFlags(mode_modifier[1]); // Handle flags earlier
-                        mode_modifier_begun = false;
-                        return 'regex-mode-modifier';
-                    }
-                }
-                if (source.lookAheadRegex(/^\?#[^)]*\)/, true)) { // No apparent nesting of comments?
-                    return 'regex-comment-pattern';
-                }
-
-                var ret;
-                if (source.lookAheadRegex(/^(?!\?)/, true)) {
-                    ret = 'regex-capturing-group';
-                }
-                if (source.lookAheadRegex(/^\?<([$\w]+)>/, true)) {
-                    ret = 'regex-named-capturing-group';
-                }
-                if (source.lookAheadRegex(/^\?[:=!]/, true)) {
-                    ret = 'regex-grouping';
-                }
-                if (!ret) {
-                    return 'regex-bad-character'; // 'Uncaught parenthetical in tokenizing regular expression';
-                }
-                return ret;
-            }
-            return outside_class(source, setState);
-        }
-
-        return function(source, startState) {
-            return noWSTokenizer(source, startState || customOutsideClass);
-        };
-    })();
-
-
-    function resetStateVariables () {
-        initialFound = false, endFound = false, charClassRangeBegun = false, negatedCharClass = false,
-        mode_modifier_begun = false;
-        flags = '';
-        if (config.flags) { // Reset to configuration value
-            _addFlags(config.flags);
-        }
-        groupTypes = [],
-            groupCounts = {
-                'capturing-group': {currentCount: 0},
-                'named-capturing-group': {currentCount: 0},
-                'grouping': {currentCount: 0}
-            };
-    }
-
-    // Parser
-    function parseRegex (source) {
-        resetStateVariables();
-
-        var tokens = tokenizeRegex(source);
-
-        if (config.literal && !source.equals(config.literal_initial)) {
-            throw 'Regular expression literals must include a beginning "'+config.literal_initial+'"';
-        }
-
-        if (config.literal) {
-            var regex = new RegExp('^[\\s\\S]*' + _esc(config.literal_initial) + '([' + possibleFlags + ']*)$', '');
-            var endFlags = source.lookAheadRegex(regex);
-            if (endFlags == null) {
-                 // Unrecognized flag used in regular expression literal
-            }
-            else {
-                _addFlags(endFlags[1]);
-            }
-        }
-        else if (config.mode_modifier) { // Fix: We are not allowing both a mode modifier and
-                                                                      // literal syntax (presumably redundant)
-            var mode_modifier = source.lookAheadRegex(/^\(\?([imsx]+)\)/, true);
-            if (mode_modifier) {
-                mode_modifier_begun = true;
-                _addFlags(mode_modifier[1]);
-            }
-        }
-        var iter = {
-            next: function() {
-                try {
-                    var level_num,
-                        token = tokens.next(),
-                        style = token.style,
-                        content = token.content,
-                        lastChildren, currentChildren, currentCount, currentGroupStyle,
-                        type = style.replace(/^regex-/, '');
-
-                    switch (type) {
-                        case 'ending-group':
-                            if (!groupTypes.length) {
-                                // Closing parenthesis without an opening one
-                                token.style = 'regex-bad-character';
-                            }
-                            else {
-                                level_num = config.max_levels ?
-                                    ((groupTypes.length % config.max_levels) || config.max_levels) : groupTypes.length;
-                                var popped = groupTypes.pop();
-                                // Allow numbered classes
-                                currentChildren = groupCounts[popped];
-                                while (currentChildren && currentChildren.currentChildren &&
-                                                currentChildren.currentChildren.currentChildren) { // Find lowest level parent
-                                    currentChildren = currentChildren.currentChildren;
-                                }
-                                delete currentChildren.currentChildren; // Use parent to delete children
-                                currentCount = currentChildren.currentCount; // Use parent as new child to get current count
-                                currentCount = config.max_alternating ?
-                                    ((currentCount % config.max_alternating) || config.max_alternating) : currentCount;
-
-                                currentGroupStyle = level_num + '-' + currentCount;
-                                token.style = 'regex-ending-' + popped + ' regex-ending-' + popped + currentGroupStyle;
-                                if (config.inner_group_mode === 'uniform') { // 'type' is automatically processed for ending
-                                    token.style += ' regex-group-' + currentGroupStyle;
-                                }
-                            }
-                            break;
-                        case 'capturing-group':
-                        case 'named-capturing-group':
-                        case 'grouping':
-                            lastChildren = groupCounts[type],
-                                    currentChildren = groupCounts[type].currentChildren;
-                            while (currentChildren) {
-                                lastChildren = currentChildren;
-                                currentChildren = currentChildren.currentChildren;
-                            }
-                            currentCount = ++lastChildren.currentCount;
-                            if (!lastChildren.currentChildren) {
-                                lastChildren.currentChildren = {currentCount: 0};
-                            }
-
-                            groupTypes.push(type);
-                            level_num = config.max_levels ?
-                                ((groupTypes.length % config.max_levels) || config.max_levels) : groupTypes.length;
-                            // Allow numbered classes
-                            currentCount = config.max_alternating ?
-                                ((currentCount % config.max_alternating) || config.max_alternating) : currentCount;
-                            currentGroupStyle = level_num + '-' + currentCount;
-                            var currentStyle = ' ' + token.style;
-
-
-                            if (config.inner_group_mode) {
-                                token.style += config.inner_group_mode === 'type' ?
-                                                            currentStyle + currentGroupStyle :
-                                                            ' regex-group-' + currentGroupStyle;
-                                token.style += ' ' + style + currentGroupStyle;
-                            }
-                            else {
-                                token.style += currentStyle + currentGroupStyle;
-                            }
-                            lastChildren.currentGroupStyle = currentGroupStyle;
-                            lastChildren.currentStyle = currentStyle;
-                            break;
-                        // Allow ability to extract information on character equivalence, e.g., for use on tooltips
-                        case 'class-octal': case 'octal': // Fall-through
-                        case 'class-octal-begin-range': case 'class-octal-end-range': // Fall-through
-                        case 'class-ascii-begin-range': case 'class-ascii-end-range': // Fall-through
-                        case 'class-ascii': case 'ascii': // Firefox apparently treats ascii here as octals
-                            token.equivalent = String.fromCharCode(parseInt(content.replace(/^\\/, ''), 8));
-                            break;
-                        case 'class-hex': case 'hex': // Fall-through
-                        case 'class-hex-begin-range': case 'class-hex-end-range': // Fall-through
-                        case 'class-unicode-escape': case 'class-unicode-escape-begin-range':  // Fall-through
-                        case 'class-unicode-escape-end-range': case 'unicode-escape':
-                            token.equivalent = String.fromCharCode(parseInt('0x'+content.replace(/^\\(x|u)/, ''), 16));
-                            break;
-                        case 'class-ascii-control-begin-range': case 'class-ascii-control-end-range': // Fall-through
-                        case 'class-ascii-control': case 'ascii-control':
-                            token.equivalent = String.fromCharCode(content.replace(/^\\c/, '').charCodeAt(0) - 64);
-                            break;
-                        case 'class-special-escape': case 'class-special-escape-begin-range': // Fall-through
-                        case 'class-special-escape-end-range': case 'special-escape':
-                            // Others to ignore (though some (\d, \s, \w) could have theirs listed): bBdDsSwW
-                            var chr = content.replace(/^\\/, ''),
-                                pos = 'fnrtv'.indexOf(chr),
-                                specialEquivs = '\f\n\r\t\v';
-                            if (pos !== -1) { // May not be visible without conversion to codepoints
-                                var c = specialEquivs.charAt(pos);
-                                var hex = c.charCodeAt(0).toString(16).toUpperCase();
-                                token.display = 'U+' + Array(5 - hex.length).join('0') + hex;
-                                token.equivalent = c;
-                            }
-                            break;
-                        case 'regex-class-escaped-special': case 'regex-class-escaped-special-begin-range':
-                        case 'regex-class-escaped-special-end-range':
-                        case 'class-extra-escaped-begin-range': case 'class-extra-escaped-end-range':
-                        case 'class-extra-escaped': case 'extra-escaped':
-                            token.equivalent = content.replace(/^\\/, '');
-                            break;
-                        default:
-                            if (config.unicode_mode === 'store') {
-                                if (config.unicode_categories) {
-                                    var cat = type.match(/regex-unicode-category-(\w+?)-(?:outside|inside)/);
-                                    if (cat) {
-                                        token.equivalent = _expandRange('categories', cat[1]) || '';
-                                        token.unicode = true;
-                                        break;
-                                    }
-                                }
-                                if (config.unicode_blocks) {
-                                    var block = type.match(/regex-unicode-block-(\w+)-(?:outside|inside)/);
-                                    if (block) {
-                                        token.equivalent = _expandRange('blocks', block[1]) || '';
-                                        token.unicode = true;
-                                        break;
-                                    }
-                                }
-                                if (config.unicode_scripts) {
-                                    var script = type.match(/regex-unicode-script-(\w+)-(?:outside|inside)/);
-                                    if (script) {
-                                        token.equivalent = _expandRange('scripts', script[1]) || '';
-                                        token.unicode = true;
-                                        break;
-                                    }
-                                }
-                            }
-                            break;
-                    }
-                    if (config.inner_group_mode && type !== 'ending-group' && type !== 'capturing-group' && type !== 'named-capturing-group' &&
-                            type !== 'grouping') {
-                        level_num = config.max_levels ?
-                            ((groupTypes.length % config.max_levels) || config.max_levels) : groupTypes.length;
-                        // Allow numbered classes
-                        var last = groupTypes[groupTypes.length - 1];
-                        if (last) {
-                            currentChildren = groupCounts[last];
-                            while (currentChildren && currentChildren.currentChildren &&
-                                            currentChildren.currentChildren.currentChildren) { // Find lowest level parent
-                                currentChildren = currentChildren.currentChildren;
-                            }
-                            token.style += config.inner_group_mode === 'type' ? 
-                                                            currentChildren.currentStyle + currentChildren.currentGroupStyle :
-                                                            ' regex-group-' + currentChildren.currentGroupStyle;
-                        }
-                    }
-                    if (!source.more()) {
-                        if (groupTypes.length) { // Opening group without a closing parenthesis
-                            token.style = 'regex-bad-character';
-                        }
-                        else if (config.literal && !endFound) {
-                            //throw 'Regular expression literals must include a (non-escaped) ending "' +
-                            //                config.literal_initial + '" (with optional flags).';
-                            token.style = 'regex-bad-character';
-                        }
-                    }
-                }
-                catch (e) {
-if (e != StopIteration) {
-    alert(e + '::'+e.lineNumber);
-}
-                    throw e;
-                }
-                return token;
-            },
-            copy: function() {
-                var _initialFound = initialFound, _charClassRangeBegun = charClassRangeBegun,
-                    _negatedCharClass = negatedCharClass, _flags = flags,
-                    _endFound = endFound, _groupTypes = groupTypes,
-                    _mode_modifier_begun = mode_modifier_begun,
-                    _tokenState = tokens.state,
-                    _groupCounts = _copyObj(groupCounts, true);
-                return function(source) {
-                    initialFound = _initialFound;
-                    charClassRangeBegun = _charClassRangeBegun;
-                    negatedCharClass = _negatedCharClass;
-                    flags = _flags;
-                    endFound = _endFound;
-                    groupTypes = _groupTypes;
-                    mode_modifier_begun = _mode_modifier_begun;
-                    tokens = tokenizeRegex(source, _tokenState);
-                    groupCounts = _groupCounts;
-                    return iter;
-                };
-            }
-        };
-        return iter;
-    }
-
-    // Parser object
-    return {
-        make: parseRegex,
-        configure: function (parserConfig) {
-            var unicode = this.unicode;
-
-            // Overridable
-            _setOptions('unicode_mode', 'simple');
-            _setOptions(regexConfigBooleanOptions, false);
-            if (parserConfig.unicode_classes) {
-                _setOptions(['unicode_blocks', 'unicode_scripts', 'unicode_categories'], true);
-            }
-            switch (parserConfig.flavor) {
-                case 'ecma-262-ed5':
-                    _setOptions(['empty_char_class'], true);
-                    // Fall-through
-                case 'ecma-262-ed3':
-                    config.possible_flags = 'gim'; // If wish for Firefox 'y', add it on parserConfig
-                    break;
-                case 'all':
-                default:
-                    _setOptions(regexConfigBooleanOptions, true);
-                    break;
-            }
-
-            // Setting with possible overrides
-            for (var opt in parserConfig) {
-                if ((/^regex_/).test(opt)) { // Use for compatibility with JS+Regex
-                    config[opt.replace(/^regex_/, '')] = parserConfig[opt];
-                    continue;
-                }
-                config[opt] = parserConfig[opt];
-            }
-
-            // Post-processing
-            if (config.possible_flags) {
-                _setPossibleFlags(config.possible_flags);
-            }
-
-            if (config.unicode_mode !== 'simple') {
-                if (!unicode) {
-                    throw 'You must include the parseregex-unicode.js file in order to use validate or storage mode Unicode';
-                }
-            }
-        }
-    };
-})();