/**
*
*   Regex
*   @version: 1.2.0
*
*   A simple & generic Regular Expression Analyzer & Composer for PHP, Python, Javascript
*   https://github.com/foo123/RegexAnalyzer
*
**/
export default (function(root, name, factory) {
"use strict";
var __version__ = "1.2.0",

    PROTO = 'prototype', OP = Object[PROTO], AP = Array[PROTO],
    Keys = Object.keys, to_string = OP.toString, HAS = OP.hasOwnProperty,
    fromCharCode = String.fromCharCode,
    fromCodePoint = String.fromCodePoint || String.fromCharCode,
    CHAR = 'charAt', CHARCODE = 'charCodeAt',
    CODEPOINT = String.prototype.codePointAt ? 'codePointAt' : CHARCODE,
    toJSON = JSON.stringify,
    INF = Infinity, ESC = '\\',
    specialChars = {
        "." : "MatchAnyChar",
        "|" : "MatchEither",
        "?" : "MatchZeroOrOne",
        "*" : "MatchZeroOrMore",
        "+" : "MatchOneOrMore",
        "^" : "MatchStart",
        "$" : "MatchEnd",
        "{" : "StartRepeats",
        "}" : "EndRepeats",
        "(" : "StartGroup",
        ")" : "EndGroup",
        "[" : "StartCharGroup",
        "]" : "EndCharGroup"
    },
    /*
        http://www.javascriptkit.com/javatutors/redev2.shtml

        \f matches form-feed.
        \r matches carriage return.
        \n matches linefeed.
        \t matches horizontal tab.
        \v matches vertical tab.
        \0 matches NUL character.
        [\b] matches backspace.
        \s matches whitespace (short for [\f\n\r\t\v\u00A0\u2028\u2029]).
        \S matches anything but a whitespace (short for [^\f\n\r\t\v\u00A0\u2028\u2029]).
        \w matches any alphanumerical character (word characters) including underscore (short for [a-zA-Z0-9_]).
        \W matches any non-word characters (short for [^a-zA-Z0-9_]).
        \d matches any digit (short for [0-9]).
        \D matches any non-digit (short for [^0-9]).
        \b matches a word boundary (the position between a word and a space).
        \B matches a non-word boundary (short for [^\b]).
        \cX matches a control character. E.g: \cm matches control-M.
        \xhh matches the character with two characters of hexadecimal code hh.
        \uhhhh matches the Unicode character with four characters of hexadecimal code hhhh.
    */
    specialCharsEscaped = {
        "\\" : "ESC",
        "/" : "/",
        "0" : "NULChar",
        "f" : "FormFeed",
        "n" : "LineFeed",
        "r" : "CarriageReturn",
        "t" : "HorizontalTab",
        "v" : "VerticalTab",
        "b" : "MatchWordBoundary",
        "B" : "MatchNonWordBoundary",
        "s" : "MatchSpaceChar",
        "S" : "MatchNonSpaceChar",
        "w" : "MatchWordChar",
        "W" : "MatchNonWordChar",
        "d" : "MatchDigitChar",
        "D" : "MatchNonDigitChar"
    },
    T_SEQUENCE = 1,
    T_ALTERNATION = 2,
    T_GROUP = 4,
    T_CHARGROUP = 8,
    T_QUANTIFIER = 16,
    T_UNICODECHAR = 32,
    T_HEXCHAR = 64,
    T_SPECIAL = 128,
    T_CHARS = 256,
    T_CHARRANGE = 512,
    T_STRING = 1024,
    T_COMMENT = 2048
;

function is_array(x)
{
    return (x instanceof Array) || ('[object Array]' === to_string.call(x));
}
function is_string(x)
{
    return (x instanceof String) || ('[object String]' === to_string.call(x));
}
function is_regexp(x)
{
    return (x instanceof RegExp) || ('[object RegExp]' === to_string.call(x));
}
function array(x)
{
    return is_array(x) ? x : [x];
}
function clone(obj, cloned)
{
    cloned = cloned || {};
    for (var p in obj) if (HAS.call(obj,p)) cloned[p] = obj[p];
    return cloned;
}
function RE_OBJ(re, flags, flavor)
{
    var self = this;
    self.re = re;
    self.flags = flags;
    self.flavor = flavor;
    self.len = re.length;
    self.pos = 0;
    self.index = 0;
    self.groupIndex = 0;
    self.group = {};
    self.inGroup = 0;
}
RE_OBJ[PROTO] = {
     constructor: RE_OBJ
    ,re: null
    ,flags: null
    ,flavor: ''
    ,len: null
    ,pos: null
    ,index: null
    ,groupIndex: null
    ,inGroup: null
    ,groups: null
    ,dispose: function() {
        var self = this;
        self.re = null;
        self.flags = null;
        self.flavor = null;
        self.len = null;
        self.pos = null;
        self.index = null;
        self.groupIndex = null;
        self.group = null;
        self.inGroup = null;
    }
};
function Node(type, value, flags)
{
    var self = this;
    if (!(self instanceof Node)) return new Node(type, value, flags);
    self.type = type;
    self.val = value;
    self.flags = flags || {};
    switch (type)
    {
        case T_SEQUENCE:
            self.typeName = "Sequence"; break;
        case T_ALTERNATION:
            self.typeName = "Alternation"; break;
        case T_GROUP:
            self.typeName = "Group"; break;
        case T_CHARGROUP:
            self.typeName = "CharacterGroup"; break;
        case T_CHARS:
            self.typeName = "Characters"; break;
        case T_CHARRANGE:
            self.typeName = "CharacterRange"; break;
        case T_STRING:
            self.typeName = "String"; break;
        case T_QUANTIFIER:
            self.typeName = "Quantifier"; break;
        case T_UNICODECHAR:
            self.typeName = "UnicodeChar"; break;
        case T_HEXCHAR:
            self.typeName = "HexChar"; break;
        case T_SPECIAL:
            self.typeName = "Special"; break;
        case T_COMMENT:
            self.typeName = "Comment"; break;
        default:
            self.typeName = "unspecified"; break;
    }
};
Node.toObjectStatic = function toObject(v) {
    if (v instanceof Node)
    {
        return v.flags && Object.keys(v.flags).length ? {
            type: v.typeName,
            value: toObject(v.val),
            flags: v.flags
        } : {
            type: v.typeName,
            value: toObject(v.val)
        };
    }
    else if (is_array(v))
    {
        return v.map(toObject);
    }
    return v;
};
Node[PROTO] = {
    constructor: Node
    ,type: null
    ,typeName: null
    ,val: null
    ,flags: null
    ,dispose: function() {
        var self = this;
        self.val = null;
        self.flags = null;
        self.type = null;
        self.typeName = null;
        return self;
    }
    ,toObject: function() {
        return Node.toObjectStatic(this);
    }
};

var rnd = function(a, b) {return Math.round((b-a)*Math.random()+a);},
    RE = function(re, fl) {return new RegExp(re, fl||'');},
    slice = function(a) {return AP.slice.apply(a, AP.slice.call(arguments, 1));},
    flatten = function(a) {
        var r = [], i = 0;
        while (i < a.length) r = r.concat(a[i++]);
        return r;
    },
    getArgs = function(args, asArray) {
        /*var a = slice(args);
        if ( asArray && a[0] &&
            ( a[0] instanceof Array || '[object Array]' == to_string.call(a[0]) )
        )
            a = a[0];*/
        return flatten(slice(args)); //a;
    },
    esc_re = function(s, esc, chargroup) {
        var es = '', l = s.length, i=0, c;
        //escaped_re = /([.*+?^${}()|[\]\/\\\-])/g
        if (chargroup)
        {
            while (i < l)
            {
                c = s[CHAR](i++);
                es += (/*('?' === c) || ('*' === c) || ('+' === c) ||*/
                        ('-' === c) || /*('.' === c) ||*/ ('^' === c) || ('$' === c) || ('|' === c) ||
                        ('{' === c) || ('}' === c) || ('(' === c) || (')' === c) ||
                        ('[' === c) || (']' === c) || ('/' === c) || (esc === c) ? esc : '') + c;
            }
        }
        else
        {
            while (i < l)
            {
                c = s[CHAR](i++);
                es += (('?' === c) || ('*' === c) || ('+' === c) ||
                    /*('-' === c) ||*/ ('.' === c) || ('^' === c) || ('$' === c) || ('|' === c) ||
                    ('{' === c) || ('}' === c) || ('(' === c) || (')' === c) ||
                    ('[' === c) || (']' === c) || ('/' === c) || (esc === c) ? esc : '') + c;
            }
        }
        return es;
    },
    pad = function(s, n, z) {
        var ps = String(s);
        z = z || '0';
        while (ps.length < n) ps = z + ps;
        return ps;
    },
    char_code = function(c) {return c[CODEPOINT](0);},
    char_code_range = function(s) {return [s[CODEPOINT](0), s[CODEPOINT](s.length-1)];},
    //char_codes = function( s_or_a ) { return (s_or_a.substr ? s_or_a.split("") : s_or_a).map( char_code ); },
    // http://stackoverflow.com/questions/12376870/create-an-array-of-characters-from-specified-range
    character_range = function(first, last) {
        if (first && is_array(first)) {last = first[1]; first = first[0];}
        var ch, chars, start = first[CODEPOINT](0), end = last[CODEPOINT](0);

        if (end === start) return [fromCodePoint(start)];

        chars = [];
        for (ch = start; ch <= end; ++ch) chars.push(fromCodePoint(ch));
        return chars;
    },
    concat = function(p1, p2) {
        if (p2)
        {
            var p, l;
            if (is_array(p2))
            {
                for (p=0,l=p2.length; p<l; ++p) p1[p2[p]] = 1;
            }
            else
            {
                for (p in p2) if (HAS.call(p2, p)) p1[p] = 1;
            }
        }
        return p1;
    },

    BSPACES = "\r\n", SPACES = " \t\v", PUNCTS = "~!@#$%^&*()-+=[]{}\\|;:,./<>?",
    DIGITS = "0123456789", DIGITS_RANGE = char_code_range(DIGITS),
    HEXDIGITS_RANGES = [DIGITS_RANGE, [char_code("a"), char_code("f")], [char_code("A"), char_code("F")]],
    ALPHAS = "_"+(character_range("a", "z").join(""))+(character_range("A", "Z").join("")),
    ALL = SPACES+PUNCTS+DIGITS+ALPHAS, ALL_ARY = ALL.split(""),

    match_chars = function(CHARS, s, pos, minlen, maxlen) {
        pos = pos || 0;
        minlen = minlen || 1;
        maxlen = maxlen || INF;
        var lp = pos, l = 0, sl = s.length, ch;
        while ((lp < sl) && (l <= maxlen) && -1 < CHARS.indexOf(ch=s[CHAR](lp)))
        {
            ++lp; ++l;
        }
        return l >= minlen ? l : false;
    },
    match_char_range = function(RANGE, s, pos, minlen, maxlen) {
        pos = pos || 0;
        minlen = minlen || 1;
        maxlen = maxlen || INF;
        var lp = pos, l = 0, sl = s.length, ch;
        while ((lp < sl) && (l <= maxlen) && ((ch=s[CHARCODE](lp)) >= RANGE[0] && ch <= RANGE[1]))
        {
            ++lp; ++l;
        }
        return l >= minlen ? l : false;
    },
    match_char_ranges = function(RANGES, s, pos, minlen, maxlen) {
        pos = pos || 0;
        minlen = minlen || 1;
        maxlen = maxlen || INF;
        var lp = pos, l = 0, sl = s.length, ch,
            i, Rl = RANGES.length, RANGE, found = true;
        while ((lp < sl) && (l <= maxlen) && found)
        {
            ch = s[CHARCODE](lp); found = false;
            for (i=0; i<Rl; ++i)
            {
                RANGE = RANGES[i];
                if (ch >= RANGE[0] && ch <= RANGE[1])
                {
                    ++lp; ++l; found = true;
                    break;
                }
            }
        }
        return l >= minlen ? l : false;
    },

    punct = function() {
        return PUNCTS[CHAR](rnd(0, PUNCTS.length-1));
    },
    space = function(positive) {
        return false !== positive
            ? SPACES[CHAR](rnd(0, SPACES.length-1))
            : (punct()+digit()+alpha())[CHAR](rnd(0, 2))
        ;
    },
    digit = function(positive) {
        return false !== positive
            ? DIGITS[CHAR](rnd(0, DIGITS.length-1))
            : (punct()+space()+alpha())[CHAR](rnd(0, 2))
        ;
    },
    alpha = function(positive) {
        return false !== positive
            ? ALPHAS[CHAR](rnd(0, ALPHAS.length-1))
            : (punct()+space()+digit())[CHAR](rnd(0, 2))
        ;
    },
    word = function(positive) {
        return false !== positive
            ? (ALPHAS+DIGITS)[CHAR](rnd(0, ALPHAS.length+DIGITS.length-1))
            : (punct()+space())[CHAR](rnd(0, 1))
        ;
    },
    any = function() {
        return ALL[CHAR](rnd(0, ALL.length-1));
    },
    character = function(chars, positive) {
        if (false !== positive) return chars.length ? chars[rnd(0, chars.length-1)] : '';
        var choices = ALL_ARY.filter(function(c) {return 0 > chars.indexOf(c);});
        return choices.length ? choices[rnd(0, choices.length-1)] : '';
    },
    random_upper_or_lower = function(c) {return 0.5 < Math.random() ? c.toLowerCase() : c.toUpperCase();},
    case_insensitive = function(chars, asArray) {
        if (asArray)
        {
            if (chars[CHAR]) chars = chars.split('');
            chars = chars.map(random_upper_or_lower);
            //if ( !asArray ) chars = chars.join('');
            return chars;
        }
        else
        {
            return random_upper_or_lower(chars);
        }
    },

    walk = function walk(ret, node, state) {
        if ((null == node) || !state) return ret;

        var i, l, r, type = node instanceof Node ? node.type : null;

        // walk the tree
        if (null === type)
        {
            // custom, let reduce handle it
            ret = state.reduce(ret, node, state);
        }

        else if (state.IGNORE & type)
        {
            /* nothing */
        }

        else if (state.MAP & type)
        {
            r = state.map(ret, node, state);
            if (null != state.ret)
            {
                ret = state.reduce(ret, node, state);
                state.ret = null;
            }
            else if (null != r)
            {
                r = array(r);
                for (i=0,l=r?r.length:0; i<l; ++i)
                {
                    state.node = node;
                    ret = walk(ret, r[i], state);
                    if (state.stop)
                    {
                        state.stop = null;
                        return ret;
                    }
                }
            }
        }

        else if (state.REDUCE & type)
        {
            ret = state.reduce(ret, node, state);
        }

        state.node = null;
        return ret;
    },
    /*map_all = function map_all( ret, node, state ) {
        return node.val;
    },*/
    map_src = function map_src(ret, node, state) {
        var type = node.type;
        if (T_ALTERNATION === type)
        {
            var r = [];
            for (var i=0,l=node.val.length-1; i<l; ++i) r.push(node.val[i], '|');
            r.push(node.val[l]);
            return r;
        }
        else if (T_CHARGROUP === type)
        {
            return [].concat('['+(node.flags.NegativeMatch?'^':'')).concat(array(node.val)).concat(']');
        }
        else if (T_QUANTIFIER === type)
        {
            var q = '';
            if (node.flags.MatchZeroOrOne) q = '?';
            else if (node.flags.MatchZeroOrMore) q = '*';
            else if (node.flags.MatchOneOrMore) q = '+';
            else q = node.flags.min === node.flags.max ? ('{'+node.flags.min+'}') : ('{'+node.flags.min+','+(-1===node.flags.max?'':node.flags.max)+'}');
            if ((node.flags.min !== node.flags.max) && !node.flags.isGreedy) q += '?';
            return [].concat(array(node.val)).concat(q);
        }
        else if (T_GROUP === type)
        {
            var g = null;
            if (node.flags.NotCaptured)
            {
                g = [].concat('(?:').concat(array(node.val)).concat(')');
            }
            else if (node.flags.LookAhead)
            {
                g = [].concat('(?=').concat(array(node.val)).concat(')');
            }
            else if (node.flags.NegativeLookAhead)
            {
                g = [].concat('(?!').concat(array(node.val)).concat(')');
            }
            else if (node.flags.LookBehind)
            {
                g = [].concat('(?<=').concat(array(node.val)).concat(')');
            }
            else if (node.flags.NegativeLookBehind)
            {
                g = [].concat('(?<!').concat(array(node.val)).concat(')');
            }
            else if (node.flags.NamedGroup && !state.compatibility)
            {
                g = [].concat('(?<'+node.flags.GroupName+'>').concat(array(node.val)).concat(')');
            }
            else
            {
                g = [].concat('(').concat(array(node.val)).concat(')');
            }
            if (null != node.flags.GroupIndex)
            {
                ret.group[node.flags.GroupIndex] = node.flags.GroupIndex;
                if (node.flags.GroupName) ret.group[node.flags.GroupName] = node.flags.GroupIndex;
            }
            return g;
        }
        return node.val;
    },
    map_any = function map_any(ret, node, state) {
        var type = node.type;
        if ((T_ALTERNATION === type) || (T_CHARGROUP === type))
        {
            return node.val.length ? node.val[rnd(0, node.val.length-1)] : null;
        }
        else if (T_QUANTIFIER === type)
        {
            var numrepeats, mmin, mmax, repeats;
            if (ret.length >= state.maxLength)
            {
                numrepeats = node.flags.min;
            }
            else
            {
                mmin = node.flags.min;
                mmax = -1 === node.flags.max ? (mmin+1+2*state.maxLength) : node.flags.max;
                numrepeats = rnd(mmin, mmax);
            }
            if (numrepeats)
            {
                repeats = new Array(numrepeats);
                for (var i=0; i<numrepeats; ++i) repeats[i] = node.val;
                return repeats;
            }
            else
            {
                return null;
            }
        }
        else if ((T_GROUP === type) && node.flags.GroupIndex)
        {
            var sample = walk('', node.val, state);
            state.group[node.flags.GroupIndex] = sample;
            state.ret = sample;
            return null;
        }
        else
        {
            return node.val;
        }
    },
    map_min = function map_min(ret, node, state) {
        var type = node.type;
        if (T_ALTERNATION === type)
        {
            var i, l = node.val.length, cur,
                min = l ? walk(0, node.val[0], state) : 0;
            for (i=1; i<l; ++i)
            {
                cur = walk(0, node.val[i], state);
                if (cur < min) min = cur;
            }
            if (l) state.ret = min;
            return null;
        }
        else if (T_CHARGROUP === type)
        {
            return node.val.length ? node.val[0] : null;
        }
        else if (T_QUANTIFIER === type)
        {
            if (0 === node.flags.min) return null;
            var i, nrepeats = node.flags.min, repeats = new Array(nrepeats);
            for (i=0; i<nrepeats; ++i) repeats[i] = node.val;
            return repeats;
        }
        else if ((T_GROUP === type) && node.flags.GroupIndex)
        {
            var min = walk(0, node.val, state);
            state.group[node.flags.GroupIndex] = min;
            state.ret = min;
            return null;
        }
        else
        {
            return node.val;
        }
    },
    map_max = function map_max(ret, node, state) {
        var type = node.type;
        if (T_ALTERNATION === type)
        {
            var i, l = node.val.length, cur, max = l ? walk(0, node.val[0], state) : 0;
            if (-1 !== max)
            {
                for (i=1; i<l; ++i)
                {
                    cur = walk(0, node.val[i], state);
                    if (-1 === cur)
                    {
                        max = -1;
                        break;
                    }
                    else if (cur > max)
                    {
                        max = cur;
                    }
                }
            }
            if (l) state.ret = max;
            return null;
        }
        else if (T_CHARGROUP === type)
        {
            return node.val.length ? node.val[0] : null;
        }
        else if (T_QUANTIFIER === type)
        {
            max = walk(0, node.val, state);
            if (-1 === max)
            {
                state.ret = -1;
            }
            else if (0 < max)
            {
                if (-1 === node.flags.max)
                {
                    state.ret = -1;
                }
                else if (0 < node.flags.max)
                {
                    state.ret = node.flags.max*max;
                }
                else
                {
                    state.ret = max;
                }
            }
            return null;
        }
        else if ((T_GROUP === type) && node.flags.GroupIndex)
        {
            var max = walk(0, node.val, state);
            state.group[node.flags.GroupIndex] = max;
            state.ret = max;
            return null;
        }
        else
        {
            return node.val;
        }
    },
    map_1st = function map_1st(ret, node, state) {
        var type = node.type;
        if (T_SEQUENCE === type)
        {
            var seq=[], i=0, l=node.val.length, n;
            for (i=0; i<l; ++i)
            {
                n = node.val[i];
                seq.push( n );
                if ((T_QUANTIFIER === n.type) && (0 === n.flags.min))
                    continue;
                else if ((T_SPECIAL === n.type) && (n.flags.MatchStart || n.flags.MatchEnd))
                    continue;
                break;
            }
            return seq.length ? seq : null;
        }
        else
        {
            return node.val;
        }
    },
    reduce_len = function reduce_len(ret, node, state) {
        if (null != state.ret)
        {
            if (-1 === state.ret) ret = -1;
            else ret += state.ret;
            return ret;
        }
        if (-1 === ret) return ret;

        if (node === +node)
        {
            ret += node;
            return ret;
        }

        if ((T_SPECIAL === node.type) && node.flags.MatchEnd)
        {
            state.stop = 1;
            return ret;
        }
        var type = node.type;

        if (
            (T_CHARS === type) || (T_CHARRANGE === type) ||
            (T_UNICODECHAR === type) || (T_HEXCHAR === type) ||
            ((T_SPECIAL === type) && !node.flags.MatchStart && !node.flags.MatchEnd)
        )
        {
            ret += node.flags.BackReference ? state.group[node.flags.GroupIndex]||0 : 1;
        }
        else if (T_STRING === type)
        {
            ret += node.val.length;
        }

        return ret;
    },
    reduce_str = function reduce_str(ret, node, state) {
        if (null != state.ret)
        {
            ret += state.ret;
            return ret;
        }

        if (is_string(node))
        {
            ret += node;
            return ret;
        }

        if ((T_SPECIAL === node.type) && node.flags.MatchEnd)
        {
            state.stop = 1;
            return ret;
        }
        var type = node.type, sample = null;

        if (T_CHARS === type)
        {
            sample = node.val;
        }
        else if (T_CHARRANGE === type)
        {
            var range = [node.val[0], node.val[1]];
            if (T_UNICODECHAR === range[0].type || T_HEXCHAR === range[0].type) range[0] = range[0].flags.Char;
            if (T_UNICODECHAR === range[1].type || T_HEXCHAR === range[1].type) range[1] = range[1].flags.Char;
            sample = character_range(range);
        }
        else if ((T_UNICODECHAR === type) || (T_HEXCHAR === type))
        {
            sample = [node.flags.Char];
        }
        else if ((T_SPECIAL === type) && !node.flags.MatchStart && !node.flags.MatchEnd)
        {
            var part = node.val;
            if (node.flags.BackReference)
            {
                part = node.flags.GroupIndex;
                ret += HAS.call(state.group, part) ? state.group[part] : '';
                return ret;
            }
            else if ('D' === part)
            {
                sample = [digit(false)];
            }
            else if ('W' === part)
            {
                sample = [word(false)];
            }
            else if ('S' === part)
            {
                sample = [space(false)];
            }
            else if ('d' === part)
            {
                sample = [digit()];
            }
            else if ('w' === part)
            {
                sample = [word()];
            }
            else if ('s' === part)
            {
                sample = [space()];
            }
            else if (('.' === part) && node.flags.MatchAnyChar)
            {
                sample = [any()];
            }
            else
            {
                sample = [ESC + part];
            }
        }
        else if (T_STRING === type)
        {
            sample = node.val;
        }

        if (sample)
        {
            ret += T_STRING === type ?
            (state.isCaseInsensitive ? case_insensitive(sample) : sample) :
            (character(state.isCaseInsensitive ? case_insensitive(sample, true) : sample, !state.node || !state.node.flags.NegativeMatch))
            ;
        }

        return ret;
    },
    reduce_src = function reduce_src(ret, node, state) {
        if (null != state.ret)
        {
            if (state.ret.src) ret.src += state.ret.src;
            if (state.ret.group) ret.group = clone(state.ret.group, ret.group);
            return ret;
        }

        if (is_string(node))
        {
            ret.src += node;
            return ret;
        }

        var type = node.type;
        if (T_CHARS === type)
        {
            ret.src += state.escaped ? esc_re(node.val.join(''), ESC, 1) : node.val.join('');
        }
        else if (T_CHARRANGE === type)
        {
            var range = [node.val[0], node.val[1]];
            if (state.escaped)
            {
                if (T_UNICODECHAR === range[0].type) range[0] = range[0].flags.UnicodePoint ? ESC+'u{'+range[0].flags.Code+'}' : ESC+'u'+pad(range[0].flags.Code,4);
                else if (T_HEXCHAR === range[0].type) range[0] = ESC+'x'+pad(range[0].flags.Code,2);
                else range[0] = esc_re(range[0], ESC, 1);
                if (T_UNICODECHAR === range[1].type) range[1] = range[1].flags.UnicodePoint ? ESC+'u{'+range[1].flags.Code+'}' : ESC+'u'+pad(range[1].flags.Code,4);
                else if (T_HEXCHAR === range[1].type) range[1] = ESC+'x'+pad(range[1].flags.Code,2);
                else range[1] = esc_re(range[1], ESC, 1);
            }
            else
            {
                if (T_UNICODECHAR === range[0].type || T_HEXCHAR === range[0].type) range[0] = range[0].flags.Char;
                if (T_UNICODECHAR === range[1].type || T_HEXCHAR === range[1].type) range[1] = range[1].flags.Char;
            }
            ret.src += range[0]+'-'+range[1];
        }
        else if (T_UNICODECHAR === type)
        {
            ret.src += node.flags.UnicodePoint ? ESC+'u{'+node.flags.Code+'}' : (state.escaped ? ESC+'u'+pad(node.flags.Code,4) : node.flags.Char);
        }
        else if (T_HEXCHAR === type)
        {
            ret.src += state.escaped ? ESC+'x'+pad(node.flags.Code,2) : node.flags.Char;
        }
        else if (T_SPECIAL === type)
        {
            if (node.flags.BackReference)
            {
                if (state.compatibility || (node.flags.GroupIndex === node.flags.GroupName))
                {
                    ret.src += ESC+node.flags.GroupIndex;
                }
                else
                {
                    ret.src += ESC+'k<'+node.flags.GroupName+'>';
                }
            }
            else
            {
                ret.src += node.flags.MatchAnyChar || node.flags.MatchStart || node.flags.MatchEnd ? (''+node.val) : (ESC+node.val);
            }
        }
        else if (T_STRING === type)
        {
            ret.src += state.escaped ? esc_re(node.val, ESC) : node.val;
        }

        return ret;
    },
    reduce_peek = function reduce_peek(ret, node, state) {
        if (null != state.ret)
        {
            ret.positive = concat(ret.positive, state.ret.positive);
            ret.negative = concat(ret.negative, state.ret.negative);
            return ret;
        }
        if ((T_SPECIAL === node.type) && node.flags.MatchEnd)
        {
            state.stop = 1;
            return ret;
        }

        var type = node.type, inCharGroup = state.node && (T_CHARGROUP === state.node.type),
            inNegativeCharGroup = inCharGroup && state.node.flags.NegativeMatch,
            peek = inNegativeCharGroup ? "negative" : "positive";

        if (T_CHARS === type)
        {
            ret[peek] = concat(ret[peek], node.val);
        }
        else if (T_CHARRANGE === type)
        {
            var range = [node.val[0],node.val[1]];
            if (T_UNICODECHAR === range[0].type || T_HEXCHAR === range[0].type) range[0] = range[0].flags.Char;
            if (T_UNICODECHAR === range[1].type || T_HEXCHAR === range[1].type) range[1] = range[1].flags.Char;
            ret[peek] = concat(ret[peek], character_range(range));
        }
        else if ((T_UNICODECHAR === type) || (T_HEXCHAR === type))
        {
            ret[peek][node.flags.Char] = 1;
        }
        else if ((T_SPECIAL === type) && !node.flags.BackReference && !node.flags.MatchStart && !node.flags.MatchEnd)
        {
            var part = node.val;
            if ('D' === part)
            {
                ret[inNegativeCharGroup?"positive":"negative"][ '\\d' ] = 1;
            }
            else if ('W' === part)
            {
                ret[inNegativeCharGroup?"positive":"negative"][ '\\w' ] = 1;
            }
            else if ('S' === part)
            {
                ret[inNegativeCharGroup?"positive":"negative"][ '\\s' ] = 1;
            }
            else if ('B' === part)
            {
                ret[inNegativeCharGroup?"positive":"negative"][ '\\b' ] = 1;
            }
            else
            {
                ret[peek][ESC + part] = 1;
            }
        }
        else if (T_STRING === type)
        {
            ret["positive"][node.val[CHAR](0)] = 1;
        }

        return ret;
    },

    match_hex = function(s) {
        var m = false;
        if ((s.length > 2) && ('x' === s[CHAR](0)))
        {
            if (match_char_ranges(HEXDIGITS_RANGES, s, 1, 2, 2)) return [m=s.slice(0,3), m.slice(1)];
        }
        return false;
    },
    match_unicode = function(s, flags) {
        var m = false, l;
        if ((s.length > 3) && ('u' === s[CHAR](0)))
        {
            if (flags.u && '{' === s[CHAR](1) && (l=match_char_ranges(HEXDIGITS_RANGES, s, 2, 1, 6)) && '}' === s[CHAR](l+2))
            {
                return [m=s.slice(0,l+3), m.slice(2, -1), 1];
            }
            else if (l=match_char_ranges(HEXDIGITS_RANGES, s, 1, 4, 4))
            {
                return [m=s.slice(0,l+1), m.slice(1), 0];
            }
        }
        return false;
    },
    match_repeats = function(s) {
        var l, sl = s.length, pos = 0, m = false, hasComma = false;
        if ((sl > 2) && ('{' === s[CHAR](pos)))
        {
            m = ['', '', null];
            ++pos;
            if (l=match_chars(SPACES, s, pos)) pos += l;
            if (l=match_char_range(DIGITS_RANGE, s, pos))
            {
                m[1] = s.slice(pos, pos+l);
                pos += l;
            }
            else
            {
                return false;
            }
            if (l=match_chars(SPACES, s, pos)) pos += l;
            if ((pos < sl) && (',' === s[CHAR](pos))) {pos += 1; hasComma = true;}
            if (l=match_chars(SPACES, s, pos)) pos += l;
            if (l=match_char_range(DIGITS_RANGE, s, pos))
            {
                m[2] = s.slice(pos, pos+l);
                pos += l;
            }
            if (l=match_chars(SPACES, s, pos)) pos += l;
            if ((pos < sl) && ('}' === s[CHAR](pos)))
            {
                pos++;
                m[0] = s.slice(0, pos);
                if (!hasComma) m[2] = m[1];
                return m;
            }
            else
            {
                return false;
            }
        }
        return false;
    },
    chargroup = function chargroup(re_obj) {
        var sequence = [], chars = [], allchars = [], flags = {}, flag, ch, lre,
        prevch = null, range, isRange = false, m, isUnicode, isHex, isSpecial, escaped = false;

        if ('^' === re_obj.re[CHAR](re_obj.pos))
        {
            flags["NegativeMatch"] = 1;
            ++re_obj.pos;
        }

        lre = re_obj.len;
        while (re_obj.pos < lre)
        {
            isUnicode = false;
            isHex = false;
            isSpecial = false;
            m = null;
            prevch = ch;
            ch = re_obj.re[CHAR](re_obj.pos++);

            escaped = ESC === ch;
            if (escaped) ch = re_obj.re[CHAR](re_obj.pos++);

            if (escaped)
            {
                // unicode character
                if ('u' === ch)
                {
                    m = match_unicode(re_obj.re.substr(re_obj.pos-1), re_obj.flags);
                    if (m)
                    {
                        re_obj.pos += m[0].length-1;
                        ch = Node(T_UNICODECHAR, m[0], {"Char": m[2] ? fromCodePoint(parseInt(m[1], 16)) : fromCharCode(parseInt(m[1], 16)), "Code": m[1], "UnicodePoint": !!m[2]});
                        isUnicode = true; isHex = false;
                    }
                }

                // hex character
                else if ('x' === ch)
                {
                    m = match_hex(re_obj.re.substr(re_obj.pos-1));
                    if (m)
                    {
                        re_obj.pos += m[0].length-1;
                        ch = Node(T_HEXCHAR, m[0], {"Char": fromCharCode(parseInt(m[1], 16)), "Code": m[1]});
                        isUnicode = true; isHex = true;
                    }
                }

                // special character
                else if (HAS.call(specialCharsEscaped, ch) && ('/' !== ch))
                {
                    isSpecial = true;
                    flag = {};
                    flag[specialCharsEscaped[ch]] = 1;
                    ch = Node(T_SPECIAL, ch, flag);
                }
            }

            if (isRange)
            {
                if (
                    (ch instanceof Node) &&
                    (ch.type === T_SPECIAL) &&
                    (-1 !== ['s','S','d','D','w','W'].indexOf(ch.val))
                )
                {
                    if (range[0] instanceof Node)
                    {
                        sequence.push(range[0]);
                    }
                    else
                    {
                        chars.push(range[0]);
                    }
                    chars.push('-');
                    sequence.push(ch);
                }
                else
                {
                    if (chars.length)
                    {
                        allchars = allchars.concat(chars);
                        chars = [];
                    }
                    range[1] = ch;
                    sequence.push(Node(T_CHARRANGE, range));
                }
                isRange = false;
            }
            else
            {
                if (escaped)
                {
                    if (isUnicode)
                    {
                        if (chars.length)
                        {
                            allchars = allchars.concat(chars);
                            chars = [];
                        }
                        sequence.push(ch);
                    }

                    else if (isSpecial)
                    {
                        if (chars.length)
                        {
                            allchars = allchars.concat(chars);
                            chars = [];
                        }
                        sequence.push(ch);
                    }

                    else
                    {
                        chars.push(ch);
                    }
                }

                else
                {
                    // end of char group
                    if (']' === ch)
                    {
                        if (chars.length)
                        {
                            allchars = allchars.concat(chars);
                            chars = [];
                        }
                        // map all chars into one node
                        if (allchars.length) sequence.push(Node(T_CHARS, allchars));
                        return Node(T_CHARGROUP, sequence, flags);
                    }

                    else if ('-' === ch)
                    {
                        if (
                            null == prevch ||
                            ']' === re_obj.re[CHAR](re_obj.pos) ||
                            (
                            (prevch instanceof Node) &&
                            (prevch.type === T_SPECIAL) &&
                            (-1 !== ['s','S','d','D','w','W'].indexOf(prevch.val))
                            )
                        )
                        {
                            // take it as literal
                            // https://github.com/foo123/RegexAnalyzer/issues/5
                            chars.push(ch);
                        }
                        else
                        {
                            range = [prevch, ''];
                            if (prevch instanceof Node) sequence.pop(); else chars.pop();
                            isRange = true;
                        }
                    }

                    else
                    {
                        chars.push(ch);
                    }
                }
            }
        }
        if (chars.length)
        {
            allchars = allchars.concat(chars);
            chars = [];
        }
        // map all chars into one node
        if (allchars.length) sequence.push(Node(T_CHARS, allchars));
        return Node(T_CHARGROUP, sequence, flags);
    },

    analyze_re = function analyze_re(re_obj) {
        var lre, ch, m, word = '', wordlen = 0,
            alternation = [], sequence = [], flags = {},
            flag, escaped = false, pre, pre3, captured;

        if (re_obj.inGroup > 0)
        {
            pre = re_obj.re.substr(re_obj.pos, 2);
            pre3 = re_obj.re.substr(re_obj.pos, 3);
            captured = 1;

            if ("?P=" === pre3)
            {
                flags["BackReference"] = 1;
                flags["GroupName"] = '';
                re_obj.pos += 3;
                lre = re_obj.len;
                while (re_obj.pos < lre)
                {
                    ch = re_obj.re[CHAR](re_obj.pos++);
                    if (")" === ch) break;
                    flags["GroupName"] += ch;
                }
                flags["GroupIndex"] = HAS.call(re_obj.group, flags["GroupName"]) ? re_obj.group[flags["GroupName"]] : null;
                return Node(T_SPECIAL, flags["GroupName"], flags);
            }

            else if ("?#" === pre)
            {
                flags["Comment"] = 1;
                re_obj.pos += 2;
                word = '';
                lre = re_obj.len;
                while (re_obj.pos < lre)
                {
                    ch = re_obj.re[CHAR](re_obj.pos++);
                    if (")" === ch) break;
                    word += ch;
                }
                return Node(T_COMMENT, word);
            }

            else if ("?:" === pre)
            {
                flags["NotCaptured"] = 1;
                re_obj.pos += 2;
                captured = 0;
            }

            else if ("?=" === pre)
            {
                flags["LookAhead"] = 1;
                re_obj.pos += 2;
                captured = 0;
            }

            else if ("?!" === pre)
            {
                flags["NegativeLookAhead"] = 1;
                re_obj.pos += 2;
                captured = 0;
            }

            else if ("?<=" === pre3)
            {
                flags["LookBehind"] = 1;
                re_obj.pos += 3;
                captured = 0;
            }

            else if ("?<!" === pre3)
            {
                flags["NegativeLookBehind"] = 1;
                re_obj.pos += 3;
                captured = 0;
            }

            else if (("?<" === pre) || ("?P<" === pre3))
            {
                // https://github.com/foo123/RegexAnalyzer/issues/6
                flags["NamedGroup"] = 1;
                flags["GroupName"] = '';
                re_obj.pos += "?<" === pre ? 2 : 3;
                lre = re_obj.len;
                while (re_obj.pos < lre)
                {
                    ch = re_obj.re[CHAR](re_obj.pos++);
                    if (">" === ch) break;
                    flags["GroupName"] += ch;
                }
            }

            ++re_obj.index;
            if (captured)
            {
                ++re_obj.groupIndex;
                flags["GroupIndex"] = re_obj.groupIndex;
                re_obj.group[flags["GroupIndex"]] = flags["GroupIndex"];
                if (flags["GroupName"]) re_obj.group[flags["GroupName"]] = flags["GroupIndex"];
            }
        }

        lre = re_obj.len;
        while (re_obj.pos < lre)
        {
            ch = re_obj.re[CHAR](re_obj.pos++);

            //   \\abc
            escaped = ESC === ch;
            if (escaped) ch = re_obj.re[CHAR](re_obj.pos++);

            if (escaped)
            {
                // unicode character
                if ('u' === ch)
                {
                    m = match_unicode(re_obj.re.substr(re_obj.pos-1), re_obj.flags);
                    if (m)
                    {
                        if (wordlen)
                        {
                            sequence.push(Node(T_STRING, word));
                            word = '';
                            wordlen = 0;
                        }
                        re_obj.pos += m[0].length-1;
                        sequence.push(Node(T_UNICODECHAR, m[0], {"Char": m[2] ? fromCodePoint(parseInt(m[1], 16)) : fromCharCode(parseInt(m[1], 16)), "Code": m[1], "UnicodePoint": !!m[2]}));
                    }
                    else
                    {
                        word += ch;
                        wordlen += 1;
                    }
                }

                // hex character
                else if ('x' === ch)
                {
                    m = match_hex(re_obj.re.substr(re_obj.pos-1));
                    if (m)
                    {
                        if (wordlen)
                        {
                            sequence.push(Node(T_STRING, word));
                            word = '';
                            wordlen = 0;
                        }
                        re_obj.pos += m[0].length-1;
                        sequence.push(Node(T_HEXCHAR, m[0], {"Char": fromCharCode(parseInt(m[1], 16)), "Code": m[1]}));
                    }
                    else
                    {
                        word += ch;
                        wordlen += 1;
                    }
                }

                // js back-reference
                else if ('k' === ch && '<' === re_obj.re[CHAR](re_obj.pos))
                {
                    // https://github.com/foo123/RegexAnalyzer/issues/6
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    re_obj.pos++;
                    word = '';
                    while (re_obj.pos < lre)
                    {
                        ch = re_obj.re[CHAR](re_obj.pos);
                        if ('>' === ch) {re_obj.pos++; break;}
                        else {word += ch; re_obj.pos++;}
                    }
                    flag = {};
                    flag["BackReference"] = 1;
                    flag["GroupName"] = word;
                    flag["GroupIndex"] = HAS.call(re_obj.group, word) ? re_obj.group[word] : null;
                    sequence.push(Node(T_SPECIAL, word, flag));
                    word = '';
                }

                else if (HAS.call(specialCharsEscaped, ch) && ('/' !== ch))
                {
                    if (wordlen)
                    {
                        sequence.push( Node(T_STRING, word) );
                        word = '';
                        wordlen = 0;
                    }
                    flag = {};
                    flag[ specialCharsEscaped[ch] ] = 1;
                    sequence.push( Node(T_SPECIAL, ch, flag) );
                }

                else if (('1' <= ch) && ('9' >= ch))
                {
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    word = ch;
                    while (re_obj.pos < lre)
                    {
                        ch = re_obj.re[CHAR](re_obj.pos);
                        if (('0' <= ch) && ('9' >= ch)) {word += ch; re_obj.pos++;}
                        else break;
                    }
                    flag = {};
                    flag['BackReference'] = 1;
                    flag['GroupName'] = word;
                    flag['GroupIndex'] = parseInt(word, 10);
                    sequence.push(Node(T_SPECIAL, word, flag));
                    word = '';
                }

                else
                {
                    word += ch;
                    wordlen += 1;
                }
            }

            else
            {
                // group end
                if ((re_obj.inGroup > 0) && (')' === ch))
                {
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    if (alternation.length)
                    {
                        alternation.push(Node(T_SEQUENCE, sequence));
                        sequence = [];
                        flag = {};
                        flag[specialChars['|']] = 1;
                        return Node(T_GROUP, Node(T_ALTERNATION, alternation, flag), flags);
                    }
                    else
                    {
                        return Node(T_GROUP, Node(T_SEQUENCE, sequence), flags);
                    }
                }

                // parse alternation
                else if ('|' === ch)
                {
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    alternation.push(Node(T_SEQUENCE, sequence));
                    sequence = [];
                }

                // parse character group
                else if ('[' === ch)
                {
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    sequence.push(chargroup(re_obj));
                }

                // parse sub-group
                else if ('(' === ch)
                {
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    re_obj.inGroup += 1;
                    sequence.push(analyze_re(re_obj));
                    re_obj.inGroup -= 1;
                }

                // parse num repeats
                else if ('{' === ch)
                {
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    m = match_repeats(re_obj.re.substr(re_obj.pos-1));
                    re_obj.pos += m[0].length-1;
                    flag = {val: m[0], "MatchMinimum": m[1], "MatchMaximum": m[2] || "unlimited", "min": parseInt(m[1],10), "max": m[2] ? parseInt(m[2],10) : -1};
                    flag[specialChars[ch]] = 1;
                    if ((re_obj.pos < lre) && ('?' === re_obj.re[CHAR](re_obj.pos)))
                    {
                        flag["isGreedy"] = 0;
                        re_obj.pos++;
                    }
                    else
                    {
                        flag["isGreedy"] = 1;
                    }
                    var prev = sequence.pop();
                    if ((T_STRING === prev.type) && (prev.val.length > 1))
                    {
                        sequence.push(Node(T_STRING, prev.val.slice(0, -1)));
                        prev.val = prev.val.slice(-1);
                    }
                    sequence.push(Node(T_QUANTIFIER, prev, flag));
                }

                // quantifiers
                else if (('*' === ch) || ('+' === ch) || ('?' === ch))
                {
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    flag = {};
                    flag[specialChars[ch]] = 1;
                    flag["min"] = '+' === ch ? 1 : 0;
                    flag["max"] = '?' === ch ? 1 : -1;
                    if ((re_obj.pos < lre) && ('?' === re_obj.re[CHAR](re_obj.pos)))
                    {
                        flag["isGreedy"] = 0;
                        re_obj.pos++;
                    }
                    else
                    {
                        flag["isGreedy"] = 1;
                    }
                    var prev = sequence.pop();
                    if ((T_STRING === prev.type) && (prev.val.length > 1))
                    {
                        sequence.push(Node(T_STRING, prev.val.slice(0, -1)));
                        prev.val = prev.val.slice(-1);
                    }
                    sequence.push(Node(T_QUANTIFIER, prev, flag));
                }

                // special characters like ^, $, ., etc..
                else if (HAS.call(specialChars,ch))
                {
                    if (wordlen)
                    {
                        sequence.push(Node(T_STRING, word));
                        word = '';
                        wordlen = 0;
                    }
                    flag = {};
                    flag[specialChars[ch]] = 1;
                    sequence.push(Node(T_SPECIAL, ch, flag));
                }

                else
                {
                    word += ch;
                    wordlen += 1;
                }
            }
        }

        if (wordlen)
        {
            sequence.push(Node(T_STRING, word));
            word = '';
            wordlen = 0;
        }

        if (alternation.length)
        {
            alternation.push(Node(T_SEQUENCE, sequence));
            sequence = [];
            flag = {};
            flags[specialChars['|']] = 1;
            return Node(T_ALTERNATION, alternation, flag);
        }
        return Node(T_SEQUENCE, sequence);
    }
;

// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
// https://docs.python.org/3/library/re.html
// http://php.net/manual/en/reference.pcre.pattern.syntax.php
// A simple regular expression analyzer
function Analyzer(re, delim, flavor)
{
    if (!(this instanceof Analyzer)) return new Analyzer(re, delim, flavor);
    if (re) this.input(re, delim, flavor);
}
Analyzer.VERSION = __version__;
Analyzer[PROTO] = {

    constructor: Analyzer,

    ast: null,
    flavor: '',
    re: null,
    fl: null,
    src: null,
    grp: null,
    min: null,
    max: null,
    ch: null,
    bc: true,

    dispose: function() {
        var self = this;
        self.ast = null;
        self.flavor = null;
        self.re = null;
        self.fl = null;
        self.src = null;
        self.grp = null;
        self.min = null;
        self.max = null;
        self.ch = null;
        return self;
    },

    reset: function() {
        var self = this;
        self.ast = null;
        self.src = null;
        self.grp = null;
        self.min = null;
        self.max = null;
        self.ch = null;
        return self;
    },

    backwardsCompatible: function(enable) {
        this.bc = !!enable;
        return this;
    },

    input: function(re, delim, flavor) {
        var self = this;
        if (!arguments.length) return self.re;
        if (re)
        {
            delim = false === delim ? false : (delim || '/');
            var l, ch, fl = {};
            re = re.toString();
            l = re.length;

            if (delim)
            {
                // parse re flags, if any
                while (0 < l)
                {
                    ch = re[CHAR](l-1);
                    if (delim === ch) break;
                    else {fl[ch] = 1; --l;}
                }

                if (0 < l)
                {
                    // remove re delimiters
                    if ((delim === re[CHAR](0)) && (delim === re[CHAR](l-1))) re = re.slice(1, l-1);
                    else re = re.slice(0, l);
                }
                else
                {
                    re = '';
                }
            }

            // re is different, reset the ast, etc
            if (self.re !== re) self.reset();
            self.re = re; self.fl = fl; self.flavor = String(flavor || '');
        }
        return self;
    },

    analyze: function() {
        var self = this;
        if ((null != self.re) && (null === self.ast))
        {
            var re = new RE_OBJ(self.re, self.fl, self.flavor);
            self.ast = analyze_re(re);
            re.dispose();
        }
        return self;
    },

    synthesize: function(escaped) {
        var self = this, state, re;
        if (null == self.re) return self;
        if (null === self.ast)
        {
            self.analyze();
            self.src = null;
            self.grp = null;
        }
        if (null === self.src)
        {
            state = {
                MAP                 : T_SEQUENCE|T_ALTERNATION|T_GROUP|T_CHARGROUP|T_QUANTIFIER,
                REDUCE              : T_UNICODECHAR|T_HEXCHAR|T_SPECIAL|T_CHARS|T_CHARRANGE|T_STRING,
                IGNORE              : T_COMMENT,
                map                 : map_src,
                reduce              : reduce_src,
                escaped             : false !== escaped,
                compatibility       : self.bc,
                group               : {}
            };
            re = walk({src:'',group:{}}, self.ast, state);
            self.src = re.src; self.grp = re.group;
        }
        return self;
    },

    source: function() {
        var self = this;
        if (null == self.re) return null;
        if (null === self.src) self.synthesize();
        return self.src;
    },

    groups: function(raw) {
        var self = this;
        if (null == self.re) return null;
        if (null === self.grp) self.synthesize();
        return true === raw ? sel.grp : clone(self.grp);
    },

    compile: function(flags, notBackwardsCompatible) {
        var self = this;
        if (null == self.re) return null;
        flags = flags || self.fl || {};
        return new RegExp(self.source(), (flags.g||flags.G?'g':'')+(flags.i||flags.I?'i':'')+(flags.m||flags.M?'m':'')+(flags.y||flags.Y?'y':'')+(flags.u?'u':'')+(flags.d?'d':'')+(flags.s?'s':''));
    },

    tree: function(flat) {
        var self = this;
        if (null == self.re) return null;
        if (null === self.ast) self.analyze();
        return true===flat ? self.ast.toObject() : self.ast;
    },

    // experimental feature
    sample: function(maxlen, numsamples) {
        var self = this, state;
        if (null == self.re) return null;
        if (null === self.ast) self.analyze();
        state = {
            MAP                 : T_SEQUENCE|T_ALTERNATION|T_GROUP|T_CHARGROUP|T_QUANTIFIER,
            REDUCE              : T_UNICODECHAR|T_HEXCHAR|T_SPECIAL|T_CHARS|T_CHARRANGE|T_STRING,
            IGNORE              : T_COMMENT,
            map                 : map_any,
            reduce              : reduce_str,
            maxLength           : (maxlen|0) || 1,
            isCaseInsensitive   : null != self.fl.i,
            group               : {}
        };
        numsamples = (numsamples|0) || 1;
        if (1 < numsamples)
        {
            var samples = new Array(numsamples);
            for (var i=0; i<numsamples; ++i) samples[i] = walk('', self.ast, state);
            return samples;
        }
        return walk('', self.ast, state);
    },

    // experimental feature
    minimum: function() {
        var self = this, state;
        if (null == self.re) return 0;
        if (null === self.ast)
        {
            self.analyze( );
            self.min = null;
        }
        if (null === self.min)
        {
            state = {
                MAP                 : T_SEQUENCE|T_ALTERNATION|T_GROUP|T_CHARGROUP|T_QUANTIFIER,
                REDUCE              : T_UNICODECHAR|T_HEXCHAR|T_SPECIAL|T_CHARS|T_CHARRANGE|T_STRING,
                IGNORE              : T_COMMENT,
                map                 : map_min,
                reduce              : reduce_len,
                group               : {}
            };
            self.min = walk(0, self.ast, state)|0;
        }
        return self.min;
    },

    // experimental feature
    maximum: function() {
        var self = this, state;
        if (null == self.re) return 0;
        if (null === self.ast)
        {
            self.analyze();
            self.max = null;
        }
        if (null === self.max)
        {
            state = {
                MAP                 : T_SEQUENCE|T_ALTERNATION|T_GROUP|T_CHARGROUP|T_QUANTIFIER,
                REDUCE              : T_UNICODECHAR|T_HEXCHAR|T_SPECIAL|T_CHARS|T_CHARRANGE|T_STRING,
                IGNORE              : T_COMMENT,
                map                 : map_max,
                reduce              : reduce_len,
                group               : {}
            };
            self.max = walk(0, self.ast, state);
        }
        return self.max;
    },

    // experimental feature
    peek: function() {
        var self = this, state, isCaseInsensitive, peek, n, c, p, cases;
        if (null == self.re) return null;
        if (null === self.ast)
        {
            self.analyze();
            self.ch = null;
        }
        if (null === self.ch)
        {
            state = {
                MAP                 : T_SEQUENCE|T_ALTERNATION|T_GROUP|T_CHARGROUP|T_QUANTIFIER,
                REDUCE              : T_UNICODECHAR|T_HEXCHAR|T_SPECIAL|T_CHARS|T_CHARRANGE|T_STRING,
                IGNORE              : T_COMMENT,
                map                 : map_1st,
                reduce              : reduce_peek,
                group               : {},
            };
            self.ch = walk({positive:{},negative:{}}, self.ast, state);
        }
        peek = {positive:clone(self.ch.positive), negative:clone(self.ch.negative)};
        isCaseInsensitive = null != self.fl.i;
        for (n in peek)
        {
            cases = {};
            // either positive or negative
            p = peek[n];
            for (c in p)
            {
                if ('\\d' === c)
                {
                    delete p[c];
                    cases = concat(cases, character_range('0', '9'));
                }

                else if ('\\s' === c)
                {
                    delete p[c];
                    cases = concat(cases, ['\f','\n','\r','\t','\v','\u00A0','\u2028','\u2029']);
                }

                else if ('\\w' === c)
                {
                    delete p[c];
                    cases = concat(cases, ['_'].concat(character_range('0', '9')).concat(character_range('a', 'z')).concat(character_range('A', 'Z')));
                }

                else if ('\\b' === c)
                {
                    delete p[c];
                    cases[ specialChars['b'] ] = 1;
                }

                else if ('\\.' === c)
                {
                    delete p[c];
                    cases[ specialChars['.'] ] = 1;
                }

                /*else if ('\\^' === c)
                {
                    delete p[c];
                    cases[ specialChars['^'] ] = 1;
                }

                else if ('\\$' === c)
                {
                    delete p[c];
                    cases[ specialChars['$'] ] = 1;
                }*/

                else if ( (ESC !== c[CHAR](0)) && isCaseInsensitive )
                {
                    cases[ c.toLowerCase() ] = 1;
                    cases[ c.toUpperCase() ] = 1;
                }

                else if ( ESC === c[CHAR](0) )
                {
                    delete p[c];
                }
            }
            peek[n] = concat(p, cases);
        }
        return peek;
    }
};
// alias
Analyzer[PROTO].set = Analyzer[PROTO].input;
/*
// custom method to access named groups feature, if any
RegExp[PROTO].$group = null;
RegExp[PROTO].group = function( group ){
    group = group || 0;
    return this.$group && this.$group.hasOwnProperty(group) ? this.$group[group] : group;
};
*/

// A simple regular expression composer
function Composer()
{
    var self = this;
    if (!(self instanceof Composer)) return new Composer();
    self.re = null;
    self.reset();
}
Composer.VERSION = __version__;
Composer[PROTO] = {

    constructor: Composer,

    re: null,
    g: 0,
    grp: null,
    level: 0,
    ast: null,

    dispose: function() {
        var self = this;
        self.re = null;
        self.g = null;
        self.grp = null;
        self.level = null;
        self.ast = null;
        return self;
    },

    reset: function() {
        var self = this;
        self.g = 0;
        self.grp = {};
        self.level = 0;
        self.ast = [{node: [], type: T_SEQUENCE, flag: ''}];
        return self;
    },

    compose: function(/* flags */) {
        var self = this,
            fl = slice(arguments).join(''),
            src = self.ast[0].node.join('');
        self.re = {
            source  : src,
            flags   : fl,
            groups  : self.grp,
            pattern : RE(src, fl)
        };
        self.reset();
        return self.re;
    },

    partial: function(reset) {
        var self = this, re = self.ast[0].node.join('');
        if (false !== reset) self.reset();
        return re;
    },

    token: function(token, escaped) {
        var self = this;
        if (null != token)
            self.ast[self.level].node.push(escaped ? esc_re(String(token), ESC) : String(token));
        return self;
    },

    literal: function(literal) {
        return this.token(String(literal), true);
    },

    regexp: function(re) {
        return this.token(String(re), false);
    },

    SOL: function() {
        var self = this;
        self.ast[self.level].node.push('^');
        return self;
    },

    SOF: function() {
        return this.SOL();
    },

    EOL: function() {
        var self = this;
        self.ast[self.level].node.push('$');
        return self;
    },

    EOF: function() {
        return this.EOL();
    },

    LF: function() {
        var self = this;
        self.ast[self.level].node.push(ESC+'n');
        return self;
    },

    CR: function() {
        var self = this;
        self.ast[self.level].node.push(ESC+'r');
        return self;
    },

    TAB: function() {
        var self = this;
        self.ast[self.level].node.push(ESC+'t');
        return self;
    },

    CTRL: function(code) {
        var self = this;
        self.ast[self.level].node.push(ESC+'c'+(code||0));
        return self;
    },

    HEX: function(code) {
        var self = this;
        self.ast[self.level].node.push(ESC+'x'+pad(code||0, 2));
        return self;
    },

    UNICODE: function(code, uni) {
        var self = this;
        self.ast[self.level].node.push(true === uni ? ESC+'u{'+String(code||0)+'}' : ESC+'u'+pad(code||0, 4));
        return self;
    },

    backSpace: function() {
        var self = this;
        self.ast[self.level].node.push('['+ESC+'b]');
        return self;
    },

    any: function(multiline) {
        var self = this;
        self.ast[self.level].node.push(multiline ? '['+ESC+'s'+ESC+'S]' : '.');
        return self;
    },

    space: function(positive) {
        var self = this;
        if (arguments.length < 1) positive = true;
        self.ast[self.level].node.push(!positive ? ESC+'S' : ESC+'s');
        return self;
    },

    digit: function(positive) {
        var self = this;
        if (arguments.length < 1) positive = true;
        self.ast[self.level].node.push(!positive ? ESC+'D' : ESC+'d');
        return self;
    },

    word: function(positive) {
        var self = this;
        if (arguments.length < 1) positive = true;
        self.ast[self.level].node.push(!positive ? ESC+'W' : ESC+'w');
        return self;
    },

    boundary: function(positive) {
        var self = this;
        if (arguments.length < 1) positive = true;
        self.ast[self.level].node.push(!positive ? ESC+'B' : ESC+'b');
        return self;
    },

    characters: function() {
        var self = this;
        if (T_CHARGROUP === self.ast[self.level].type)
            self.ast[self.level].node.push(getArgs(arguments,1).map(function(c){ return esc_re(String(c), ESC, 1); }).join(''));
        return self;
    },

    range: function(start, end) {
        var self = this;
        if (null != start && null != end && T_CHARGROUP === self.ast[self.level].type)
            self.ast[self.level].node.push(esc_re(String(start), ESC, 1)+'-'+esc_re(String(end), ESC, 1));
        return self;
    },

    backReference: function(n) {
        var self = this;
        self.ast[self.level].node.push(ESC+(HAS.call(self.grp, n) ? self.grp[n] : n|0));
        return self;
    },

    repeat: function(min, max, greedy) {
        var self = this;
        if (null == min) return self;
        if (arguments.length < 3) greedy = true;
        var repeat = (null==max || min===max ? ('{'+String(min)+'}') : ('{'+String(min)+','+String(max)+'}')) + (!greedy ? '?' : '');
        self.ast[self.level].node[self.ast[self.level].node.length-1] += repeat;
        return self;
    },

    zeroOrOne: function(greedy) {
        var self = this;
        if (arguments.length < 1) greedy = true;
        self.ast[self.level].node[self.ast[self.level].node.length-1] += (!greedy ? '??' : '?');
        return self;
    },

    zeroOrMore: function(greedy) {
        var self = this;
        if (arguments.length < 1) greedy = true;
        self.ast[self.level].node[self.ast[self.level].node.length-1] += (!greedy ? '*?' : '*');
        return self;
    },

    oneOrMore: function(greedy) {
        var self = this;
        if (arguments.length < 1) greedy = true;
        self.ast[self.level].node[self.ast[self.level].node.length-1] += (!greedy ? '+?' : '+');
        return self;
    },

    alternate: function() {
        var self = this;
        self.level++;
        self.ast.push({node: [], type: T_ALTERNATION, flag: '', sequences: []});
        return self;
    },

    either: function() {
        return this.alternate();
    },

    or_: function() {
        var self = this, ast = self.ast[self.level];
        if ((T_ALTERNATION === ast.type) && ast.node.length)
        {
            ast.sequences.push(ast.node.join(''));
            ast.node = [];
        }
        return self;
    },

    group: function(opts, v) {
        var self = this, type = T_GROUP, fl = '';
        if (is_string(opts))
        {
            fl = opts; opts = {};
            opts[fl] = v; fl = '';
        }
        else
        {
            opts = opts || {};
        }
        if (!!opts['name'] || !!opts['named'])
        {
            self.g++;
            self.grp[self.g] = self.g;
            self.grp[opts.name||opts.named] = self.g;
        }
        else if ((true === opts['lookahead']) || (false === opts['lookahead']))
        {
            fl = false === opts['lookahead'] ? '?!' : '?=';
        }
        else if ((true === opts['lookbehind']) || (false === opts['lookbehind']))
        {
            fl = false === opts['lookbehind'] ? '?<!' : '?<=';
        }
        else if (true === opts['nocapture'])
        {
            fl = '?:';
        }
        else if ((true === opts['characters']) || (false === opts['characters']))
        {
            type = T_CHARGROUP;
            fl = false === opts['characters'] ? '^' : '';
        }
        else
        {
            self.g++;
            self.grp[self.g] = self.g;
        }
        self.level++;
        self.ast.push({node: [], type: type, flag: fl});
        return self;
    },

    subGroup: function(opts) {
        return this.group(opts);
    },

    characterGroup: function(positive) {
        return this.group({'characters':false!==positive});
    },

    namedGroup: function(name) {
        return this.group({'name':name});
    },

    nonCaptureGroup: function() {
        return this.group({'nocapture':true});
    },

    lookAheadGroup: function(positive) {
        return this.group({'lookahead':false!==positive});
    },

    lookBehindGroup: function(positive) {
        return this.group({'lookbehind':false!==positive});
    },

    end: function(n) {
        var self = this, prev, type, flag, part, sequences;
        n = (arguments.length ? n|0 : 1) || 1;
        // support ending multiple blocks at once
        while (n--)
        {
            prev = self.ast.length ? self.ast.pop() : null;
            type = prev ? prev.type : 0;
            flag = prev ? prev.flag : '';
            part = prev ? prev.node : [];
            if (T_ALTERNATION === type)
            {
                sequences = prev ? prev.sequences : [];
                part = !part.length ? sequences : sequences.concat(part.join(''));
            }
            if (0 < self.level)
            {
                --self.level;
                if (T_ALTERNATION === type)
                    self.ast[self.level].node.push(part.join('|'));
                else if (T_GROUP === type)
                    self.ast[self.level].node.push('('+flag+part.join('')+')');
                else if (T_CHARGROUP === type)
                    self.ast[self.level].node.push('['+flag+part.join('')+']');
                else
                    self.ast[self.level].node.push(part.join(''));
            }
        }
        return self;
    }
};
// aliases
var CP = Composer[PROTO];
CP.startOfLine = CP.SOL;
CP.endOfLine = CP.EOL;
CP.startOfInput = CP.SOF;
CP.endOfInput = CP.EOF;
CP.match = CP.token;
CP.sub = CP.regexp;
CP.lineFeed = CP.LF;
CP.carriageReturn = CP.CR;
CP.tabulate = CP.TAB;
CP.wordBoundary = CP.boundary;
CP.chars = CP.characters;
CP.charGroup = CP.characterGroup;
CP.namedSubGroup = CP.namedGroup;
CP.nonCaptureSubGroup = CP.nonCaptureGroup;
CP.lookAheadSubGroup = CP.lookAheadGroup;
CP.lookBehindSubGroup = CP.lookBehindGroup;

var Regex = {
    VERSION     : __version__,
    Node        : Node,
    Analyzer    : Analyzer,
    Composer    : Composer
};
/* export the module */
return Regex;
})();