fix(parser): /a{,3}/ is interpreted literally

Apparently, lower bounds are not optional at least when an upper bound
is defined.

Author: gruhn

src/index.ts

@@ -174,7 +174,7 @@ class RegexBuilder {
    * ```typescript
    * RB('a').repeat(4) // a{4}
    * RB('a').repeat({ min: 3, max: 5 }) // a{3,5}
-   * RB('a').repeat({ max: 5 }) // a{,5}
+   * RB('a').repeat({ max: 5 }) // a{0,5}
    * RB('a').repeat({ min: 3 }) // a{3,}
    * RB('a').repeat({ min: 0, max: 1 }) // a?
    * RB('a').repeat({ min: 0 }) // a*

src/regex-parser.ts

@@ -139,34 +139,30 @@ const group = P.choice([
 
 // Need to backtrack on bounded quantifier because if the curly bracket is
 // not terminated (e.g. "a{2,3") then all characters are interpreted literally.
+// The same if min value is missing but max value is given (e.g. "a{,3}").
+// 
 // FIXME: However, this breaks something else. E.g. "a*{3}" must still be rejected as
 // invalid and not interpreted as "a*" and then literal charactesr "{3}".
 const boundedQuantifier: P.Expr.UnaryOperator<AST.RegExpAST> = P.tryElseBacktrack(
   P.between(
     P.string('{'),
     P.string('}'),
-    P.optional(P.decimal).andThen(min => {
-      if (min === undefined)
-        // e.g. a{,5}
-        return P.string(',')
-          .andThen(_ => P.decimal)
-          .map(max => inner => AST.repeat(inner, { max }))
-      else
-        return P.optional(P.string(',')).andThen(comma => {
-          if (comma === undefined)
-            // e.g. a{3}
-            return P.pure(inner => AST.repeat(inner, min))
-          else
-            return P.optional(P.decimal).map(max => inner => {
-              if (max === undefined)
-                // e.g. a{3,}
-                return AST.repeat(inner, { min })
-              else
-                // e.g. a{3,5}
-                return AST.repeat(inner, { min, max })
-            })
-        })
-    })
+    P.decimal.andThen(min => 
+      P.optional(P.string(',')).andThen(comma => {
+        if (comma === undefined)
+          // e.g. a{3}
+          return P.pure(inner => AST.repeat(inner, min))
+        else
+          return P.optional(P.decimal).map(max => inner => {
+            if (max === undefined)
+              // e.g. a{3,}
+              return AST.repeat(inner, { min })
+            else
+              // e.g. a{3,5}
+              return AST.repeat(inner, { min, max })
+          })
+      })
+    )
   )
 )
 

test/regex-parser.spec.ts

@@ -38,10 +38,11 @@ describe('parseRegExp', () => {
     // bounded quantifier:
     [/a{3}/, AST.repeat(char('a'), 3)],
     [/a{3,}/, AST.repeat(char('a'), { min: 3 })],
-    [/a{,5}/, AST.repeat(char('a'), { max: 5 })],
     [/a{3,5}/, AST.repeat(char('a'), { min: 3, max: 5 })],
     // if curly bracket is not terminated the whole thing is interpreted literally:
     [/a{3,5/, str('a{3,5')],
+    // same if max value is given but min value is missing: 
+    [/a{,5}/, str('a{,5}')],
     // char classes / escaping:
     [/\w/, AST.literal(CharSet.wordChars)],
     [/\W/, AST.literal(CharSet.nonWordChars)],