commit 247e15c08ccd7054d7da07b5b77089418f546bd5 · kitten.sh/reghex

+33 -29

src/babel/__snapshots__/plugin.test.js.snap

···

       185
        
             break alt_3;

     

       186
        
           }

     

       187
        
       

     

       188
       -
           loop_3: for (var j3 = 0; 1; j3++) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       189
        
             var y3 = state.y,

     

       190
        
                 x3 = state.x;

     

       191
        
       

     

       192
        
             if ((x = _node_expression3(state)) != null) {} else {

     

       193
       -
               if (j3) {

     

       194
       -
                 state.y = y3;

     

       195
       -
                 state.x = x3;

     

       196
       -
                 break loop_3;

     

       197
       -
               } else {}

     

       198
       -
       

     

       199
       -
               state.y = y1;

     

       200
       -
               state.x = x1;

     

       201
       -
               node.length = ln2;

     

       202
       -
               return;

     

       203
        
             }

     

       204
        
           }

     

       205
        
         }

     
···

       269
        
             var y2 = state.y,

     

       270
        
                 x2 = state.x;

     

       271
        
       

     

       272
       -
             loop_2: for (var j2 = 0; 1; j2++) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       273
        
               var y2 = state.y,

     

       274
        
                   x2 = state.x;

     

       275
        
       

     

       276
        
               if ((x = _node_expression(state)) != null) {

     

       277
        
                 node.push(x);

     

       278
        
               } else {

     

       279
       -
                 if (j2) {

     

       280
       -
                   state.y = y2;

     

       281
       -
                   state.x = x2;

     

       282
       -
                   break loop_2;

     

       283
       -
                 } else {}

     

       284
       -
       

     

       285
        
                 state.y = y2;

     

       286
        
                 state.x = x2;

     

       287
       -
                 break block_2;

     

       288
        
               }

     

       289
        
             }

     

       290
        
       

     

       291
        
             break alt_2;

     

       292
        
           }

     

       293
        
       

     

       294
       -
           loop_2: for (var j2 = 0; 1; j2++) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       295
        
             var y2 = state.y,

     

       296
        
                 x2 = state.x;

     

       297
        
       

     

       298
        
             if ((x = _node_expression2(state)) != null) {

     

       299
        
               node.push(x);

     

       300
        
             } else {

     

       301
       -
               if (j2) {

     

       302
       -
                 state.y = y2;

     

       303
       -
                 state.x = x2;

     

       304
       -
                 break loop_2;

     

       305
       -
               } else {}

     

       306
       -
       

     

       307
       -
               state.y = y1;

     

       308
       -
               state.x = x1;

     

       309
       -
               return;

     

       310
        
             }

     

       311
        
           }

     

       312

···

       185
        
             break alt_3;

     

       186
        
           }

     

       187
        
       

     

       188
       +
           if ((x = _node_expression3(state)) != null) {} else {

     

       189
       +
             state.y = y1;

     

       190
       +
             state.x = x1;

     

       191
       +
             node.length = ln2;

     

       192
       +
             return;

     

       193
       +
           }

     

       194
       +
       

     

       195
       +
           loop_3: for (;;) {

     

       196
        
             var y3 = state.y,

     

       197
        
                 x3 = state.x;

     

       198
        
       

     

       199
        
             if ((x = _node_expression3(state)) != null) {} else {

     

       200
       +
               state.y = y3;

     

       201
       +
               state.x = x3;

     

       202
       +
               break loop_3;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       203
        
             }

     

       204
        
           }

     

       205
        
         }

     
···

       269
        
             var y2 = state.y,

     

       270
        
                 x2 = state.x;

     

       271
        
       

     

       272
       +
             if ((x = _node_expression(state)) != null) {

     

       273
       +
               node.push(x);

     

       274
       +
             } else {

     

       275
       +
               state.y = y2;

     

       276
       +
               state.x = x2;

     

       277
       +
               break block_2;

     

       278
       +
             }

     

       279
       +
       

     

       280
       +
             loop_2: for (;;) {

     

       281
        
               var y2 = state.y,

     

       282
        
                   x2 = state.x;

     

       283
        
       

     

       284
        
               if ((x = _node_expression(state)) != null) {

     

       285
        
                 node.push(x);

     

       286
        
               } else {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       287
        
                 state.y = y2;

     

       288
        
                 state.x = x2;

     

       289
       +
                 break loop_2;

     

       290
        
               }

     

       291
        
             }

     

       292
        
       

     

       293
        
             break alt_2;

     

       294
        
           }

     

       295
        
       

     

       296
       +
           if ((x = _node_expression2(state)) != null) {

     

       297
       +
             node.push(x);

     

       298
       +
           } else {

     

       299
       +
             state.y = y1;

     

       300
       +
             state.x = x1;

     

       301
       +
             return;

     

       302
       +
           }

     

       303
       +
       

     

       304
       +
           loop_2: for (;;) {

     

       305
        
             var y2 = state.y,

     

       306
        
                 x2 = state.x;

     

       307
        
       

     

       308
        
             if ((x = _node_expression2(state)) != null) {

     

       309
        
               node.push(x);

     

       310
        
             } else {

     

       311
       +
               state.y = y2;

     

       312
       +
               state.x = x2;

     

       313
       +
               break loop_2;

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       314
        
             }

     

       315
        
           }

     

       316

+5 -20

src/codegen.js

