···

       
40
       
 
       
exports[`works with local recursion 1`] = `

     

       
41
       
 
       
"import { match as m, tag, _exec, _pattern } from 'reghex';

     

       
42
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
43
       
 
       
const inner = function (state) {

     

       
44
       
 
       
  var index_1 = state.index;

     

       
45
       
 
       
  var node = [];

     

       
46
       
 
       
  var match;

     

       
47
       
 
       


     

       
48
       
-
       
  if (match = _exec(state, \\"inner\\")) {

     

       
49
       
 
       
    node.push(match);

     

       
50
       
 
       
  } else {

     

       
51
       
 
       
    state.index = index_1;

     

···

       
40
       
 
       
exports[`works with local recursion 1`] = `

     

       
41
       
 
       
"import { match as m, tag, _exec, _pattern } from 'reghex';

     

       
42
       
 
       


     

       
43
       
+
       
var _inner_expression = _pattern(/inner/);

     

       
44
       
+
       


     

       
45
       
 
       
const inner = function (state) {

     

       
46
       
 
       
  var index_1 = state.index;

     

       
47
       
 
       
  var node = [];

     

       
48
       
 
       
  var match;

     

       
49
       
 
       


     

       
50
       
+
       
  if (match = _exec(state, _inner_expression)) {

     

       
51
       
 
       
    node.push(match);

     

       
52
       
 
       
  } else {

     

       
53
       
 
       
    state.index = index_1;

     

···

       
115
       
 
       
              const matchPath = binding.path.get('init');

     

       
116
       
 
       
              if (this.isMatch(matchPath)) return expression;

     

       
117
       
 
       
            }

     

       
118
       
-
       
          } else if (

     

       
119
       
-
       
            t.isRegExpLiteral(expression) &&

     

       
120
       
-
       
            !regexPatternsRe.test(expression.pattern)

     

       
121
       
-
       
          ) {

     

       
122
       
-
       
            // NOTE: This is an optimisation path, where the pattern regex is inlined

     

       
123
       
-
       
            // and has determined to be "simple" enough to be turned into a string

     

       
124
       
-
       
            return t.stringLiteral(

     

       
125
       
-
       
              expression.pattern.replace(/\\./g, (x) => x[1])

     

       
126
       
-
       
            );

     

       
127
       
 
       
          }

     

       
128
       
 
       


     

       
129
       
 
       
          const id = path.scope.generateUidIdentifier(

     

···

       
115
       
 
       
              const matchPath = binding.path.get('init');

     

       
116
       
 
       
              if (this.isMatch(matchPath)) return expression;

     

       
117
       
 
       
            }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
118
       
 
       
          }

     

       
119
       
 
       


     

       
120
       
 
       
          const id = path.scope.generateUidIdentifier(

     

···

       
17
       
 
       
  if (typeof pattern === 'function') {

     

       
18
       
 
       
    while (typeof pattern === 'function') pattern = pattern(state);

     

       
19
       
 
       
    return pattern;

     

       
20
       
-
       
  } else if (typeof pattern === 'string') {

     

       
21
       
-
       
    const end = state.index + pattern.length;

     

       
22
       
-
       
    const sub = state.input.slice(state.index, end);

     

       
23
       
-
       
    if (sub === pattern) {

     

       
24
       
-
       
      state.index = end;

     

       
25
       
-
       
      match = sub;

     

       
26
       
-
       
    }

     

       
27
       
 
       
  } else if (isStickySupported) {

     

       
28
       
 
       
    pattern.lastIndex = state.index;

     

       
29
       
 
       
    if (pattern.test(state.input)) {

     

···

       
17
       
 
       
  if (typeof pattern === 'function') {

     

       
18
       
 
       
    while (typeof pattern === 'function') pattern = pattern(state);

     

       
19
       
 
       
    return pattern;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
20
       
 
       
  } else if (isStickySupported) {

     

       
21
       
 
       
    pattern.lastIndex = state.index;

     

       
22
       
 
       
    if (pattern.test(state.input)) {