fix(all): accept RegexOptions.NonBacktracking

src/Fable.Transforms/Replacements.Util.fs

@@ -1293,6 +1293,7 @@ let (|RegexFlags|_|) e =
             | 8 -> Some [] // Compiled flag (ignored)
             | 16 -> Some [ RegexSingleline ]
             | 256 -> Some [] // ECMAScript flag (ignored)
+            | 1024 -> Some [] // NonBacktracking flag (ignored)
             | _ -> None
         | Operation(Binary(BinaryOrBitwise, flags1, flags2), _, _, _) ->
             match getFlags flags1, getFlags flags2 with

src/fable-library-dart/RegExp.dart

@@ -61,9 +61,10 @@ RegExp create(String pattern, [int options = 0]) {
   // * Compiled:    0x0008 (ignored)
   // * Singleline:  0x0010
   // * ECMAScript:  0x0100 (ignored)
-  if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256)) != 0) {
+  // * NonBacktracking: 0x0400 (ignored)
+  if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256 ^ 1024)) != 0) {
     throw Exception(
-        'RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript');
+        'RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline, ECMAScript and NonBacktracking');
   }
   return RegExp(pattern,
       unicode: true,

src/fable-library-rust/src/RegExp.rs

@@ -193,7 +193,8 @@ pub mod RegExp_ {
             // * Singleline:               0x0010
             // * IgnorePatternWhitespace:  0x0020
             // * ECMAScript:               0x0100 (ignored)
-            if ((options & !(1 | 2 | 8 | 16 | 32 | 256)) != 0) {
+            // * NonBacktracking:          0x0400 (ignored)
+            if ((options & !(1 | 2 | 8 | 16 | 32 | 256 | 1024)) != 0) {
                 panic!("Unsupported Regex Option");
             }
             let regex_ = regex::RegexBuilder::new(pat.as_str())

src/fable-library-ts/RegExp.ts

@@ -9,8 +9,9 @@ export function create(pattern: string, options = 0) {
   // * Compiled:    0x0008 (ignored)
   // * Singleline:  0x0010
   // * ECMAScript:  0x0100 (ignored)
-  if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256)) !== 0) {
-    throw new Exception("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline and ECMAScript");
+  // * NonBacktracking: 0x0400 (ignored)
+  if ((options & ~(1 ^ 2 ^ 8 ^ 16 ^ 256 ^ 1024)) !== 0) {
+    throw new Exception("RegexOptions only supports: IgnoreCase, Multiline, Compiled, Singleline, ECMAScript and NonBacktracking");
   }
   // Set always global and unicode flags for compatibility with dotnet, see #2925
   let flags = "gu";

tests/Beam/RegexTests.fs

@@ -164,6 +164,14 @@ let ``test Regex.Unescape works`` () =
 
 // --- Options ---
 
+[<Fact>]
+let ``test RegexOptions.NonBacktracking is accepted`` () =
+    let options = RegexOptions.NonBacktracking ||| RegexOptions.IgnoreCase
+    let r = Regex("ab", options)
+    r.IsMatch("xABx") |> equal true
+    Regex.IsMatch("aaab", "(a+)*b", RegexOptions.NonBacktracking) |> equal true
+    Regex.Replace("a1b2", "\\d", "-", RegexOptions.NonBacktracking) |> equal "a-b-"
+
 [<Fact>]
 let ``test Regex.Options works`` () =
     let r = Regex("\\d+", RegexOptions.IgnoreCase ||| RegexOptions.Multiline)

tests/Dart/src/RegexTests.fs

@@ -41,6 +41,13 @@ let tests() =
         let r = Regex("[a-z]", options)
         int r.Options |> equal 257
 
+    testCase "RegexOptions.NonBacktracking is accepted" <| fun _ ->
+        let options = RegexOptions.NonBacktracking ||| RegexOptions.IgnoreCase
+        let r = Regex("ab", options)
+        r.IsMatch("xABx") |> equal true
+        Regex.IsMatch("aaab", "(a+)*b", RegexOptions.NonBacktracking) |> equal true
+        Regex.Replace("a1b2", "\\d", "-", RegexOptions.NonBacktracking) |> equal "a-b-"
+
     testCase "Regex.IsMatch with IgnoreCase and Multiline works" <| fun _ ->
         let str = "ab\ncd"
         let option1 = RegexOptions.IgnoreCase

tests/Js/Main/RegexTests.fs

@@ -37,6 +37,13 @@ let tests =
         let r = Regex("[a-z]", options)
         int r.Options |> equal 257
 
+    testCase "RegexOptions.NonBacktracking is accepted" <| fun _ ->
+        let options = RegexOptions.NonBacktracking ||| RegexOptions.IgnoreCase
+        let r = Regex("ab", options)
+        r.IsMatch("xABx") |> equal true
+        Regex.IsMatch("aaab", "(a+)*b", RegexOptions.NonBacktracking) |> equal true
+        Regex.Replace("a1b2", "\\d", "-", RegexOptions.NonBacktracking) |> equal "a-b-"
+
     testCase "Regex.IsMatch with IgnoreCase and Multiline works" <| fun _ ->
         let str = "ab\ncd"
         let option1 = RegexOptions.IgnoreCase

tests/Python/TestRegex.fs

@@ -46,6 +46,14 @@ let ``test Literal regex works with whitespace characters`` () = // See #2635
     Regex("\\t").IsMatch("foo\tbar") |> equal true
     Regex(@"\\t").IsMatch("foo\tbar") |> equal false
 
+[<Fact>]
+let ``test RegexOptions.NonBacktracking is accepted`` () =
+    let options = RegexOptions.NonBacktracking ||| RegexOptions.IgnoreCase
+    let r = Regex("ab", options)
+    r.IsMatch("xABx") |> equal true
+    Regex.IsMatch("aaab", "(a+)*b", RegexOptions.NonBacktracking) |> equal true
+    Regex.Replace("a1b2", "\\d", "-", RegexOptions.NonBacktracking) |> equal "a-b-"
+
 [<Fact>]
 let ``test Regex.Options works`` () =
     let option1 = int RegexOptions.IgnoreCase

tests/Rust/tests/src/RegexTests.fs

@@ -31,6 +31,14 @@ let ``Literal regex works with whitespace characters`` () = // See #2635
     Regex("\\t").IsMatch("foo\tbar") |> equal true
     Regex(@"\\t").IsMatch("foo\tbar") |> equal false
 
+[<Fact>]
+let ``RegexOptions.NonBacktracking is accepted`` () =
+    let options = RegexOptions.NonBacktracking ||| RegexOptions.IgnoreCase
+    let r = Regex("ab", options)
+    r.IsMatch("xABx") |> equal true
+    Regex.IsMatch("aaab", "(a+)*b", RegexOptions.NonBacktracking) |> equal true
+    Regex.Replace("a1b2", "\\d", "-", RegexOptions.NonBacktracking) |> equal "a-b-"
+
 [<Fact>]
 let ``Regex.Options works`` () =
     let option1 = RegexOptions.IgnoreCase