···

       35
        
           if ((${_match} = ${ast.expression.id}(${_state})) != null) {

     

       36
        
             ${capture ? js`${_node}.push(${_match})` : ''}

     

       37
        
           } else {

     

       38
       -
             ${opts.onAbort}

     

       39
        
             ${restoreIndex(opts.index)}

     

       40
        
             ${restoreLength}

     

       41
        
             ${opts.abort}

     
···

       64
        
         ast.expression ? astExpression(ast, depth, opts) : astGroup(ast, depth, opts);

     

       65
        
       

     

       66
        
       const astQuantifier = (ast, depth, opts) => {

     

       67
       -
         const { index, abort, onAbort } = opts;

     

       68
        
         const invert = `inv_${depth}`;

     

       69
        
         const loop = `loop_${depth}`;

     

       70
       -
         const count = `j${depth}`;

     

       71
        
       

     

       72
        
         opts = copy(opts);

     

       73
        
         if (ast.capture === '!') {

     
···

       77
        
       

     

       78
        
         let child;

     

       79
        
         if (ast.quantifier === '+') {

     

       80
       -
           opts.onAbort = js`

     

       81
       -
             if (${count}) {

     

       82
       -
               ${restoreIndex(depth)}

     

       83
       -
               break ${loop};

     

       84
       -
             } else {

     

       85
       -
               ${onAbort}

     

       86
       -
             }

     

       87
       -
           `;

     

       88
       -
       

     

       89
        
           child = js`

     

       90
       -
             ${loop}: for (var ${count} = 0; 1; ${count}++) {

     

       91
       -
               ${assignIndex(depth)}

     

       92
       -
               ${astChild(ast, depth, opts)}

     

       93
       -
             }

     

       94
        
           `;

     

       95
        
         } else if (ast.quantifier === '*') {

     

       96
        
           opts.length = 0;

     

       97
        
           opts.index = depth;

     

       98
        
           opts.abort = js`break ${loop};`;

     

       99
       -
           opts.onAbort = '';

     

       100
        
       

     

       101
        
           child = js`

     

       102
        
             ${loop}: for (;;) {

     
···

       107
        
         } else if (ast.quantifier === '?') {

     

       108
        
           opts.index = depth;

     

       109
        
           opts.abort = '';

     

       110
       -
           opts.onAbort = '';

     

       111
        
       

     

       112
        
           child = js`

     

       113
        
             ${assignIndex(depth)}

     
···

       149
        
             childOpts = copy(opts);

     

       150
        
             childOpts.index = depth;

     

       151
        
             childOpts.abort = js`break ${block};`;

     

       152
       -
             childOpts.onAbort = '';

     

       153
        
           }

     

       154
        
       

     

       155
        
           let sequence = '';

     
···

       188
        
             ${astSequence(ast, 2, {

     

       189
        
               index: 1,

     

       190
        
               length: 0,

     

       191
       -
               onAbort: '',

     

       192
        
               abort: js`return;`,

     

       193
        
               capture: true,

     

       194
        
             })}

···

       35
        
           if ((${_match} = ${ast.expression.id}(${_state})) != null) {

     

       36
        
             ${capture ? js`${_node}.push(${_match})` : ''}

     

       37
        
           } else {

     

       0
        
       
     

       38
        
             ${restoreIndex(opts.index)}

     

       39
        
             ${restoreLength}

     

       40
        
             ${opts.abort}

     
···

       63
        
         ast.expression ? astExpression(ast, depth, opts) : astGroup(ast, depth, opts);

     

       64
        
       

     

       65
        
       const astQuantifier = (ast, depth, opts) => {

     

       66
       +
         const { index, abort } = opts;

     

       67
        
         const invert = `inv_${depth}`;

     

       68
        
         const loop = `loop_${depth}`;

     

       0
        
       
     

       69
        
       

     

       70
        
         opts = copy(opts);

     

       71
        
         if (ast.capture === '!') {

     
···

       75
        
       

     

       76
        
         let child;

     

       77
        
         if (ast.quantifier === '+') {

     

       78
       +
           const starAst = copy(ast);

     

       79
       +
           starAst.quantifier = '*';

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       80
        
           child = js`

     

       81
       +
             ${astChild(ast, depth, opts)}

     

       82
       +
             ${astQuantifier(starAst, depth, opts)}

     

       0
        
       
     

       0
        
       
     

       83
        
           `;

     

       84
        
         } else if (ast.quantifier === '*') {

     

       85
        
           opts.length = 0;

     

       86
        
           opts.index = depth;

     

       87
        
           opts.abort = js`break ${loop};`;

     

       0
        
       
     

       88
        
       

     

       89
        
           child = js`

     

       90
        
             ${loop}: for (;;) {

     
···

       95
        
         } else if (ast.quantifier === '?') {

     

       96
        
           opts.index = depth;

     

       97
        
           opts.abort = '';

     

       0
        
       
     

       98
        
       

     

       99
        
           child = js`

     

       100
        
             ${assignIndex(depth)}

     
···

       136
        
             childOpts = copy(opts);

     

       137
        
             childOpts.index = depth;

     

       138
        
             childOpts.abort = js`break ${block};`;

     

       0
        
       
     

       139
        
           }

     

       140
        
       

     

       141
        
           let sequence = '';

     
···

       174
        
             ${astSequence(ast, 2, {

     

       175
        
               index: 1,

     

       176
        
               length: 0,

     

       0
        
       
     

       177
        
               abort: js`return;`,

     

       178
        
               capture: true,

     

       179
        
             })}