diff --git a/src/core/regex/include/sourcemeta/core/regex.h b/src/core/regex/include/sourcemeta/core/regex.h
index c2eac823f..49b6625fc 100644
--- a/src/core/regex/include/sourcemeta/core/regex.h
+++ b/src/core/regex/include/sourcemeta/core/regex.h
@@ -119,6 +119,22 @@ SOURCEMETA_CORE_REGEX_EXPORT
 auto matches_if_valid(const std::string_view pattern,
                       const std::string_view value) -> bool;
 
+/// @ingroup regex
+///
+/// Check whether the given string is a valid ECMA-262 regular expression. For
+/// example:
+///
+/// ```cpp
+/// #include <sourcemeta/core/regex.h>
+/// #include <cassert>
+///
+/// assert(sourcemeta::core::is_regex_ecma("([abc])+\\s+$"));
+/// assert(!sourcemeta::core::is_regex_ecma("^(abc]"));
+/// assert(!sourcemeta::core::is_regex_ecma("\\a"));
+/// ```
+SOURCEMETA_CORE_REGEX_EXPORT
+auto is_regex_ecma(const std::string_view pattern) -> bool;
+
 } // namespace sourcemeta::core
 
 #endif
diff --git a/src/core/regex/preprocess.h b/src/core/regex/preprocess.h
index 682aac0a9..c9630da45 100644
--- a/src/core/regex/preprocess.h
+++ b/src/core/regex/preprocess.h
@@ -7,6 +7,7 @@
 #include <optional>    // std::optional
 #include <string>      // std::string
 #include <string_view> // std::string_view
+#include <type_traits> // std::conditional_t
 #include <utility>     // std::pair
 
 namespace sourcemeta::core {
@@ -636,14 +637,63 @@ inline auto find_shorthand(char escape) -> const ShorthandExpansion * {
 
 } // namespace
 
+template <bool CheckECMA>
 inline auto preprocess_regex(const std::string &pattern)
-    -> std::optional<std::string> {
+    -> std::conditional_t<CheckECMA, bool, std::optional<std::string>> {
   std::string result;
-  result.reserve(pattern.size() * 2);
+  if constexpr (!CheckECMA) {
+    result.reserve(pattern.size() * 2);
+  }
   bool in_class = false;
 
   for (std::size_t position = 0; position < pattern.size(); ++position) {
     const char current = pattern[position];
+
+    // Reject group constructs that are not part of ECMA-262
+    if (current == '(' && !is_escaped(pattern, position) && !in_class &&
+        position + 1 < pattern.size()) {
+      // (*...) backtracking control verbs (PCRE-only)
+      if (pattern[position + 1] == '*') {
+        if constexpr (CheckECMA) {
+          return false;
+        } else {
+          return std::nullopt;
+        }
+      }
+      // (?X...): ECMA only allows (?:  (?=  (?!  (?<=  (?<!  (?<name>
+      if (pattern[position + 1] == '?' && position + 2 < pattern.size()) {
+        const char third = pattern[position + 2];
+        bool valid_extension{third == ':' || third == '=' || third == '!'};
+        if (!valid_extension && third == '<' && position + 3 < pattern.size()) {
+          const char fourth = pattern[position + 3];
+          valid_extension = fourth == '=' || fourth == '!' ||
+                            (fourth >= 'a' && fourth <= 'z') ||
+                            (fourth >= 'A' && fourth <= 'Z') || fourth == '_' ||
+                            fourth == '$';
+        }
+        if (!valid_extension) {
+          if constexpr (CheckECMA) {
+            return false;
+          } else {
+            return std::nullopt;
+          }
+        }
+      }
+    }
+
+    // Reject possessive quantifiers (PCRE-only): *+ ++ ?+
+    if (current == '+' && position > 0 && !in_class) {
+      const char prev = pattern[position - 1];
+      if ((prev == '*' || prev == '+' || prev == '?') &&
+          !is_escaped(pattern, position - 1)) {
+        if constexpr (CheckECMA) {
+          return false;
+        } else {
+          return std::nullopt;
+        }
+      }
+    }
+
     if (current == '[' && !is_escaped(pattern, position) && !in_class) {
       // Find end both ways and check which applies
       const auto simple_end = find_bracket_end(pattern, position + 1, false);
@@ -652,6 +702,16 @@ inline auto preprocess_regex(const std::string &pattern)
       const auto nested_content =
           pattern.substr(position + 1, nested_end - position - 2);
 
+      // Reject POSIX-style character classes like [[:alpha:]] (PCRE-only)
+      if (nested_content.size() >= 4 && nested_content[0] == '[' &&
+          nested_content[1] == ':' && nested_content.ends_with(":]")) {
+        if constexpr (CheckECMA) {
+          return false;
+        } else {
+          return std::nullopt;
+        }
+      }
+
       // Check for v-flag operators in nested content
       const bool nested_has_ops =
           nested_content.contains("--") || nested_content.contains("&&");
@@ -680,10 +740,16 @@ inline auto preprocess_regex(const std::string &pattern)
       if (use_v_flag) {
         const auto expanded = expand_char_class(nested_content);
         if (!expanded) {
-          return std::nullopt;
+          if constexpr (CheckECMA) {
+            return false;
+          } else {
+            return std::nullopt;
+          }
         }
 
-        result += *expanded;
+        if constexpr (!CheckECMA) {
+          result += *expanded;
+        }
         position = nested_end - 1;
         continue;
       }
@@ -696,41 +762,81 @@ inline auto preprocess_regex(const std::string &pattern)
     }
 
     if (current != '\\' || position + 1 >= pattern.size()) {
-      result += current;
+      if constexpr (!CheckECMA) {
+        result += current;
+      }
       continue;
     }
 
     const char next = pattern[position + 1];
     if (std::string_view{"\\[]^$"}.contains(next)) {
-      result += current;
-      result += next;
+      if constexpr (!CheckECMA) {
+        result += current;
+        result += next;
+      }
       ++position;
       continue;
     }
 
     if (next == 'u' && position + 2 < pattern.size()) {
       if (pattern[position + 2] == '{') {
-        result += "\\x{";
+        if constexpr (!CheckECMA) {
+          result += "\\x{";
+        }
         for (position += 3;
              position < pattern.size() && pattern[position] != '}';
              ++position) {
-          result += pattern[position];
+          if constexpr (!CheckECMA) {
+            result += pattern[position];
+          }
         }
 
         if (position < pattern.size()) {
-          result += '}';
+          if constexpr (!CheckECMA) {
+            result += '}';
+          }
         }
 
         continue;
       }
 
       if (position + 5 < pattern.size() && all_hex(pattern, position + 2, 4)) {
-        result += "\\x{" + pattern.substr(position + 2, 4) + '}';
+        if constexpr (!CheckECMA) {
+          result += "\\x{" + pattern.substr(position + 2, 4) + '}';
+        }
         position += 5;
         continue;
       }
     }
 
+    // Named backreference \k<name> (ECMA-262 since 2018)
+    if (next == 'k' && position + 2 < pattern.size() &&
+        pattern[position + 2] == '<') {
+      if constexpr (!CheckECMA) {
+        result += "\\k<";
+      }
+      const auto name_start = position + 3;
+      position = name_start;
+      while (position < pattern.size() && pattern[position] != '>') {
+        if constexpr (!CheckECMA) {
+          result += pattern[position];
+        }
+        ++position;
+      }
+      // Reject unterminated \k<name or empty name \k<>
+      if (position >= pattern.size() || position == name_start) {
+        if constexpr (CheckECMA) {
+          return false;
+        } else {
+          return std::nullopt;
+        }
+      }
+      if constexpr (!CheckECMA) {
+        result += '>';
+      }
+      continue;
+    }
+
     if ((next == 'p' || next == 'P') && position + 2 < pattern.size() &&
         pattern[position + 2] == '{') {
       const auto start = position;
@@ -742,13 +848,19 @@ inline auto preprocess_regex(const std::string &pattern)
 
       if (position < pattern.size()) {
         if (auto translated = translate_property(name, next == 'P')) {
-          result += *translated;
+          if constexpr (!CheckECMA) {
+            result += *translated;
+          }
         } else {
-          result += pattern.substr(start, position - start + 1);
+          if constexpr (!CheckECMA) {
+            result += pattern.substr(start, position - start + 1);
+          }
         }
       } else {
         position = start;
-        result += current;
+        if constexpr (!CheckECMA) {
+          result += current;
+        }
       }
 
       continue;
@@ -756,18 +868,42 @@ inline auto preprocess_regex(const std::string &pattern)
 
     if (const auto *expansion = find_shorthand(next)) {
       if (in_class && expansion->inside_class.empty()) {
-        result += std::string{current} + next;
+        if constexpr (!CheckECMA) {
+          result += std::string{current} + next;
+        }
       } else {
-        result += in_class ? expansion->inside_class : expansion->outside_class;
+        if constexpr (!CheckECMA) {
+          result +=
+              in_class ? expansion->inside_class : expansion->outside_class;
+        }
       }
 
       ++position;
     } else {
-      result += current;
+      // Reject escape sequences that are not valid in ECMA-262 strict mode
+      constexpr std::string_view ecma_remaining_escapes{"tnrfvcx0"};
+      const bool is_ecma_escape{ecma_remaining_escapes.contains(next) ||
+                                v_flag_syntax.contains(next) ||
+                                (next >= '1' && next <= '9')};
+      if (!is_ecma_escape) {
+        if constexpr (CheckECMA) {
+          return false;
+        } else {
+          return std::nullopt;
+        }
+      }
+
+      if constexpr (!CheckECMA) {
+        result += current;
+      }
     }
   }
 
-  return result;
+  if constexpr (CheckECMA) {
+    return true;
+  } else {
+    return result;
+  }
 }
 
 } // namespace sourcemeta::core
diff --git a/src/core/regex/regex.cc b/src/core/regex/regex.cc
index 094857bcd..f3b4e0146 100644
--- a/src/core/regex/regex.cc
+++ b/src/core/regex/regex.cc
@@ -59,7 +59,7 @@ auto to_regex(const std::string_view pattern) -> std::optional<Regex> {
     return RegexTypeRange{minimum, maximum};
   }
 
-  const auto pcre2_pattern{preprocess_regex(std::string{pattern})};
+  const auto pcre2_pattern{preprocess_regex<false>(std::string{pattern})};
   if (!pcre2_pattern.has_value()) {
     return std::nullopt;
   }
@@ -115,4 +115,27 @@ auto matches_if_valid(const std::string_view pattern,
   return regex.has_value() && matches(regex.value(), value);
 }
 
+auto is_regex_ecma(const std::string_view pattern) -> bool {
+  const auto pcre2_pattern{preprocess_regex<false>(std::string{pattern})};
+  if (!pcre2_pattern.has_value()) {
+    return false;
+  }
+
+  int pcre2_error_code{0};
+  PCRE2_SIZE pcre2_error_offset{0};
+  pcre2_code *pcre2_regex_raw{pcre2_compile(
+      reinterpret_cast<PCRE2_SPTR>(pcre2_pattern.value().c_str()),
+      pcre2_pattern.value().size(),
+      PCRE2_UTF | PCRE2_UCP | PCRE2_NO_AUTO_CAPTURE | PCRE2_DOTALL |
+          PCRE2_DOLLAR_ENDONLY | PCRE2_NEVER_BACKSLASH_C | PCRE2_NO_UTF_CHECK,
+      &pcre2_error_code, &pcre2_error_offset, nullptr)};
+
+  if (pcre2_regex_raw == nullptr) {
+    return false;
+  }
+
+  pcre2_code_free(pcre2_regex_raw);
+  return true;
+}
+
 } // namespace sourcemeta::core
diff --git a/test/regex/CMakeLists.txt b/test/regex/CMakeLists.txt
index 388b79043..608d44402 100644
--- a/test/regex/CMakeLists.txt
+++ b/test/regex/CMakeLists.txt
@@ -3,6 +3,7 @@ sourcemeta_googletest(NAMESPACE sourcemeta PROJECT core NAME regex
     regex_matches_if_valid_test.cc
     regex_matches_ecma262_test.cc
     regex_matches_rfc9485_test.cc
+    regex_is_ecma_test.cc
     regex_to_regex_test.cc
     regex_test.cc)
 
diff --git a/test/regex/regex_is_ecma_test.cc b/test/regex/regex_is_ecma_test.cc
new file mode 100644
index 000000000..c8a05a419
--- /dev/null
+++ b/test/regex/regex_is_ecma_test.cc
@@ -0,0 +1,305 @@
+#include <gtest/gtest.h>
+
+#include <sourcemeta/core/regex.h>
+
+TEST(Regex_is_ecma, suite_valid_basic) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("([abc])+\\s+$"));
+}
+
+TEST(Regex_is_ecma, suite_invalid_unclosed_paren) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("^(abc]"));
+}
+
+TEST(Regex_is_ecma, suite_invalid_perl_extension_alarm) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\a"));
+}
+
+TEST(Regex_is_ecma, valid_empty) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(""));
+}
+
+TEST(Regex_is_ecma, valid_anchor_start) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^foo"));
+}
+
+TEST(Regex_is_ecma, valid_anchor_end) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo$"));
+}
+
+TEST(Regex_is_ecma, valid_anchor_both) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^foo$"));
+}
+
+TEST(Regex_is_ecma, valid_character_class) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[abc]"));
+}
+
+TEST(Regex_is_ecma, valid_negated_class) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[^abc]"));
+}
+
+TEST(Regex_is_ecma, valid_range_class) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a-z]"));
+}
+
+TEST(Regex_is_ecma, invalid_unclosed_class) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[abc"));
+}
+
+TEST(Regex_is_ecma, valid_digit_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\d"));
+}
+
+TEST(Regex_is_ecma, valid_word_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\w"));
+}
+
+TEST(Regex_is_ecma, valid_space_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\s"));
+}
+
+TEST(Regex_is_ecma, valid_word_boundary) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\bfoo\\b"));
+}
+
+TEST(Regex_is_ecma, valid_newline_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\n"));
+}
+
+TEST(Regex_is_ecma, valid_tab_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\t"));
+}
+
+TEST(Regex_is_ecma, valid_carriage_return_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\r"));
+}
+
+TEST(Regex_is_ecma, valid_form_feed_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\f"));
+}
+
+TEST(Regex_is_ecma, valid_vertical_tab_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\v"));
+}
+
+TEST(Regex_is_ecma, valid_null_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\0"));
+}
+
+TEST(Regex_is_ecma, valid_hex_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\x41"));
+}
+
+TEST(Regex_is_ecma, valid_unicode_4digit) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\u0041"));
+}
+
+TEST(Regex_is_ecma, valid_unicode_braced) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\u{1F600}"));
+}
+
+TEST(Regex_is_ecma, valid_control_escape) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\cA"));
+}
+
+TEST(Regex_is_ecma, valid_unicode_property) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Letter}"));
+}
+
+TEST(Regex_is_ecma, invalid_alarm_escape) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\a"));
+}
+
+TEST(Regex_is_ecma, invalid_escape_e) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\e"));
+}
+
+TEST(Regex_is_ecma, invalid_escape_h) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\h"));
+}
+
+TEST(Regex_is_ecma, invalid_escape_q) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\q"));
+}
+
+TEST(Regex_is_ecma, valid_quantifier_star) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a*"));
+}
+
+TEST(Regex_is_ecma, valid_quantifier_plus) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a+"));
+}
+
+TEST(Regex_is_ecma, valid_quantifier_optional) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a?"));
+}
+
+TEST(Regex_is_ecma, valid_quantifier_range) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{2,5}"));
+}
+
+TEST(Regex_is_ecma, valid_quantifier_exact) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{3}"));
+}
+
+TEST(Regex_is_ecma, valid_quantifier_open) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{3,}"));
+}
+
+TEST(Regex_is_ecma, invalid_quantifier_reversed) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("a{5,2}"));
+}
+
+TEST(Regex_is_ecma, invalid_quantifier_no_target) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("+"));
+}
+
+TEST(Regex_is_ecma, valid_group) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(foo)"));
+}
+
+TEST(Regex_is_ecma, valid_non_capturing_group) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?:foo)"));
+}
+
+TEST(Regex_is_ecma, valid_alternation) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo|bar"));
+}
+
+TEST(Regex_is_ecma, invalid_unclosed_group) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(foo"));
+}
+
+TEST(Regex_is_ecma, invalid_unopened_group) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("foo)"));
+}
+
+TEST(Regex_is_ecma, valid_lookahead) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo(?=bar)"));
+}
+
+TEST(Regex_is_ecma, valid_negative_lookahead) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo(?!bar)"));
+}
+
+TEST(Regex_is_ecma, valid_lookbehind) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?<=foo)bar"));
+}
+
+TEST(Regex_is_ecma, valid_negative_lookbehind) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?<!foo)bar"));
+}
+
+TEST(Regex_is_ecma, valid_dot_star) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(".*"));
+}
+
+TEST(Regex_is_ecma, valid_anchored_dot_star) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^.*$"));
+}
+
+TEST(Regex_is_ecma, valid_dot_plus) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(".+"));
+}
+
+TEST(Regex_is_ecma, valid_single_dot) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("."));
+}
+
+TEST(Regex_is_ecma, valid_uuid_pattern) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"));
+}
+
+TEST(Regex_is_ecma, valid_email_loose) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$"));
+}
+
+TEST(Regex_is_ecma, valid_iso_date) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\d{4}-\\d{2}-\\d{2}$"));
+}
+
+TEST(Regex_is_ecma, valid_named_group) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?<name>foo)"));
+}
+
+TEST(Regex_is_ecma, valid_named_backreference) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?<name>foo)\\k<name>"));
+}
+
+TEST(Regex_is_ecma, invalid_python_named_group) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(?P<name>foo)"));
+}
+
+TEST(Regex_is_ecma, invalid_atomic_group) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(?>foo)"));
+}
+
+TEST(Regex_is_ecma, invalid_inline_option_group) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(?i)foo"));
+}
+
+TEST(Regex_is_ecma, invalid_inline_option_scoped) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(?i:foo)"));
+}
+
+TEST(Regex_is_ecma, invalid_branch_reset_group) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(?|a|b)"));
+}
+
+TEST(Regex_is_ecma, invalid_conditional_group) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(?(1)yes|no)"));
+}
+
+TEST(Regex_is_ecma, invalid_subroutine_call) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(?&name)"));
+}
+
+TEST(Regex_is_ecma, invalid_recursion) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(?R)"));
+}
+
+TEST(Regex_is_ecma, invalid_backreference_uppercase_k) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("foo\\Kbar"));
+}
+
+TEST(Regex_is_ecma, invalid_line_break_escape) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\R"));
+}
+
+TEST(Regex_is_ecma, invalid_quote_sequence) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\Qfoo\\E"));
+}
+
+TEST(Regex_is_ecma, invalid_posix_class_alpha) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[[:alpha:]]"));
+}
+
+TEST(Regex_is_ecma, invalid_possessive_quantifier) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("a*+"));
+}
+
+TEST(Regex_is_ecma, invalid_backtracking_control) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(*FAIL)"));
+}
+
+TEST(Regex_is_ecma, invalid_perl_g_backreference) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(foo)\\g{1}"));
+}
+
+TEST(Regex_is_ecma, valid_literal_open_bracket_colon_in_class) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[:abc]"));
+}
+
+TEST(Regex_is_ecma, valid_literal_colon_inside_class) {
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a:b]"));
+}
+
+TEST(Regex_is_ecma, invalid_unterminated_named_backreference) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\k<name"));
+}
+
+TEST(Regex_is_ecma, invalid_empty_named_backreference) {
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\k<>"));
+}
diff --git a/test/regex/regex_matches_ecma262_test.cc b/test/regex/regex_matches_ecma262_test.cc
index c16d62aa0..c5c3bd65f 100644
--- a/test/regex/regex_matches_ecma262_test.cc
+++ b/test/regex/regex_matches_ecma262_test.cc
@@ -7,6 +7,7 @@
 TEST(Regex_matches, ecma262_anchor_start) {
   const auto regex{sourcemeta::core::to_regex("^foo")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "barfoo"));
@@ -15,6 +16,7 @@ TEST(Regex_matches, ecma262_anchor_start) {
 TEST(Regex_matches, ecma262_anchor_end) {
   const auto regex{sourcemeta::core::to_regex("foo$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "barfoo"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foobar"));
@@ -23,6 +25,7 @@ TEST(Regex_matches, ecma262_anchor_end) {
 TEST(Regex_matches, ecma262_anchor_both) {
   const auto regex{sourcemeta::core::to_regex("^foo$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^foo$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "barfoo"));
@@ -31,6 +34,7 @@ TEST(Regex_matches, ecma262_anchor_both) {
 TEST(Regex_matches, ecma262_anchor_start_with_alternation) {
   const auto regex{sourcemeta::core::to_regex("^(foo|bar)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^(foo|bar)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "baz"));
@@ -39,6 +43,7 @@ TEST(Regex_matches, ecma262_anchor_start_with_alternation) {
 TEST(Regex_matches, ecma262_digit_escape) {
   const auto regex{sourcemeta::core::to_regex("\\d+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\d+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
@@ -48,6 +53,7 @@ TEST(Regex_matches, ecma262_digit_escape) {
 TEST(Regex_matches, ecma262_non_digit_escape) {
   const auto regex{sourcemeta::core::to_regex("\\D+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\D+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "123"));
@@ -56,6 +62,7 @@ TEST(Regex_matches, ecma262_non_digit_escape) {
 TEST(Regex_matches, ecma262_word_escape) {
   const auto regex{sourcemeta::core::to_regex("\\w+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\w+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ABC"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
@@ -66,6 +73,7 @@ TEST(Regex_matches, ecma262_word_escape) {
 TEST(Regex_matches, ecma262_non_word_escape) {
   const auto regex{sourcemeta::core::to_regex("\\W+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\W+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!!!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "   "));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
@@ -74,6 +82,7 @@ TEST(Regex_matches, ecma262_non_word_escape) {
 TEST(Regex_matches, ecma262_whitespace_escape) {
   const auto regex{sourcemeta::core::to_regex("\\s+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\s+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\n"));
@@ -84,6 +93,7 @@ TEST(Regex_matches, ecma262_whitespace_escape) {
 TEST(Regex_matches, ecma262_non_whitespace_escape) {
   const auto regex{sourcemeta::core::to_regex("\\S+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\S+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "   "));
@@ -92,6 +102,7 @@ TEST(Regex_matches, ecma262_non_whitespace_escape) {
 TEST(Regex_matches, ecma262_word_boundary_start) {
   const auto regex{sourcemeta::core::to_regex("\\bfoo")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\bfoo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo bar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " foo"));
@@ -101,6 +112,7 @@ TEST(Regex_matches, ecma262_word_boundary_start) {
 TEST(Regex_matches, ecma262_word_boundary_end) {
   const auto regex{sourcemeta::core::to_regex("foo\\b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo\\b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bar foo"));
@@ -110,6 +122,7 @@ TEST(Regex_matches, ecma262_word_boundary_end) {
 TEST(Regex_matches, ecma262_word_boundary_both) {
   const auto regex{sourcemeta::core::to_regex("\\bfoo\\b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\bfoo\\b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo bar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bar foo baz"));
@@ -119,6 +132,7 @@ TEST(Regex_matches, ecma262_word_boundary_both) {
 TEST(Regex_matches, ecma262_non_word_boundary) {
   const auto regex{sourcemeta::core::to_regex("\\Boo")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\Boo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "oo"));
 }
@@ -126,6 +140,7 @@ TEST(Regex_matches, ecma262_non_word_boundary) {
 TEST(Regex_matches, ecma262_hex_escape_2digit) {
   const auto regex{sourcemeta::core::to_regex("\\x41")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\x41"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "B"));
 }
@@ -133,6 +148,7 @@ TEST(Regex_matches, ecma262_hex_escape_2digit) {
 TEST(Regex_matches, ecma262_hex_escape_in_pattern) {
   const auto regex{sourcemeta::core::to_regex("a\\x20b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\x20b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -140,6 +156,7 @@ TEST(Regex_matches, ecma262_hex_escape_in_pattern) {
 TEST(Regex_matches, ecma262_unicode_escape_4digit) {
   const auto regex{sourcemeta::core::to_regex("\\u0041")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\u0041"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "B"));
 }
@@ -147,6 +164,7 @@ TEST(Regex_matches, ecma262_unicode_escape_4digit) {
 TEST(Regex_matches, ecma262_unicode_escape_brace) {
   const auto regex{sourcemeta::core::to_regex("\\u{1F600}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\u{1F600}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "😀"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
 }
@@ -154,6 +172,7 @@ TEST(Regex_matches, ecma262_unicode_escape_brace) {
 TEST(Regex_matches, ecma262_null_escape) {
   const auto regex{sourcemeta::core::to_regex("a\\0b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\0b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string("a\0b", 3)));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -161,6 +180,7 @@ TEST(Regex_matches, ecma262_null_escape) {
 TEST(Regex_matches, ecma262_non_capturing_group) {
   const auto regex{sourcemeta::core::to_regex("(?:abc)+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?:abc)+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abcabc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
@@ -169,6 +189,7 @@ TEST(Regex_matches, ecma262_non_capturing_group) {
 TEST(Regex_matches, ecma262_lookahead_positive) {
   const auto regex{sourcemeta::core::to_regex("foo(?=bar)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo(?=bar)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foobaz"));
 }
@@ -176,6 +197,7 @@ TEST(Regex_matches, ecma262_lookahead_positive) {
 TEST(Regex_matches, ecma262_lookahead_negative) {
   const auto regex{sourcemeta::core::to_regex("foo(?!bar)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo(?!bar)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobaz"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foobar"));
 }
@@ -183,6 +205,7 @@ TEST(Regex_matches, ecma262_lookahead_negative) {
 TEST(Regex_matches, ecma262_lookbehind_positive) {
   const auto regex{sourcemeta::core::to_regex("(?<=foo)bar")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?<=foo)bar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "bazbar"));
 }
@@ -190,6 +213,7 @@ TEST(Regex_matches, ecma262_lookbehind_positive) {
 TEST(Regex_matches, ecma262_lookbehind_negative) {
   const auto regex{sourcemeta::core::to_regex("(?<!foo)bar")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?<!foo)bar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bazbar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foobar"));
 }
@@ -197,6 +221,7 @@ TEST(Regex_matches, ecma262_lookbehind_negative) {
 TEST(Regex_matches, ecma262_combined_digit_word_anchors) {
   const auto regex{sourcemeta::core::to_regex("^\\w+@\\w+\\.\\w+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\w+@\\w+\\.\\w+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "user@example.com"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "invalid"));
 }
@@ -204,6 +229,7 @@ TEST(Regex_matches, ecma262_combined_digit_word_anchors) {
 TEST(Regex_matches, ecma262_digit_range_pattern) {
   const auto regex{sourcemeta::core::to_regex("\\d{3}-\\d{2}-\\d{4}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\d{3}-\\d{2}-\\d{4}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123-45-6789"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc-de-fghi"));
 }
@@ -211,6 +237,7 @@ TEST(Regex_matches, ecma262_digit_range_pattern) {
 TEST(Regex_matches, ecma262_mixed_escapes) {
   const auto regex{sourcemeta::core::to_regex("\\w+\\s+\\d+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\w+\\s+\\d+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "hello 123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test  456"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "hello"));
@@ -219,6 +246,7 @@ TEST(Regex_matches, ecma262_mixed_escapes) {
 TEST(Regex_matches, ecma262_anchor_with_digit) {
   const auto regex{sourcemeta::core::to_regex("^\\d+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\d+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "123abc"));
@@ -227,6 +255,7 @@ TEST(Regex_matches, ecma262_anchor_with_digit) {
 TEST(Regex_matches, ecma262_word_boundary_with_digit) {
   const auto regex{sourcemeta::core::to_regex("\\b\\d{3}\\b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\b\\d{3}\\b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc 123 def"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "1234"));
@@ -235,6 +264,7 @@ TEST(Regex_matches, ecma262_word_boundary_with_digit) {
 TEST(Regex_matches, ecma262_whitespace_variants) {
   const auto regex{sourcemeta::core::to_regex("a\\sb")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\sb"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\tb"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\nb"));
@@ -246,6 +276,8 @@ TEST(Regex_matches, ecma262_complex_email_pattern) {
   const auto regex{
       sourcemeta::core::to_regex("^[\\w.+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("^[\\w.+-]+@[\\w.-]+\\.[a-zA-Z]{2,}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "user@example.com"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(),
                                         "test.user+tag@sub.example.org"));
@@ -256,6 +288,8 @@ TEST(Regex_matches, ecma262_complex_url_pattern) {
   const auto regex{
       sourcemeta::core::to_regex("^https?://[\\w.-]+\\.[a-z]{2,}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("^https?://[\\w.-]+\\.[a-z]{2,}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "http://example.com"));
   EXPECT_TRUE(
       sourcemeta::core::matches(regex.value(), "https://sub.example.org"));
@@ -266,6 +300,8 @@ TEST(Regex_matches, ecma262_phone_number_pattern) {
   const auto regex{
       sourcemeta::core::to_regex("^\\(\\d{3}\\)\\s*\\d{3}-\\d{4}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("^\\(\\d{3}\\)\\s*\\d{3}-\\d{4}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "(123) 456-7890"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "(123)456-7890"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "123-456-7890"));
@@ -274,6 +310,7 @@ TEST(Regex_matches, ecma262_phone_number_pattern) {
 TEST(Regex_matches, ecma262_hex_color_with_anchor) {
   const auto regex{sourcemeta::core::to_regex("^#[0-9a-fA-F]{6}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^#[0-9a-fA-F]{6}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "#FF5733"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "#000000"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "#FF57"));
@@ -282,6 +319,7 @@ TEST(Regex_matches, ecma262_hex_color_with_anchor) {
 TEST(Regex_matches, ecma262_non_capturing_with_alternation) {
   const auto regex{sourcemeta::core::to_regex("(?:red|green|blue)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?:red|green|blue)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "red"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "green"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "blue"));
@@ -291,6 +329,7 @@ TEST(Regex_matches, ecma262_non_capturing_with_alternation) {
 TEST(Regex_matches, ecma262_lookahead_with_quantifier) {
   const auto regex{sourcemeta::core::to_regex("\\d+(?=px)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\d+(?=px)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "100px"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "50px"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "100em"));
@@ -299,6 +338,7 @@ TEST(Regex_matches, ecma262_lookahead_with_quantifier) {
 TEST(Regex_matches, ecma262_multiple_word_boundaries) {
   const auto regex{sourcemeta::core::to_regex("\\btest\\b.*\\bcase\\b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\btest\\b.*\\bcase\\b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test case"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test this case"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "testing cases"));
@@ -307,6 +347,7 @@ TEST(Regex_matches, ecma262_multiple_word_boundaries) {
 TEST(Regex_matches, ecma262_unicode_with_anchors) {
   const auto regex{sourcemeta::core::to_regex("^\\u{1F600}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\u{1F600}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "😀"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "😀😀"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A😀"));
@@ -315,6 +356,7 @@ TEST(Regex_matches, ecma262_unicode_with_anchors) {
 TEST(Regex_matches, ecma262_word_ascii_only_in_charclass) {
   const auto regex{sourcemeta::core::to_regex("^[\\w.-]+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[\\w.-]+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "hello-world"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test.file"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "café"));
@@ -323,6 +365,7 @@ TEST(Regex_matches, ecma262_word_ascii_only_in_charclass) {
 TEST(Regex_matches, ecma262_digit_ascii_only_in_charclass) {
   const auto regex{sourcemeta::core::to_regex("^[\\d.-]+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[\\d.-]+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123-456"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\u07C0"));
 }
@@ -330,6 +373,7 @@ TEST(Regex_matches, ecma262_digit_ascii_only_in_charclass) {
 TEST(Regex_matches, ecma262_whitespace_in_charclass) {
   const auto regex{sourcemeta::core::to_regex("^[\\s]+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[\\s]+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " \t\n"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -337,6 +381,7 @@ TEST(Regex_matches, ecma262_whitespace_in_charclass) {
 TEST(Regex_matches, ecma262_dollar_anchor_no_trailing_newline) {
   const auto regex{sourcemeta::core::to_regex("^abc$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^abc$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc\n"));
 }
@@ -344,6 +389,7 @@ TEST(Regex_matches, ecma262_dollar_anchor_no_trailing_newline) {
 TEST(Regex_matches, ecma262_tab_escape) {
   const auto regex{sourcemeta::core::to_regex("^\\t$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\t$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\\t"));
 }
@@ -351,6 +397,7 @@ TEST(Regex_matches, ecma262_tab_escape) {
 TEST(Regex_matches, ecma262_control_escape_upper) {
   const auto regex{sourcemeta::core::to_regex("^\\cC$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\cC$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0003"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\\cC"));
 }
@@ -358,6 +405,7 @@ TEST(Regex_matches, ecma262_control_escape_upper) {
 TEST(Regex_matches, ecma262_control_escape_lower) {
   const auto regex{sourcemeta::core::to_regex("^\\cc$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\cc$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0003"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\\cc"));
 }
@@ -365,6 +413,7 @@ TEST(Regex_matches, ecma262_control_escape_lower) {
 TEST(Regex_matches, ecma262_whitespace_unicode_nbsp) {
   const auto regex{sourcemeta::core::to_regex("^\\s$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\s$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u000b"));
@@ -381,6 +430,7 @@ TEST(Regex_matches, ecma262_whitespace_unicode_nbsp) {
 TEST(Regex_matches, ecma262_non_whitespace_unicode) {
   const auto regex{sourcemeta::core::to_regex("^\\S$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\S$"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\u000b"));
@@ -397,6 +447,7 @@ TEST(Regex_matches, ecma262_non_whitespace_unicode) {
 TEST(Regex_matches, ecma262_digit_not_bengali) {
   const auto regex{sourcemeta::core::to_regex("^\\d+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\d+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "42"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "-%#"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "৪২"));
@@ -405,6 +456,7 @@ TEST(Regex_matches, ecma262_digit_not_bengali) {
 TEST(Regex_matches, ecma262_unicode_digit_property) {
   const auto regex{sourcemeta::core::to_regex("^\\p{Nd}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{Nd}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "42"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "-%#"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "৪২"));
@@ -413,6 +465,7 @@ TEST(Regex_matches, ecma262_unicode_digit_property) {
 TEST(Regex_matches, ecma262_unicode_digit_property_lowercase) {
   const auto regex{sourcemeta::core::to_regex("^\\p{digit}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{digit}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "42"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "-%#"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "৪২"));
@@ -421,6 +474,7 @@ TEST(Regex_matches, ecma262_unicode_digit_property_lowercase) {
 TEST(Regex_matches, ecma262_unicode_space_property_lowercase) {
   const auto regex{sourcemeta::core::to_regex("^\\p{space}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{space}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " \t"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -428,6 +482,7 @@ TEST(Regex_matches, ecma262_unicode_space_property_lowercase) {
 TEST(Regex_matches, ecma262_unicode_ASCII_property) {
   const auto regex{sourcemeta::core::to_regex("^\\p{ASCII}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{ASCII}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc123"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "café"));
 }
@@ -435,6 +490,7 @@ TEST(Regex_matches, ecma262_unicode_ASCII_property) {
 TEST(Regex_matches, ecma262_unicode_Hex_Digit_property) {
   const auto regex{sourcemeta::core::to_regex("^\\p{Hex_Digit}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{Hex_Digit}+$"));
   EXPECT_TRUE(
       sourcemeta::core::matches(regex.value(), "0123456789abcdefABCDEF"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "xyz"));
@@ -443,6 +499,7 @@ TEST(Regex_matches, ecma262_unicode_Hex_Digit_property) {
 TEST(Regex_matches, ecma262_unicode_Alphabetic_property) {
   const auto regex{sourcemeta::core::to_regex("^\\p{Alphabetic}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{Alphabetic}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ABC"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "123"));
@@ -451,6 +508,7 @@ TEST(Regex_matches, ecma262_unicode_Alphabetic_property) {
 TEST(Regex_matches, ecma262_unicode_White_Space_property) {
   const auto regex{sourcemeta::core::to_regex("^\\p{White_Space}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{White_Space}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " \t\n"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -458,6 +516,7 @@ TEST(Regex_matches, ecma262_unicode_White_Space_property) {
 TEST(Regex_matches, ecma262_escaped_backslash_before_charclass) {
   const auto regex{sourcemeta::core::to_regex("\\\\[abc]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\[abc]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\c"));
@@ -468,6 +527,7 @@ TEST(Regex_matches, ecma262_escaped_backslash_before_charclass) {
 TEST(Regex_matches, ecma262_escaped_backslash_before_digit_class) {
   const auto regex{sourcemeta::core::to_regex("\\\\d")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\d"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\d"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
 }
@@ -475,6 +535,7 @@ TEST(Regex_matches, ecma262_escaped_backslash_before_digit_class) {
 TEST(Regex_matches, ecma262_digit_hyphen_in_charclass) {
   const auto regex{sourcemeta::core::to_regex("^[\\d-]+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[\\d-]+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "1-2-3"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "---"));
@@ -485,6 +546,7 @@ TEST(Regex_matches, ecma262_digit_hyphen_in_charclass) {
 TEST(Regex_matches, ecma262_word_boundary_ascii_only) {
   const auto regex{sourcemeta::core::to_regex("\\bcafé\\b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\bcafé\\b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "café"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "bon café"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "café123"));
@@ -493,6 +555,7 @@ TEST(Regex_matches, ecma262_word_boundary_ascii_only) {
 TEST(Regex_matches, ecma262_non_greedy_quantifiers) {
   const auto regex{sourcemeta::core::to_regex("^a+?b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^a+?b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaab"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -501,6 +564,7 @@ TEST(Regex_matches, ecma262_non_greedy_quantifiers) {
 TEST(Regex_matches, ecma262_quantifier_exact) {
   const auto regex{sourcemeta::core::to_regex("^a{3}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^a{3}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaa"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "aa"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "aaaa"));
@@ -509,6 +573,7 @@ TEST(Regex_matches, ecma262_quantifier_exact) {
 TEST(Regex_matches, ecma262_quantifier_range) {
   const auto regex{sourcemeta::core::to_regex("^a{2,4}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^a{2,4}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaaa"));
@@ -519,6 +584,7 @@ TEST(Regex_matches, ecma262_quantifier_range) {
 TEST(Regex_matches, ecma262_quantifier_min_only) {
   const auto regex{sourcemeta::core::to_regex("^a{2,}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^a{2,}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaaaaa"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -527,6 +593,7 @@ TEST(Regex_matches, ecma262_quantifier_min_only) {
 TEST(Regex_matches, ecma262_negated_charclass) {
   const auto regex{sourcemeta::core::to_regex("^[^abc]+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[^abc]+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xyz"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
@@ -536,6 +603,7 @@ TEST(Regex_matches, ecma262_negated_charclass) {
 TEST(Regex_matches, ecma262_escaped_metacharacters) {
   const auto regex{sourcemeta::core::to_regex("^\\.\\.\\.$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\.\\.\\.$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "..."));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -543,6 +611,7 @@ TEST(Regex_matches, ecma262_escaped_metacharacters) {
 TEST(Regex_matches, ecma262_hex_escape_hi) {
   const auto regex{sourcemeta::core::to_regex("^\\x48\\x69$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\x48\\x69$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Hi"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\\x48\\x69"));
 }
@@ -550,6 +619,7 @@ TEST(Regex_matches, ecma262_hex_escape_hi) {
 TEST(Regex_matches, ecma262_unicode_property_letter_all) {
   const auto regex{sourcemeta::core::to_regex("^\\p{L}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{L}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ABC"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "café"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "中文"));
@@ -559,6 +629,7 @@ TEST(Regex_matches, ecma262_unicode_property_letter_all) {
 TEST(Regex_matches, ecma262_unicode_property_letter_uppercase) {
   const auto regex{sourcemeta::core::to_regex("^\\p{Lu}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{Lu}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ABC"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "Abc"));
@@ -567,6 +638,7 @@ TEST(Regex_matches, ecma262_unicode_property_letter_uppercase) {
 TEST(Regex_matches, ecma262_unicode_property_letter_lowercase) {
   const auto regex{sourcemeta::core::to_regex("^\\p{Ll}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{Ll}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ABC"));
 }
@@ -574,6 +646,7 @@ TEST(Regex_matches, ecma262_unicode_property_letter_lowercase) {
 TEST(Regex_matches, ecma262_unicode_property_mark) {
   const auto regex{sourcemeta::core::to_regex("\\p{M}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{M}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\u0301"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "é"));
 }
@@ -581,6 +654,7 @@ TEST(Regex_matches, ecma262_unicode_property_mark) {
 TEST(Regex_matches, ecma262_unicode_property_number) {
   const auto regex{sourcemeta::core::to_regex("^\\p{N}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{N}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "৪২"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
@@ -589,6 +663,7 @@ TEST(Regex_matches, ecma262_unicode_property_number) {
 TEST(Regex_matches, ecma262_unicode_property_punctuation) {
   const auto regex{sourcemeta::core::to_regex("^\\p{P}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\p{P}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!.,;"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -596,6 +671,7 @@ TEST(Regex_matches, ecma262_unicode_property_punctuation) {
 TEST(Regex_matches, ecma262_unicode_property_symbol) {
   const auto regex{sourcemeta::core::to_regex("\\p{S}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{S}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "€"));
@@ -604,6 +680,7 @@ TEST(Regex_matches, ecma262_unicode_property_symbol) {
 TEST(Regex_matches, ecma262_unicode_property_separator) {
   const auto regex{sourcemeta::core::to_regex("\\p{Z}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Z}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u00A0"));
 }
@@ -611,6 +688,7 @@ TEST(Regex_matches, ecma262_unicode_property_separator) {
 TEST(Regex_matches, ecma262_unicode_property_other) {
   const auto regex{sourcemeta::core::to_regex("\\p{C}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{C}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string(1, '\0')));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0001"));
 }
@@ -618,6 +696,7 @@ TEST(Regex_matches, ecma262_unicode_property_other) {
 TEST(Regex_matches, ecma262_unicode_property_negated_letter) {
   const auto regex{sourcemeta::core::to_regex("^\\P{L}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\P{L}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!@#"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
@@ -626,6 +705,7 @@ TEST(Regex_matches, ecma262_unicode_property_negated_letter) {
 TEST(Regex_matches, ecma262_unicode_property_negated_number) {
   const auto regex{sourcemeta::core::to_regex("^\\P{N}+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\P{N}+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "৪২"));
@@ -634,6 +714,7 @@ TEST(Regex_matches, ecma262_unicode_property_negated_number) {
 TEST(Regex_matches, ecma262_quantifier_star_any_string) {
   const auto regex{sourcemeta::core::to_regex(".*")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(".*"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
 }
@@ -641,6 +722,7 @@ TEST(Regex_matches, ecma262_quantifier_star_any_string) {
 TEST(Regex_matches, ecma262_quantifier_plus_non_empty) {
   const auto regex{sourcemeta::core::to_regex(".+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(".+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), ""));
 }
@@ -648,18 +730,21 @@ TEST(Regex_matches, ecma262_quantifier_plus_non_empty) {
 TEST(Regex_matches, ecma262_dot_matches_newline) {
   const auto regex{sourcemeta::core::to_regex(".")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("."));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\n"));
 }
 
 TEST(Regex_matches, ecma262_dot_matches_carriage_return) {
   const auto regex{sourcemeta::core::to_regex(".")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("."));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\r"));
 }
 
 TEST(Regex_matches, ecma262_unicode_range_4byte_deseret) {
   const auto regex{sourcemeta::core::to_regex("[\\u{10400}-\\u{1044F}]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\u{10400}-\\u{1044F}]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\U00010400"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\U0001044F"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -668,6 +753,7 @@ TEST(Regex_matches, ecma262_unicode_range_4byte_deseret) {
 TEST(Regex_matches, ecma262_anchor_start_prefix_match) {
   const auto regex{sourcemeta::core::to_regex("^foo")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "bar"));
 }
@@ -675,18 +761,21 @@ TEST(Regex_matches, ecma262_anchor_start_prefix_match) {
 TEST(Regex_matches, ecma262_anchor_both_full_match) {
   const auto regex{sourcemeta::core::to_regex("^.*$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^.*$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
 }
 
 TEST(Regex_matches, ecma262_anchor_both_with_group) {
   const auto regex{sourcemeta::core::to_regex("^(.*)$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^(.*)$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
 }
 
 TEST(Regex_matches, ecma262_anchor_start_slash_path) {
   const auto regex{sourcemeta::core::to_regex("^/.*")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^/.*"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "/foo/bar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "/"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foo/bar"));
@@ -695,6 +784,7 @@ TEST(Regex_matches, ecma262_anchor_start_slash_path) {
 TEST(Regex_matches, ecma262_anchor_both_length_range) {
   const auto regex{sourcemeta::core::to_regex("^.{1,256}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^.{1,256}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "f"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string(256, 'x')));
@@ -704,6 +794,7 @@ TEST(Regex_matches, ecma262_anchor_both_length_range) {
 TEST(Regex_matches, ecma262_anchor_start_at_sign) {
   const auto regex{sourcemeta::core::to_regex("^@")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^@"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "@foo"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foo"));
 }
@@ -711,6 +802,7 @@ TEST(Regex_matches, ecma262_anchor_start_at_sign) {
 TEST(Regex_matches, ecma262_anchor_end_letter_o) {
   const auto regex{sourcemeta::core::to_regex("o$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("o$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "bar"));
 }
@@ -718,6 +810,7 @@ TEST(Regex_matches, ecma262_anchor_end_letter_o) {
 TEST(Regex_matches, ecma262_anchor_both_identifier_pattern) {
   const auto regex{sourcemeta::core::to_regex("^[a-z][a-z0-9-_]{1,63}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[a-z][a-z0-9-_]{1,63}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abcd"));
 }
 
@@ -725,18 +818,22 @@ TEST(Regex_matches, ecma262_anchor_both_package_name) {
   const auto regex{
       sourcemeta::core::to_regex("^(?:@[0-9a-z-_.]+\\/)?[a-z][0-9a-z-_.]*$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "^(?:@[0-9a-z-_.]+\\/)?[a-z][0-9a-z-_.]*$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "@namespace/mypackage"));
 }
 
 TEST(Regex_matches, ecma262_anchor_both_multiline_string) {
   const auto regex{sourcemeta::core::to_regex("^.+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^.+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo\nbar\r"));
 }
 
 TEST(Regex_matches, ecma262_unicode_escape_4digit_arabic_digit_range) {
   const auto regex{sourcemeta::core::to_regex("[\\u0660-\\u0669]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\u0660-\\u0669]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0660"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0669"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -746,6 +843,8 @@ TEST(Regex_matches, ecma262_unicode_property_letter_identifier) {
   const auto regex{
       sourcemeta::core::to_regex("^\\p{Letter}[\\p{Letter}\\p{Number}]*$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "^\\p{Letter}[\\p{Letter}\\p{Number}]*$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "hello"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "hello123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Àlement"));
@@ -758,6 +857,8 @@ TEST(Regex_matches, ecma262_unicode_property_negative_lookahead_identifier) {
   const auto regex{sourcemeta::core::to_regex(
       "^(?!\\p{Number})\\p{Letter}[\\p{Letter}\\p{Number}\\-_.]*$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "^(?!\\p{Number})\\p{Letter}[\\p{Letter}\\p{Number}\\-_.]*$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "element123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "element٠"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "٠element"));
@@ -767,6 +868,7 @@ TEST(Regex_matches, ecma262_unicode_property_negative_lookahead_identifier) {
 TEST(Regex_matches, ecma262_unicode_dot_single_codepoint) {
   const auto regex{sourcemeta::core::to_regex("^.$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^.$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "À"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "中"));
@@ -776,6 +878,7 @@ TEST(Regex_matches, ecma262_unicode_dot_single_codepoint) {
 TEST(Regex_matches, ecma262_unicode_quantifier_three_codepoints) {
   const auto regex{sourcemeta::core::to_regex("^.{3}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^.{3}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ABC"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ÀÁÂ"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "中文字"));
@@ -786,6 +889,7 @@ TEST(Regex_matches, ecma262_unicode_quantifier_three_codepoints) {
 TEST(Regex_matches, ecma262_digit_class_ascii_only) {
   const auto regex{sourcemeta::core::to_regex("^\\d$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\d$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\u07C0"));
 }
@@ -793,6 +897,7 @@ TEST(Regex_matches, ecma262_digit_class_ascii_only) {
 TEST(Regex_matches, ecma262_word_class_ascii_only) {
   const auto regex{sourcemeta::core::to_regex("^\\w$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\\w$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "é"));
 }
@@ -800,6 +905,7 @@ TEST(Regex_matches, ecma262_word_class_ascii_only) {
 TEST(Regex_matches, ecma262_nonbmp_emoji_quantifier_codepoint) {
   const auto regex{sourcemeta::core::to_regex("^\U0001F432*$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\U0001F432*$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\U0001F432"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\U0001F432\U0001F432"));
@@ -810,6 +916,7 @@ TEST(Regex_matches, ecma262_nonbmp_emoji_quantifier_codepoint) {
 TEST(Regex_matches, ecma262_nonbmp_literal_exact_match) {
   const auto regex{sourcemeta::core::to_regex("^\U0001F432$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^\U0001F432$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\U0001F432"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\U0001F409"));
   EXPECT_FALSE(
@@ -820,6 +927,8 @@ TEST(Regex_matches, ecma262_xml_ncname_unicode_identifier) {
   const auto regex{sourcemeta::core::to_regex(
       "^(?![:\\p{Nd}])[\\p{L}_][\\p{L}\\p{Nd}\\-._·]*$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "^(?![:\\p{Nd}])[\\p{L}_][\\p{L}\\p{Nd}\\-._·]*$"));
 
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "element"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_element"));
@@ -836,6 +945,7 @@ TEST(Regex_matches, ecma262_xml_ncname_unicode_identifier) {
 TEST(Regex_matches, ecma262_escaped_backslash_before_bracket) {
   const auto regex{sourcemeta::core::to_regex("\\\\[abc]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\[abc]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\c"));
@@ -846,6 +956,7 @@ TEST(Regex_matches, ecma262_escaped_backslash_before_bracket) {
 TEST(Regex_matches, ecma262_triple_backslash_before_bracket) {
   const auto regex{sourcemeta::core::to_regex("\\\\\\[")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\\\["));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\["));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\\a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "["));
@@ -854,6 +965,7 @@ TEST(Regex_matches, ecma262_triple_backslash_before_bracket) {
 TEST(Regex_matches, ecma262_dollar_in_middle_never_matches) {
   const auto regex{sourcemeta::core::to_regex("foo$bar")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo$bar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foo$bar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "foo"));
@@ -862,6 +974,7 @@ TEST(Regex_matches, ecma262_dollar_in_middle_never_matches) {
 TEST(Regex_matches, ecma262_dollar_in_character_class) {
   const auto regex{sourcemeta::core::to_regex("[$]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[$]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "$"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -869,6 +982,7 @@ TEST(Regex_matches, ecma262_dollar_in_character_class) {
 TEST(Regex_matches, ecma262_escaped_dollar) {
   const auto regex{sourcemeta::core::to_regex("\\$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "$"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -876,6 +990,7 @@ TEST(Regex_matches, ecma262_escaped_dollar) {
 TEST(Regex_matches, ecma262_multiple_dollars) {
   const auto regex{sourcemeta::core::to_regex("$$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("$$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "anything"));
 }
@@ -883,6 +998,7 @@ TEST(Regex_matches, ecma262_multiple_dollars) {
 TEST(Regex_matches, ecma262_negated_digit_in_char_class) {
   const auto regex{sourcemeta::core::to_regex("[\\D]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\D]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
@@ -892,6 +1008,7 @@ TEST(Regex_matches, ecma262_negated_digit_in_char_class) {
 TEST(Regex_matches, ecma262_negated_word_in_char_class) {
   const auto regex{sourcemeta::core::to_regex("[\\W]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\W]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "@"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
@@ -903,6 +1020,7 @@ TEST(Regex_matches, ecma262_negated_word_in_char_class) {
 TEST(Regex_matches, ecma262_negated_space_in_char_class) {
   const auto regex{sourcemeta::core::to_regex("[\\S]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\S]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
@@ -914,6 +1032,7 @@ TEST(Regex_matches, ecma262_negated_space_in_char_class) {
 TEST(Regex_matches, ecma262_mixed_escapes_in_char_class) {
   const auto regex{sourcemeta::core::to_regex("[\\d\\D]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\d\\D]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
@@ -923,6 +1042,7 @@ TEST(Regex_matches, ecma262_mixed_escapes_in_char_class) {
 TEST(Regex_matches, ecma262_escaped_bracket_in_char_class) {
   const auto regex{sourcemeta::core::to_regex("[\\]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "["));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -931,6 +1051,7 @@ TEST(Regex_matches, ecma262_escaped_bracket_in_char_class) {
 TEST(Regex_matches, ecma262_backslash_in_char_class) {
   const auto regex{sourcemeta::core::to_regex("[\\\\]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\\\]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -938,6 +1059,7 @@ TEST(Regex_matches, ecma262_backslash_in_char_class) {
 TEST(Regex_matches, ecma262_complex_char_class_with_escaped_chars) {
   const auto regex{sourcemeta::core::to_regex("[a\\]b\\\\c]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a\\]b\\\\c]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
@@ -950,26 +1072,31 @@ TEST(Regex_matches, ecma262_complex_char_class_with_escaped_chars) {
 TEST(Regex_matches, ecma262_empty_char_class) {
   const auto regex{sourcemeta::core::to_regex("[]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[]"));
 }
 
 TEST(Regex_matches, ecma262_incomplete_unicode_property) {
   const auto regex{sourcemeta::core::to_regex("\\p{Letter")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\p{Letter"));
 }
 
 TEST(Regex_matches, ecma262_incomplete_unicode_escape) {
   const auto regex{sourcemeta::core::to_regex("\\u{DEAD")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\u{DEAD"));
 }
 
 TEST(Regex_matches, ecma262_backslash_at_end) {
   const auto regex{sourcemeta::core::to_regex("foo\\")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("foo\\"));
 }
 
 TEST(Regex_matches, ecma262_nested_char_class_attempt) {
   const auto regex{sourcemeta::core::to_regex("[[abc]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[abc]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
@@ -981,6 +1108,7 @@ TEST(Regex_matches, ecma262_nested_char_class_attempt) {
 TEST(Regex_matches, ecma262_dollar_before_alternation) {
   const auto regex{sourcemeta::core::to_regex("foo$|bar")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("foo$|bar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foo"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "barxyz"));
@@ -990,6 +1118,7 @@ TEST(Regex_matches, ecma262_dollar_before_alternation) {
 TEST(Regex_matches, ecma262_multiple_backslashes_complex) {
   const auto regex{sourcemeta::core::to_regex("\\\\\\\\\\\\\\\\")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\\\\\\\\\\\\\"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\\\\\\\"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\\\\"));
 }
@@ -997,6 +1126,7 @@ TEST(Regex_matches, ecma262_multiple_backslashes_complex) {
 TEST(Regex_matches, ecma262_right_bracket_as_first_char_in_class) {
   const auto regex{sourcemeta::core::to_regex("[]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "["));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1005,6 +1135,7 @@ TEST(Regex_matches, ecma262_right_bracket_as_first_char_in_class) {
 TEST(Regex_matches, ecma262_right_bracket_negated_class) {
   const auto regex{sourcemeta::core::to_regex("[^]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[^]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "["));
@@ -1013,6 +1144,7 @@ TEST(Regex_matches, ecma262_right_bracket_negated_class) {
 TEST(Regex_matches, ecma262_dollar_before_opening_paren) {
   const auto regex{sourcemeta::core::to_regex("$(abc)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("$(abc)"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "$abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -1020,6 +1152,7 @@ TEST(Regex_matches, ecma262_dollar_before_opening_paren) {
 TEST(Regex_matches, ecma262_caret_not_at_start_of_class) {
   const auto regex{sourcemeta::core::to_regex("[a^b]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a^b]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "^"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
@@ -1029,6 +1162,7 @@ TEST(Regex_matches, ecma262_caret_not_at_start_of_class) {
 TEST(Regex_matches, ecma262_caret_in_middle_of_pattern) {
   const auto regex{sourcemeta::core::to_regex("a^b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a^b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a^b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1037,6 +1171,7 @@ TEST(Regex_matches, ecma262_caret_in_middle_of_pattern) {
 TEST(Regex_matches, ecma262_backslash_before_digit_escape) {
   const auto regex{sourcemeta::core::to_regex("\\\\\\d")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\\\d"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -1045,6 +1180,7 @@ TEST(Regex_matches, ecma262_backslash_before_digit_escape) {
 TEST(Regex_matches, ecma262_dash_at_end_of_class) {
   const auto regex{sourcemeta::core::to_regex("[abc-]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[abc-]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "d"));
@@ -1053,6 +1189,7 @@ TEST(Regex_matches, ecma262_dash_at_end_of_class) {
 TEST(Regex_matches, ecma262_dash_at_start_of_class) {
   const auto regex{sourcemeta::core::to_regex("[-abc]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[-abc]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "d"));
@@ -1061,6 +1198,7 @@ TEST(Regex_matches, ecma262_dash_at_start_of_class) {
 TEST(Regex_matches, ecma262_double_caret) {
   const auto regex{sourcemeta::core::to_regex("^^abc")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^^abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abcdef"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "^abc"));
@@ -1070,6 +1208,7 @@ TEST(Regex_matches, ecma262_double_caret) {
 TEST(Regex_matches, ecma262_caret_after_alternation) {
   const auto regex{sourcemeta::core::to_regex("a|^b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a|^b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "xb"));
@@ -1078,6 +1217,7 @@ TEST(Regex_matches, ecma262_caret_after_alternation) {
 TEST(Regex_matches, ecma262_caret_after_opening_paren) {
   const auto regex{sourcemeta::core::to_regex("(^abc)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(^abc)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "xabc"));
 }
@@ -1085,6 +1225,7 @@ TEST(Regex_matches, ecma262_caret_after_opening_paren) {
 TEST(Regex_matches, ecma262_dollar_then_caret) {
   const auto regex{sourcemeta::core::to_regex("a$^b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a$^b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a$^b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -1092,6 +1233,7 @@ TEST(Regex_matches, ecma262_dollar_then_caret) {
 TEST(Regex_matches, ecma262_backspace_in_char_class) {
   const auto regex{sourcemeta::core::to_regex("[\\b]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\b]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -1099,6 +1241,7 @@ TEST(Regex_matches, ecma262_backspace_in_char_class) {
 TEST(Regex_matches, ecma262_whitespace_and_non_whitespace_class) {
   const auto regex{sourcemeta::core::to_regex("[\\s\\S]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\s\\S]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -1108,6 +1251,7 @@ TEST(Regex_matches, ecma262_whitespace_and_non_whitespace_class) {
 TEST(Regex_matches, ecma262_word_boundary_outside_class) {
   const auto regex{sourcemeta::core::to_regex("\\bword\\b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\bword\\b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "word"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " word "));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "sword"));
@@ -1117,21 +1261,25 @@ TEST(Regex_matches, ecma262_word_boundary_outside_class) {
 TEST(Regex_matches, ecma262_unmatched_closing_paren) {
   const auto regex{sourcemeta::core::to_regex("abc)")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("abc)"));
 }
 
 TEST(Regex_matches, ecma262_unmatched_opening_paren) {
   const auto regex{sourcemeta::core::to_regex("(abc")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(abc"));
 }
 
 TEST(Regex_matches, ecma262_quantifier_on_assertion) {
   const auto regex{sourcemeta::core::to_regex("^*")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("^*"));
 }
 
 TEST(Regex_matches, ecma262_escaped_closing_bracket_in_class) {
   const auto regex{sourcemeta::core::to_regex("[a\\]b]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a\\]b]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
@@ -1141,16 +1289,19 @@ TEST(Regex_matches, ecma262_escaped_closing_bracket_in_class) {
 TEST(Regex_matches, ecma262_negated_empty_class) {
   const auto regex{sourcemeta::core::to_regex("[^]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[^]"));
 }
 
 TEST(Regex_matches, ecma262_unicode_hex_too_large) {
   const auto regex{sourcemeta::core::to_regex("\\u{110000}")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("\\u{110000}"));
 }
 
 TEST(Regex_matches, ecma262_multiple_backslashes_before_d) {
   const auto regex{sourcemeta::core::to_regex("\\\\\\\\d")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\\\\\d"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\\\d"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\\\\5"));
 }
@@ -1158,11 +1309,13 @@ TEST(Regex_matches, ecma262_multiple_backslashes_before_d) {
 TEST(Regex_matches, ecma262_backslash_before_closing_bracket) {
   const auto regex{sourcemeta::core::to_regex("[abc\\]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[abc\\]"));
 }
 
 TEST(Regex_matches, ecma262_empty_alternation_branch) {
   const auto regex{sourcemeta::core::to_regex("a||b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a||b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
@@ -1171,6 +1324,7 @@ TEST(Regex_matches, ecma262_empty_alternation_branch) {
 TEST(Regex_matches, ecma262_pipe_at_start) {
   const auto regex{sourcemeta::core::to_regex("|abc")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("|abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
 }
@@ -1178,6 +1332,7 @@ TEST(Regex_matches, ecma262_pipe_at_start) {
 TEST(Regex_matches, ecma262_pipe_at_end) {
   const auto regex{sourcemeta::core::to_regex("abc|")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("abc|"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
 }
@@ -1185,6 +1340,7 @@ TEST(Regex_matches, ecma262_pipe_at_end) {
 TEST(Regex_matches, ecma262_dot_matches_any_except_newline) {
   const auto regex{sourcemeta::core::to_regex("a.b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a.b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "axb"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a5b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a b"));
@@ -1193,6 +1349,7 @@ TEST(Regex_matches, ecma262_dot_matches_any_except_newline) {
 TEST(Regex_matches, ecma262_escaped_dot_in_char_class) {
   const auto regex{sourcemeta::core::to_regex("[.]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[.]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "."));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -1200,6 +1357,7 @@ TEST(Regex_matches, ecma262_escaped_dot_in_char_class) {
 TEST(Regex_matches, ecma262_non_greedy_star) {
   const auto regex{sourcemeta::core::to_regex("a*?")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a*?"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaa"));
@@ -1208,6 +1366,7 @@ TEST(Regex_matches, ecma262_non_greedy_star) {
 TEST(Regex_matches, ecma262_non_greedy_plus) {
   const auto regex{sourcemeta::core::to_regex("a+?")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a+?"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaa"));
@@ -1216,6 +1375,7 @@ TEST(Regex_matches, ecma262_non_greedy_plus) {
 TEST(Regex_matches, ecma262_lowercase_range) {
   const auto regex{sourcemeta::core::to_regex("[a-z]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a-z]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
@@ -1226,6 +1386,7 @@ TEST(Regex_matches, ecma262_lowercase_range) {
 TEST(Regex_matches, ecma262_hex_escape) {
   const auto regex{sourcemeta::core::to_regex("\\x41")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\x41"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "B"));
 }
@@ -1233,6 +1394,7 @@ TEST(Regex_matches, ecma262_hex_escape) {
 TEST(Regex_matches, ecma262_dollar_before_bracket) {
   const auto regex{sourcemeta::core::to_regex("$[abc]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("$[abc]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "$a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "$b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1241,6 +1403,7 @@ TEST(Regex_matches, ecma262_dollar_before_bracket) {
 TEST(Regex_matches, ecma262_quantifier_on_group) {
   const auto regex{sourcemeta::core::to_regex("(ab)+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(ab)+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abab"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1249,6 +1412,7 @@ TEST(Regex_matches, ecma262_quantifier_on_group) {
 TEST(Regex_matches, ecma262_nested_groups) {
   const auto regex{sourcemeta::core::to_regex("((abc))")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("((abc))"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -1256,6 +1420,7 @@ TEST(Regex_matches, ecma262_nested_groups) {
 TEST(Regex_matches, ecma262_escaped_pipe) {
   const auto regex{sourcemeta::core::to_regex("a\\|b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\|b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a|b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -1264,6 +1429,7 @@ TEST(Regex_matches, ecma262_escaped_pipe) {
 TEST(Regex_matches, ecma262_escaped_paren) {
   const auto regex{sourcemeta::core::to_regex("\\(abc\\)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\(abc\\)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "(abc)"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -1271,6 +1437,7 @@ TEST(Regex_matches, ecma262_escaped_paren) {
 TEST(Regex_matches, ecma262_dollar_at_start) {
   const auto regex{sourcemeta::core::to_regex("$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "anything"));
 }
@@ -1278,6 +1445,7 @@ TEST(Regex_matches, ecma262_dollar_at_start) {
 TEST(Regex_matches, ecma262_caret_at_end) {
   const auto regex{sourcemeta::core::to_regex("abc^")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("abc^"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc^"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -1285,6 +1453,7 @@ TEST(Regex_matches, ecma262_caret_at_end) {
 TEST(Regex_matches, ecma262_escaped_quantifiers) {
   const auto regex{sourcemeta::core::to_regex("\\*\\+\\?")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\*\\+\\?"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "*+?"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -1292,6 +1461,7 @@ TEST(Regex_matches, ecma262_escaped_quantifiers) {
 TEST(Regex_matches, ecma262_escaped_curly_brace) {
   const auto regex{sourcemeta::core::to_regex("\\{3\\}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\{3\\}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "{3}"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "333"));
 }
@@ -1299,6 +1469,7 @@ TEST(Regex_matches, ecma262_escaped_curly_brace) {
 TEST(Regex_matches, ecma262_question_quantifier) {
   const auto regex{sourcemeta::core::to_regex("ab?c")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("ab?c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ac"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abbc"));
@@ -1307,6 +1478,7 @@ TEST(Regex_matches, ecma262_question_quantifier) {
 TEST(Regex_matches, ecma262_zero_quantifier) {
   const auto regex{sourcemeta::core::to_regex("a{0}b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{0}b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xyzb"));
@@ -1315,6 +1487,7 @@ TEST(Regex_matches, ecma262_zero_quantifier) {
 TEST(Regex_matches, ecma262_spaces_are_literal) {
   const auto regex{sourcemeta::core::to_regex("a b c")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a b c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a b c"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc"));
 }
@@ -1322,6 +1495,7 @@ TEST(Regex_matches, ecma262_spaces_are_literal) {
 TEST(Regex_matches, ecma262_tab_is_literal) {
   const auto regex{sourcemeta::core::to_regex("a\tb")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\tb"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\tb"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -1329,11 +1503,13 @@ TEST(Regex_matches, ecma262_tab_is_literal) {
 TEST(Regex_matches, ecma262_backslash_before_closing_paren) {
   const auto regex{sourcemeta::core::to_regex("(abc\\)")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("(abc\\)"));
 }
 
 TEST(Regex_matches, ecma262_caret_dollar_together) {
   const auto regex{sourcemeta::core::to_regex("^$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -1341,6 +1517,7 @@ TEST(Regex_matches, ecma262_caret_dollar_together) {
 TEST(Regex_matches, ecma262_multiple_carets_at_start) {
   const auto regex{sourcemeta::core::to_regex("^^^abc")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^^^abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abcdef"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "^^abc"));
@@ -1350,6 +1527,7 @@ TEST(Regex_matches, ecma262_multiple_carets_at_start) {
 TEST(Regex_matches, ecma262_multiple_dollars_at_end) {
   const auto regex{sourcemeta::core::to_regex("abc$$$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("abc$$$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abc$"));
 }
@@ -1357,6 +1535,7 @@ TEST(Regex_matches, ecma262_multiple_dollars_at_end) {
 TEST(Regex_matches, ecma262_v_flag_set_subtraction) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--a]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]--a]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1365,6 +1544,7 @@ TEST(Regex_matches, ecma262_v_flag_set_subtraction) {
 TEST(Regex_matches, ecma262_v_flag_set_intersection) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]&&[0-5]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]&&[0-5]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "9"));
@@ -1373,6 +1553,7 @@ TEST(Regex_matches, ecma262_v_flag_set_intersection) {
 TEST(Regex_matches, ecma262_v_flag_subtract_vowels) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--[aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]--[aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
@@ -1386,6 +1567,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_vowels) {
 TEST(Regex_matches, ecma262_v_flag_subtract_range) {
   const auto regex{sourcemeta::core::to_regex("[[0-9]--[3-7]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[0-9]--[3-7]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "1"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "2"));
@@ -1399,6 +1581,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_range) {
 TEST(Regex_matches, ecma262_v_flag_subtract_from_digit) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]--[0]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]--[0]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "1"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -1408,6 +1591,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_from_digit) {
 TEST(Regex_matches, ecma262_v_flag_subtract_from_word) {
   const auto regex{sourcemeta::core::to_regex("[[\\w]--[0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\w]--[0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_"));
@@ -1419,6 +1603,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_from_word) {
 TEST(Regex_matches, ecma262_v_flag_intersect_word_lowercase) {
   const auto regex{sourcemeta::core::to_regex("[[\\w]&&[a-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\w]&&[a-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -1429,6 +1614,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_word_lowercase) {
 TEST(Regex_matches, ecma262_v_flag_intersect_even_digits) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]&&[02468]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]&&[02468]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "2"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "8"));
@@ -1439,6 +1625,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_even_digits) {
 TEST(Regex_matches, ecma262_v_flag_subtract_uppercase) {
   const auto regex{sourcemeta::core::to_regex("[[A-Za-z]--[A-Z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[A-Za-z]--[A-Z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -1448,6 +1635,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_uppercase) {
 TEST(Regex_matches, ecma262_v_flag_subtract_same_char) {
   const auto regex{sourcemeta::core::to_regex("[[a]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a]--[a]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -1455,6 +1643,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_same_char) {
 TEST(Regex_matches, ecma262_v_flag_intersect_same_range) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]&&[a-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]&&[a-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
@@ -1464,6 +1653,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_same_range) {
 TEST(Regex_matches, ecma262_v_flag_intersect_disjoint) {
   const auto regex{sourcemeta::core::to_regex("[[a-c]&&[x-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-c]&&[x-z]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "m"));
@@ -1472,6 +1662,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_disjoint) {
 TEST(Regex_matches, ecma262_v_flag_subtract_hex_letters) {
   const auto regex{sourcemeta::core::to_regex("[[0-9a-f]--[a-f]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[0-9a-f]--[a-f]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1481,6 +1672,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_hex_letters) {
 TEST(Regex_matches, ecma262_v_flag_intersect_partial_overlap) {
   const auto regex{sourcemeta::core::to_regex("[[a-m]&&[h-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-m]&&[h-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "h"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "j"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
@@ -1493,6 +1685,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_partial_overlap) {
 TEST(Regex_matches, ecma262_v_flag_subtract_start_of_range) {
   const auto regex{sourcemeta::core::to_regex("[[a-e]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-e]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "e"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1501,6 +1694,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_start_of_range) {
 TEST(Regex_matches, ecma262_v_flag_subtract_end_of_range) {
   const auto regex{sourcemeta::core::to_regex("[[a-e]--[e]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-e]--[e]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "d"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "e"));
@@ -1509,6 +1703,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_end_of_range) {
 TEST(Regex_matches, ecma262_v_flag_subtract_middle_of_range) {
   const auto regex{sourcemeta::core::to_regex("[[a-e]--[c]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-e]--[c]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "d"));
@@ -1519,6 +1714,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_middle_of_range) {
 TEST(Regex_matches, ecma262_v_flag_intersect_single_char) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]&&[m]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]&&[m]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "z"));
@@ -1527,6 +1723,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_single_char) {
 TEST(Regex_matches, ecma262_v_flag_subtraction_in_pattern) {
   const auto regex{sourcemeta::core::to_regex("^[[a-z]--[aeiou]]+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[[a-z]--[aeiou]]+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bcdfg"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xyz"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "hello"));
@@ -1536,6 +1733,7 @@ TEST(Regex_matches, ecma262_v_flag_subtraction_in_pattern) {
 TEST(Regex_matches, ecma262_v_flag_intersection_in_pattern) {
   const auto regex{sourcemeta::core::to_regex("^[\\d&&[0-5]]+$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[\\d&&[0-5]]+$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "012345"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "6789"));
@@ -1545,6 +1743,7 @@ TEST(Regex_matches, ecma262_v_flag_intersection_in_pattern) {
 TEST(Regex_matches, ecma262_v_flag_subtract_digit_from_word) {
   const auto regex{sourcemeta::core::to_regex("[[\\w]--[\\d]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\w]--[\\d]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_"));
@@ -1555,6 +1754,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_digit_from_word) {
 TEST(Regex_matches, ecma262_v_flag_intersect_digit_word) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]&&[\\w]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]&&[\\w]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1564,6 +1764,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_digit_word) {
 TEST(Regex_matches, ecma262_v_flag_subtract_specific_punct) {
   const auto regex{sourcemeta::core::to_regex("[[\\!-\\/]--[#$%]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\!-\\/]--[#$%]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "&"));
@@ -1576,6 +1777,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_specific_punct) {
 TEST(Regex_matches, ecma262_v_flag_subtract_empty) {
   const auto regex{sourcemeta::core::to_regex("[[a-c]--[x-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-c]--[x-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
@@ -1585,6 +1787,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_empty) {
 TEST(Regex_matches, ecma262_v_flag_intersect_printable_alpha) {
   const auto regex{sourcemeta::core::to_regex("[[ -~]&&[A-Z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[ -~]&&[A-Z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "M"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
@@ -1596,6 +1799,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_printable_alpha) {
 TEST(Regex_matches, ecma262_v_flag_subtract_multiple_ranges) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--[a-cx-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]--[a-cx-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "d"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "w"));
@@ -1610,6 +1814,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_multiple_ranges) {
 TEST(Regex_matches, ecma262_v_flag_subtract_space) {
   const auto regex{sourcemeta::core::to_regex("[[ -\\/]--[ ]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[ -\\/]--[ ]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "/"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), " "));
@@ -1618,6 +1823,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_space) {
 TEST(Regex_matches, ecma262_v_flag_intersect_to_single) {
   const auto regex{sourcemeta::core::to_regex("[[a-c]&&[c-e]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-c]&&[c-e]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -1628,6 +1834,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_to_single) {
 TEST(Regex_matches, ecma262_v_flag_subtraction_with_quantifier) {
   const auto regex{sourcemeta::core::to_regex("^[[0-9]--[0]]{3}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[[0-9]--[0]]{3}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "999"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "012"));
@@ -1638,6 +1845,7 @@ TEST(Regex_matches, ecma262_v_flag_subtraction_with_quantifier) {
 TEST(Regex_matches, ecma262_v_flag_subtract_caret) {
   const auto regex{sourcemeta::core::to_regex("[[!-@]--[\\^]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[!-@]--[\\^]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "@"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "^"));
@@ -1646,6 +1854,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_caret) {
 TEST(Regex_matches, ecma262_v_flag_intersect_alphanum_upper) {
   const auto regex{sourcemeta::core::to_regex("[[0-9A-Za-z]&&[A-Z0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[0-9A-Za-z]&&[A-Z0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -1656,6 +1865,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_alphanum_upper) {
 TEST(Regex_matches, ecma262_v_flag_subtract_entire_range) {
   const auto regex{sourcemeta::core::to_regex("[[a-c]--[a-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-c]--[a-z]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "c"));
@@ -1666,6 +1876,8 @@ TEST(Regex_matches, ecma262_v_flag_multiple_set_ops_pattern) {
   const auto regex{
       sourcemeta::core::to_regex("^[[a-z]--[aeiou]][[0-9]--[0]]$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("^[[a-z]--[aeiou]][[0-9]--[0]]$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b1"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a1"));
@@ -1676,6 +1888,7 @@ TEST(Regex_matches, ecma262_v_flag_multiple_set_ops_pattern) {
 TEST(Regex_matches, ecma262_v_flag_intersect_digit_ranges) {
   const auto regex{sourcemeta::core::to_regex("[[0-5]&&[3-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[0-5]&&[3-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "3"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "4"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -1688,6 +1901,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_digit_ranges) {
 TEST(Regex_matches, ecma262_v_flag_subtract_preserving_hyphen) {
   const auto regex{sourcemeta::core::to_regex("[[0-9\\-]--[5-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[0-9\\-]--[5-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "4"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
@@ -1698,6 +1912,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_preserving_hyphen) {
 TEST(Regex_matches, ecma262_v_flag_intersect_word_underscore) {
   const auto regex{sourcemeta::core::to_regex("[[\\w]&&[_]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\w]&&[_]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -1706,6 +1921,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_word_underscore) {
 TEST(Regex_matches, ecma262_v_flag_subtract_from_union) {
   const auto regex{sourcemeta::core::to_regex("[[a-zA-Z0-9]--[A-Z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-zA-Z0-9]--[A-Z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -1716,6 +1932,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_from_union) {
 TEST(Regex_matches, ecma262_v_flag_large_subtraction) {
   const auto regex{sourcemeta::core::to_regex("[[\\x20-\\x7e]--[a-zA-Z0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x20-\\x7e]--[a-zA-Z0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "@"));
@@ -1728,6 +1945,7 @@ TEST(Regex_matches, ecma262_v_flag_large_subtraction) {
 TEST(Regex_matches, ecma262_v_flag_hex_range_subtract_literal) {
   const auto regex{sourcemeta::core::to_regex("[[\\x61-\\x7a]--[aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x61-\\x7a]--[aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1737,6 +1955,7 @@ TEST(Regex_matches, ecma262_v_flag_hex_range_subtract_literal) {
 TEST(Regex_matches, ecma262_v_flag_subtract_single_from_single) {
   const auto regex{sourcemeta::core::to_regex("[[a]--[b]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a]--[b]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -1744,6 +1963,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_single_from_single) {
 TEST(Regex_matches, ecma262_v_flag_intersect_single_chars_same) {
   const auto regex{sourcemeta::core::to_regex("[[a]&&[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a]&&[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -1751,6 +1971,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_single_chars_same) {
 TEST(Regex_matches, ecma262_v_flag_intersect_single_chars_different) {
   const auto regex{sourcemeta::core::to_regex("[[a]&&[b]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a]&&[b]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -1759,6 +1980,8 @@ TEST(Regex_matches, ecma262_v_flag_hex_intersect_hex) {
   const auto regex{
       sourcemeta::core::to_regex("[[\\x30-\\x39]&&[\\x33-\\x37]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[\\x30-\\x39]&&[\\x33-\\x37]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "3"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "7"));
@@ -1771,6 +1994,7 @@ TEST(Regex_matches, ecma262_v_flag_hex_intersect_hex) {
 TEST(Regex_matches, ecma262_v_flag_subtract_all_digits_from_word) {
   const auto regex{sourcemeta::core::to_regex("[[[\\w]--[\\d]]--[_]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[\\w]--[\\d]]--[_]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -1780,6 +2004,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_all_digits_from_word) {
 TEST(Regex_matches, ecma262_v_flag_intersect_with_escaped_backslash) {
   const auto regex{sourcemeta::core::to_regex("[[\\\\a-z]&&[\\\\]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\\\a-z]&&[\\\\]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "z"));
@@ -1789,6 +2014,8 @@ TEST(Regex_matches, ecma262_v_flag_subtract_control_chars) {
   const auto regex{
       sourcemeta::core::to_regex("[[\\x00-\\x1f]--[\\x00-\\x08]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[\\x00-\\x1f]--[\\x00-\\x08]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\n"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\x00"));
@@ -1798,6 +2025,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_control_chars) {
 TEST(Regex_matches, ecma262_v_flag_intersect_with_tab_newline) {
   const auto regex{sourcemeta::core::to_regex("[[\\t\\n\\r ]&&[\\t\\n]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\t\\n\\r ]&&[\\t\\n]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\n"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\r"));
@@ -1807,6 +2035,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_with_tab_newline) {
 TEST(Regex_matches, ecma262_v_flag_subtract_leaves_single) {
   const auto regex{sourcemeta::core::to_regex("[[a-c]--[ab]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-c]--[ab]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -1815,6 +2044,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_leaves_single) {
 TEST(Regex_matches, ecma262_v_flag_intersect_overlapping_three_char) {
   const auto regex{sourcemeta::core::to_regex("[[abc]&&[bcd]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[abc]&&[bcd]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1824,6 +2054,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_overlapping_three_char) {
 TEST(Regex_matches, ecma262_v_flag_mixed_hex_and_literal_in_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[\\x41-\\x5a]--[AEIOU]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x41-\\x5a]--[AEIOU]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "B"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -1834,6 +2065,7 @@ TEST(Regex_matches, ecma262_v_flag_mixed_hex_and_literal_in_subtract) {
 TEST(Regex_matches, ecma262_v_flag_subtract_boundary_chars) {
   const auto regex{sourcemeta::core::to_regex("[[!-~]--[!~]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[!-~]--[!~]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1845,6 +2077,8 @@ TEST(Regex_matches, ecma262_v_flag_intersect_complement_like) {
   const auto regex{
       sourcemeta::core::to_regex("[[\\x00-\\x60\\x7b-\\x7f]&&[\\x00-\\x7f]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "[[\\x00-\\x60\\x7b-\\x7f]&&[\\x00-\\x7f]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
@@ -1855,6 +2089,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_complement_like) {
 TEST(Regex_matches, ecma262_v_flag_subtract_from_shorthand_with_hex) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]--[\\x30-\\x34]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]--[\\x30-\\x34]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -1864,6 +2099,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_from_shorthand_with_hex) {
 TEST(Regex_matches, ecma262_v_flag_complex_alphanumeric_filter) {
   const auto regex{sourcemeta::core::to_regex("[[0-9A-Fa-f]--[g-zG-Z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[0-9A-Fa-f]--[g-zG-Z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1877,6 +2113,7 @@ TEST(Regex_matches, ecma262_v_flag_complex_alphanumeric_filter) {
 TEST(Regex_matches, ecma262_v_flag_intersect_ranges_at_boundary) {
   const auto regex{sourcemeta::core::to_regex("[[a-f]&&[f-k]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-f]&&[f-k]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "f"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "e"));
@@ -1887,6 +2124,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_ranges_at_boundary) {
 TEST(Regex_matches, ecma262_v_flag_subtract_all_but_one_from_range) {
   const auto regex{sourcemeta::core::to_regex("[[a-e]--[abde]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-e]--[abde]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -1898,6 +2136,8 @@ TEST(Regex_matches, ecma262_v_flag_multiple_hex_escapes_in_subtraction) {
   const auto regex{sourcemeta::core::to_regex(
       "[[\\x20-\\x7e]--[\\x30-\\x39]--[\\x41-\\x5a]--[\\x61-\\x7a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "[[\\x20-\\x7e]--[\\x30-\\x39]--[\\x41-\\x5a]--[\\x61-\\x7a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "@"));
@@ -1909,6 +2149,7 @@ TEST(Regex_matches, ecma262_v_flag_multiple_hex_escapes_in_subtraction) {
 TEST(Regex_matches, ecma262_v_flag_mixed_subtract_then_intersect) {
   const auto regex{sourcemeta::core::to_regex("[[[a-z]--[aeiou]]&&[a-m]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[a-z]--[aeiou]]&&[a-m]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1919,6 +2160,7 @@ TEST(Regex_matches, ecma262_v_flag_mixed_subtract_then_intersect) {
 TEST(Regex_matches, ecma262_v_flag_mixed_intersect_then_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[[a-z]&&[a-m]]--[aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[a-z]&&[a-m]]--[aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1929,6 +2171,7 @@ TEST(Regex_matches, ecma262_v_flag_mixed_intersect_then_subtract) {
 TEST(Regex_matches, ecma262_v_flag_nested_class_in_operand) {
   const auto regex{sourcemeta::core::to_regex("[[[a-z][0-9]]--[aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[a-z][0-9]]--[aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1938,6 +2181,7 @@ TEST(Regex_matches, ecma262_v_flag_nested_class_in_operand) {
 TEST(Regex_matches, ecma262_v_flag_deeply_nested_brackets) {
   const auto regex{sourcemeta::core::to_regex("[[[[a-z]]]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[[a-z]]]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -1947,6 +2191,7 @@ TEST(Regex_matches, ecma262_v_flag_deeply_nested_brackets) {
 TEST(Regex_matches, ecma262_v_flag_subtract_nested_from_nested) {
   const auto regex{sourcemeta::core::to_regex("[[[a-z]]--[[x-z]]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[a-z]]--[[x-z]]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "w"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
@@ -1956,6 +2201,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_nested_from_nested) {
 TEST(Regex_matches, ecma262_v_flag_shorthand_nested_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[[\\d]]--[0]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[\\d]]--[0]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "1"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -1964,6 +2210,7 @@ TEST(Regex_matches, ecma262_v_flag_shorthand_nested_subtract) {
 TEST(Regex_matches, ecma262_v_flag_triple_chained_intersection) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]&&[a-m]&&[f-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]&&[a-m]&&[f-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "f"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -1975,6 +2222,7 @@ TEST(Regex_matches, ecma262_v_flag_triple_chained_intersection) {
 TEST(Regex_matches, ecma262_v_flag_subtract_empty_result_in_chain) {
   const auto regex{sourcemeta::core::to_regex("[[a]--[a]--[b]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a]--[a]--[b]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -1982,6 +2230,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_empty_result_in_chain) {
 TEST(Regex_matches, ecma262_v_flag_intersect_empty_result_in_chain) {
   const auto regex{sourcemeta::core::to_regex("[[a-c]&&[x-z]&&[a-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-c]&&[x-z]&&[a-z]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
 }
@@ -1989,6 +2238,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_empty_result_in_chain) {
 TEST(Regex_matches, ecma262_v_flag_operator_inside_nested_not_toplevel) {
   const auto regex{sourcemeta::core::to_regex("[[a\\-\\-b]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a\\-\\-b]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
@@ -1997,6 +2247,7 @@ TEST(Regex_matches, ecma262_v_flag_operator_inside_nested_not_toplevel) {
 TEST(Regex_matches, ecma262_v_flag_alternation_after_set_op) {
   const auto regex{sourcemeta::core::to_regex("^([[a-z]--[aeiou]]|[0-9])$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^([[a-z]--[aeiou]]|[0-9])$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2006,6 +2257,7 @@ TEST(Regex_matches, ecma262_v_flag_alternation_after_set_op) {
 TEST(Regex_matches, ecma262_v_flag_set_op_with_dot_star) {
   const auto regex{sourcemeta::core::to_regex("^.*[[a-z]--[aeiou]]$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^.*[[a-z]--[aeiou]]$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xxxb"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "xxxa"));
@@ -2015,6 +2267,7 @@ TEST(Regex_matches, ecma262_v_flag_set_op_with_dot_star) {
 TEST(Regex_matches, ecma262_v_flag_shorthand_only_intersection) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]&&[\\w]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]&&[\\w]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2024,6 +2277,7 @@ TEST(Regex_matches, ecma262_v_flag_shorthand_only_intersection) {
 TEST(Regex_matches, ecma262_v_flag_double_nested_with_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[[a-z]]--[[aeiou]]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[a-z]]--[[aeiou]]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2033,6 +2287,7 @@ TEST(Regex_matches, ecma262_v_flag_double_nested_with_subtract) {
 TEST(Regex_matches, ecma262_v_flag_union_in_nested) {
   const auto regex{sourcemeta::core::to_regex("[[[a-c][x-z]]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[a-c][x-z]]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "x"));
@@ -2044,6 +2299,7 @@ TEST(Regex_matches, ecma262_v_flag_union_in_nested) {
 TEST(Regex_matches, ecma262_v_flag_subtract_from_union_nested) {
   const auto regex{sourcemeta::core::to_regex("[[[a-z][0-9]]--[aeiou0]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[a-z][0-9]]--[aeiou0]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "1"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
@@ -2055,6 +2311,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_from_union_nested) {
 TEST(Regex_matches, ecma262_v_flag_four_way_intersection) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]&&[a-m]&&[f-z]&&[g-l]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]&&[a-m]&&[f-z]&&[g-l]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "g"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "l"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "f"));
@@ -2066,6 +2323,8 @@ TEST(Regex_matches, ecma262_v_flag_alternating_ops) {
   const auto regex{
       sourcemeta::core::to_regex("[[[[a-z]--[aeiou]]&&[a-m]]--[klm]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[[[a-z]--[aeiou]]&&[a-m]]--[klm]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "j"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "k"));
@@ -2076,6 +2335,7 @@ TEST(Regex_matches, ecma262_v_flag_alternating_ops) {
 TEST(Regex_matches, ecma262_v_flag_repeated_char_class) {
   const auto regex{sourcemeta::core::to_regex("^[[a-c]][[d-f]]$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[[a-c]][[d-f]]$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ad"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "cf"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "aa"));
@@ -2086,6 +2346,7 @@ TEST(Regex_matches, ecma262_v_flag_repeated_char_class) {
 TEST(Regex_matches, ecma262_v_flag_whitespace_subtract_space) {
   const auto regex{sourcemeta::core::to_regex("[[\\s]--[ ]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\s]--[ ]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\n"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), " "));
@@ -2095,6 +2356,7 @@ TEST(Regex_matches, ecma262_v_flag_whitespace_subtract_space) {
 TEST(Regex_matches, ecma262_v_flag_negated_digit_intersect) {
   const auto regex{sourcemeta::core::to_regex("[[\\D]&&[a-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\D]&&[a-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -2104,6 +2366,7 @@ TEST(Regex_matches, ecma262_v_flag_negated_digit_intersect) {
 TEST(Regex_matches, ecma262_v_flag_negated_word_intersect) {
   const auto regex{sourcemeta::core::to_regex("[[\\W]&&[\\!-\\/]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\W]&&[\\!-\\/]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "/"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2113,6 +2376,7 @@ TEST(Regex_matches, ecma262_v_flag_negated_word_intersect) {
 TEST(Regex_matches, ecma262_v_flag_negated_space_intersect) {
   const auto regex{sourcemeta::core::to_regex("[[\\S]&&[a-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\S]&&[a-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), " "));
@@ -2122,6 +2386,7 @@ TEST(Regex_matches, ecma262_v_flag_negated_space_intersect) {
 TEST(Regex_matches, ecma262_v_flag_caret_negation_with_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[^a-z]--[0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[^a-z]--[0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2131,6 +2396,7 @@ TEST(Regex_matches, ecma262_v_flag_caret_negation_with_subtract) {
 TEST(Regex_matches, ecma262_v_flag_single_char_range) {
   const auto regex{sourcemeta::core::to_regex("[[a-a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -2138,6 +2404,7 @@ TEST(Regex_matches, ecma262_v_flag_single_char_range) {
 TEST(Regex_matches, ecma262_v_flag_literal_hyphen_at_end) {
   const auto regex{sourcemeta::core::to_regex("[[a-z\\-]--[aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z\\-]--[aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2147,6 +2414,7 @@ TEST(Regex_matches, ecma262_v_flag_literal_hyphen_at_end) {
 TEST(Regex_matches, ecma262_v_flag_literal_hyphen_at_start) {
   const auto regex{sourcemeta::core::to_regex("[[\\-a-z]--[aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\-a-z]--[aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2155,6 +2423,7 @@ TEST(Regex_matches, ecma262_v_flag_literal_hyphen_at_start) {
 TEST(Regex_matches, ecma262_v_flag_subtract_with_caret_in_operand) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--[^aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]--[^aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "e"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -2164,6 +2433,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_with_caret_in_operand) {
 TEST(Regex_matches, ecma262_v_flag_intersect_with_caret_in_operand) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]&&[^x-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]&&[^x-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "w"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
@@ -2173,6 +2443,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_with_caret_in_operand) {
 TEST(Regex_matches, ecma262_v_flag_unicode_escape_4digit_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[\\u0041-\\u005A]--[ABC]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\u0041-\\u005A]--[ABC]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "D"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -2184,6 +2455,8 @@ TEST(Regex_matches, ecma262_v_flag_unicode_escape_brace_subtract) {
   const auto regex{
       sourcemeta::core::to_regex("[[\\u{0041}-\\u{005A}]--[ABC]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[\\u{0041}-\\u{005A}]--[ABC]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "D"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -2194,6 +2467,7 @@ TEST(Regex_matches, ecma262_v_flag_unicode_escape_brace_subtract) {
 TEST(Regex_matches, ecma262_v_flag_backspace_in_class) {
   const auto regex{sourcemeta::core::to_regex("[[\\b]--[\\x08]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\b]--[\\x08]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2201,6 +2475,7 @@ TEST(Regex_matches, ecma262_v_flag_backspace_in_class) {
 TEST(Regex_matches, ecma262_v_flag_control_escape_intersect) {
   const auto regex{sourcemeta::core::to_regex("[[\\cA-\\cZ]&&[\\x01-\\x03]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\cA-\\cZ]&&[\\x01-\\x03]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x01"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x03"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\x04"));
@@ -2210,21 +2485,25 @@ TEST(Regex_matches, ecma262_v_flag_control_escape_intersect) {
 TEST(Regex_matches, ecma262_v_flag_empty_first_operand) {
   const auto regex{sourcemeta::core::to_regex("[--[a-z]]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[--[a-z]]"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_empty_second_operand) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[[a-z]--]"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_double_operator_subtraction) {
   const auto regex{sourcemeta::core::to_regex("[a-z----abc]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[a-z----abc]"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_subtract_abc_from_az) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--[abc]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]--[abc]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "d"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2235,6 +2514,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_abc_from_az) {
 TEST(Regex_matches, ecma262_v_flag_rightbracket_first_in_nested) {
   const auto regex{sourcemeta::core::to_regex("[[\\]-a]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\]-a]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2242,6 +2522,7 @@ TEST(Regex_matches, ecma262_v_flag_rightbracket_first_in_nested) {
 TEST(Regex_matches, ecma262_v_flag_subtract_from_single_shorthand) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]--[5]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]--[5]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
@@ -2251,6 +2532,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_from_single_shorthand) {
 TEST(Regex_matches, ecma262_v_flag_intersect_two_shorthands) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]&&[\\w]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]&&[\\w]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2260,6 +2542,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_two_shorthands) {
 TEST(Regex_matches, ecma262_v_flag_subtract_shorthand_from_shorthand) {
   const auto regex{sourcemeta::core::to_regex("[[\\w]--[\\d]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\w]--[\\d]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_"));
@@ -2270,6 +2553,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_shorthand_from_shorthand) {
 TEST(Regex_matches, ecma262_v_flag_triple_nested_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[[a-z]]--[[aeiou]]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[a-z]]--[[aeiou]]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2279,6 +2563,7 @@ TEST(Regex_matches, ecma262_v_flag_triple_nested_subtract) {
 TEST(Regex_matches, ecma262_v_flag_subtract_empty_nested) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--[]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]--[]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -2287,6 +2572,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_empty_nested) {
 TEST(Regex_matches, ecma262_v_flag_word_minus_alphanumeric) {
   const auto regex{sourcemeta::core::to_regex("[[\\w]--[a-zA-Z0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\w]--[a-zA-Z0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -2295,6 +2581,7 @@ TEST(Regex_matches, ecma262_v_flag_word_minus_alphanumeric) {
 TEST(Regex_matches, ecma262_v_flag_multiple_escape_sequences_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[[\\t\\n\\r]]--[\\t]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[\\t\\n\\r]]--[\\t]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\n"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\r"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\t"));
@@ -2303,6 +2590,7 @@ TEST(Regex_matches, ecma262_v_flag_multiple_escape_sequences_subtract) {
 TEST(Regex_matches, ecma262_v_flag_mixed_unicode_escape_types) {
   const auto regex{sourcemeta::core::to_regex("[[\\u0041-\\u{005A}]--[ABC]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\u0041-\\u{005A}]--[ABC]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "D"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -2313,6 +2601,8 @@ TEST(Regex_matches, ecma262_v_flag_control_char_range_intersect) {
   const auto regex{
       sourcemeta::core::to_regex("[[\\x00-\\x1F]&&[\\x00-\\x0F]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[\\x00-\\x1F]&&[\\x00-\\x0F]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string("\x00", 1)));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x0F"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\x10"));
@@ -2322,6 +2612,7 @@ TEST(Regex_matches, ecma262_v_flag_control_char_range_intersect) {
 TEST(Regex_matches, ecma262_v_flag_del_char_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[\\x7E-\\x7F]--[\\x7E]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x7E-\\x7F]--[\\x7E]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x7F"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "~"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2330,6 +2621,7 @@ TEST(Regex_matches, ecma262_v_flag_del_char_subtract) {
 TEST(Regex_matches, ecma262_v_flag_form_feed_and_vertical_tab) {
   const auto regex{sourcemeta::core::to_regex("[[\\f\\v]--[\\f]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\f\\v]--[\\f]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\v"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\f"));
 }
@@ -2337,6 +2629,7 @@ TEST(Regex_matches, ecma262_v_flag_form_feed_and_vertical_tab) {
 TEST(Regex_matches, ecma262_v_flag_null_char_in_operation) {
   const auto regex{sourcemeta::core::to_regex("[[\\x00-\\x02]--[\\x00]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x00-\\x02]--[\\x00]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x01"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x02"));
   EXPECT_FALSE(
@@ -2346,6 +2639,7 @@ TEST(Regex_matches, ecma262_v_flag_null_char_in_operation) {
 TEST(Regex_matches, ecma262_v_flag_printable_minus_alphanumeric) {
   const auto regex{sourcemeta::core::to_regex("[[\\x20-\\x7E]--[a-zA-Z0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x20-\\x7E]--[a-zA-Z0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "@"));
@@ -2357,6 +2651,8 @@ TEST(Regex_matches, ecma262_v_flag_five_way_chained_intersection) {
   const auto regex{
       sourcemeta::core::to_regex("[[a-z]&&[a-w]&&[a-t]&&[a-q]&&[a-n]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[a-z]&&[a-w]&&[a-t]&&[a-q]&&[a-n]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "n"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "o"));
@@ -2366,6 +2662,7 @@ TEST(Regex_matches, ecma262_v_flag_five_way_chained_intersection) {
 TEST(Regex_matches, ecma262_v_flag_lowercase_control_escape) {
   const auto regex{sourcemeta::core::to_regex("[[\\ca-\\cz]&&[\\x01-\\x03]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\ca-\\cz]&&[\\x01-\\x03]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x01"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x03"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\x04"));
@@ -2374,6 +2671,7 @@ TEST(Regex_matches, ecma262_v_flag_lowercase_control_escape) {
 TEST(Regex_matches, ecma262_v_flag_subtract_all_word_chars) {
   const auto regex{sourcemeta::core::to_regex("[[\\w]--[\\w]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\w]--[\\w]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "_"));
@@ -2382,6 +2680,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_all_word_chars) {
 TEST(Regex_matches, ecma262_v_flag_intersect_with_itself) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]&&[\\d]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]&&[\\d]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2390,6 +2689,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_with_itself) {
 TEST(Regex_matches, ecma262_v_flag_double_backslash_in_operation) {
   const auto regex{sourcemeta::core::to_regex("[[\\\\]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\\\]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2400,6 +2700,10 @@ TEST(Regex_matches, ecma262_v_flag_subtract_from_full_ascii_printable) {
                                  "\\x40]]--[\\x5B-\\x60]]--[\\x7"
                                  "B-\\x7E]]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "[[[[[[\\x20-\\x7E]--[\\x20-\\x2F]]--[\\x3A-"
+      "\\x40]]--[\\x5B-\\x60]]--[\\x7"
+      "B-\\x7E]]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -2411,6 +2715,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_from_full_ascii_printable) {
 TEST(Regex_matches, ecma262_v_flag_all_hex_digits_only) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]&&[a-fA-F0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]&&[a-fA-F0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2420,6 +2725,7 @@ TEST(Regex_matches, ecma262_v_flag_all_hex_digits_only) {
 TEST(Regex_matches, ecma262_v_flag_hex_letter_only) {
   const auto regex{sourcemeta::core::to_regex("[[a-fA-F0-9]--[\\d]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-fA-F0-9]--[\\d]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "f"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
@@ -2432,6 +2738,7 @@ TEST(Regex_matches, ecma262_v_flag_hex_letter_only) {
 TEST(Regex_matches, ecma262_v_flag_escaped_special_regex_chars) {
   const auto regex{sourcemeta::core::to_regex("[[.+*?]--[.]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[.+*?]--[.]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "*"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "?"));
@@ -2442,6 +2749,7 @@ TEST(Regex_matches, ecma262_v_flag_escaped_special_regex_chars) {
 TEST(Regex_matches, ecma262_v_flag_escaped_open_bracket) {
   const auto regex{sourcemeta::core::to_regex("[[\\[]--[x]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\[]--[x]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "["));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "]"));
@@ -2450,6 +2758,7 @@ TEST(Regex_matches, ecma262_v_flag_escaped_open_bracket) {
 TEST(Regex_matches, ecma262_v_flag_only_special_punctuation) {
   const auto regex{sourcemeta::core::to_regex("[[\\!-\\/]&&[\\(-+]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\!-\\/]&&[\\(-+]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "("));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ")"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "*"));
@@ -2461,6 +2770,7 @@ TEST(Regex_matches, ecma262_v_flag_only_special_punctuation) {
 TEST(Regex_matches, ecma262_v_flag_range_with_same_start_end) {
   const auto regex{sourcemeta::core::to_regex("[[a-a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -2468,6 +2778,7 @@ TEST(Regex_matches, ecma262_v_flag_range_with_same_start_end) {
 TEST(Regex_matches, ecma262_v_flag_at_sign_and_backtick) {
   const auto regex{sourcemeta::core::to_regex("[[@`]--[@]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[@`]--[@]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "`"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "@"));
 }
@@ -2475,6 +2786,7 @@ TEST(Regex_matches, ecma262_v_flag_at_sign_and_backtick) {
 TEST(Regex_matches, ecma262_v_flag_escaped_hyphen_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[a\\-z]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a\\-z]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2484,6 +2796,7 @@ TEST(Regex_matches, ecma262_v_flag_escaped_hyphen_subtract) {
 TEST(Regex_matches, ecma262_v_flag_hex_to_literal_range) {
   const auto regex{sourcemeta::core::to_regex("[[\\x41-Z]--[ABC]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x41-Z]--[ABC]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "D"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -2493,6 +2806,7 @@ TEST(Regex_matches, ecma262_v_flag_hex_to_literal_range) {
 TEST(Regex_matches, ecma262_v_flag_literal_to_hex_range) {
   const auto regex{sourcemeta::core::to_regex("[[A-\\x5A]--[ABC]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[A-\\x5A]--[ABC]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "D"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -2503,6 +2817,8 @@ TEST(Regex_matches, ecma262_v_flag_multiple_char_classes_in_pattern) {
   const auto regex{
       sourcemeta::core::to_regex("[[a-z]--[aeiou]][[A-Z]--[AEIOU]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[a-z]--[aeiou]][[A-Z]--[AEIOU]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bB"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "cD"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "aA"));
@@ -2512,6 +2828,7 @@ TEST(Regex_matches, ecma262_v_flag_multiple_char_classes_in_pattern) {
 TEST(Regex_matches, ecma262_v_flag_in_group) {
   const auto regex{sourcemeta::core::to_regex("(x[[a-z]--[aeiou]]y)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(x[[a-z]--[aeiou]]y)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xby"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xcy"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "xay"));
@@ -2521,6 +2838,7 @@ TEST(Regex_matches, ecma262_v_flag_in_group) {
 TEST(Regex_matches, ecma262_v_flag_with_quantifier_range) {
   const auto regex{sourcemeta::core::to_regex("^[[a-z]--[aeiou]]{2,4}$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[[a-z]--[aeiou]]{2,4}$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bcdf"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -2530,6 +2848,7 @@ TEST(Regex_matches, ecma262_v_flag_with_quantifier_range) {
 TEST(Regex_matches, ecma262_v_flag_anchored_both_ends) {
   const auto regex{sourcemeta::core::to_regex("^[[a-z]--[aeiou]]$")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("^[[a-z]--[aeiou]]$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2540,6 +2859,8 @@ TEST(Regex_matches, ecma262_v_flag_alternation_both_branches) {
   const auto regex{
       sourcemeta::core::to_regex("[[a-m]--[aeiou]]|[[n-z]--[aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[a-m]--[aeiou]]|[[n-z]--[aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "p"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2550,6 +2871,8 @@ TEST(Regex_matches, ecma262_v_flag_ten_way_chained_subtraction) {
   const auto regex{sourcemeta::core::to_regex(
       "[[a-z]--[a]--[b]--[c]--[d]--[e]--[f]--[g]--[h]--[i]--[j]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "[[a-z]--[a]--[b]--[c]--[d]--[e]--[f]--[g]--[h]--[i]--[j]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "k"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2559,6 +2882,7 @@ TEST(Regex_matches, ecma262_v_flag_ten_way_chained_subtraction) {
 TEST(Regex_matches, ecma262_v_flag_single_char_minus_single_char_same) {
   const auto regex{sourcemeta::core::to_regex("[[x]--[x]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[x]--[x]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "y"));
 }
@@ -2566,6 +2890,7 @@ TEST(Regex_matches, ecma262_v_flag_single_char_minus_single_char_same) {
 TEST(Regex_matches, ecma262_v_flag_single_char_minus_single_char_different) {
   const auto regex{sourcemeta::core::to_regex("[[x]--[y]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[x]--[y]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "x"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "y"));
 }
@@ -2573,6 +2898,7 @@ TEST(Regex_matches, ecma262_v_flag_single_char_minus_single_char_different) {
 TEST(Regex_matches, ecma262_v_flag_caret_not_at_start_in_nested) {
   const auto regex{sourcemeta::core::to_regex("[[a^b]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a^b]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "^"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2581,6 +2907,7 @@ TEST(Regex_matches, ecma262_v_flag_caret_not_at_start_in_nested) {
 TEST(Regex_matches, ecma262_v_flag_dollar_in_class) {
   const auto regex{sourcemeta::core::to_regex("[[$a]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[$a]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "$"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2588,6 +2915,7 @@ TEST(Regex_matches, ecma262_v_flag_dollar_in_class) {
 TEST(Regex_matches, ecma262_v_flag_pipe_in_class) {
   const auto regex{sourcemeta::core::to_regex("[[\\|a]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\|a]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "|"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2595,6 +2923,7 @@ TEST(Regex_matches, ecma262_v_flag_pipe_in_class) {
 TEST(Regex_matches, ecma262_v_flag_lookahead_with_operation) {
   const auto regex{sourcemeta::core::to_regex("(?=[[a-z]--[aeiou]]).")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?=[[a-z]--[aeiou]])."));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2604,6 +2933,7 @@ TEST(Regex_matches, ecma262_v_flag_lookahead_with_operation) {
 TEST(Regex_matches, ecma262_v_flag_lookbehind_with_operation) {
   const auto regex{sourcemeta::core::to_regex("(?<=[[a-z]--[aeiou]])x")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?<=[[a-z]--[aeiou]])x"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bx"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ax"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ex"));
@@ -2612,6 +2942,7 @@ TEST(Regex_matches, ecma262_v_flag_lookbehind_with_operation) {
 TEST(Regex_matches, ecma262_v_flag_full_ascii_intersect_to_alpha) {
   const auto regex{sourcemeta::core::to_regex("[[\\x00-\\x7F]&&[a-zA-Z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x00-\\x7F]&&[a-zA-Z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -2621,6 +2952,7 @@ TEST(Regex_matches, ecma262_v_flag_full_ascii_intersect_to_alpha) {
 TEST(Regex_matches, ecma262_v_flag_subtract_to_result_one_char) {
   const auto regex{sourcemeta::core::to_regex("[[a-c]--[ab]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-c]--[ab]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -2630,6 +2962,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_to_result_one_char) {
 TEST(Regex_matches, ecma262_v_flag_intersect_to_result_one_char) {
   const auto regex{sourcemeta::core::to_regex("[[abc]&&[cde]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[abc]&&[cde]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "d"));
@@ -2638,6 +2971,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_to_result_one_char) {
 TEST(Regex_matches, ecma262_v_flag_space_in_operation) {
   const auto regex{sourcemeta::core::to_regex("[[ a]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[ a]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2645,6 +2979,7 @@ TEST(Regex_matches, ecma262_v_flag_space_in_operation) {
 TEST(Regex_matches, ecma262_v_flag_bell_char_subtract) {
   const auto regex{sourcemeta::core::to_regex("[[\\x07-\\x09]--[\\x08]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\x07-\\x09]--[\\x08]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x07"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\b"));
@@ -2653,6 +2988,7 @@ TEST(Regex_matches, ecma262_v_flag_bell_char_subtract) {
 TEST(Regex_matches, ecma262_v_flag_escape_sequence_vs_hex) {
   const auto regex{sourcemeta::core::to_regex("[\\t--[\\x09]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\t--[\\x09]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\t"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "t"));
 }
@@ -2660,6 +2996,7 @@ TEST(Regex_matches, ecma262_v_flag_escape_sequence_vs_hex) {
 TEST(Regex_matches, ecma262_v_flag_carriage_return_line_feed) {
   const auto regex{sourcemeta::core::to_regex("[[\\r\\n]--[\\n]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\r\\n]--[\\n]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\r"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\n"));
 }
@@ -2667,6 +3004,7 @@ TEST(Regex_matches, ecma262_v_flag_carriage_return_line_feed) {
 TEST(Regex_matches, ecma262_v_flag_repeated_same_subtraction) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--[aeiou]--[aeiou]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[a-z]--[aeiou]--[aeiou]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2674,6 +3012,7 @@ TEST(Regex_matches, ecma262_v_flag_repeated_same_subtraction) {
 TEST(Regex_matches, ecma262_v_flag_quadruple_nested) {
   const auto regex{sourcemeta::core::to_regex("[[[[a-z]]]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[[[a-z]]]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -2682,6 +3021,7 @@ TEST(Regex_matches, ecma262_v_flag_quadruple_nested) {
 TEST(Regex_matches, ecma262_v_flag_subtract_superset) {
   const auto regex{sourcemeta::core::to_regex("[[abc]--[a-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[abc]--[a-z]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "c"));
@@ -2690,6 +3030,7 @@ TEST(Regex_matches, ecma262_v_flag_subtract_superset) {
 TEST(Regex_matches, ecma262_v_flag_intersect_disjoint_sets) {
   const auto regex{sourcemeta::core::to_regex("[[abc]&&[xyz]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[abc]&&[xyz]]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
 }
@@ -2697,6 +3038,7 @@ TEST(Regex_matches, ecma262_v_flag_intersect_disjoint_sets) {
 TEST(Regex_matches, ecma262_v_flag_negative_lookahead_with_operation) {
   const auto regex{sourcemeta::core::to_regex("a(?![[a-z]--[aeiou]])")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a(?![[a-z]--[aeiou]])"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ae"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a1"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
@@ -2706,6 +3048,7 @@ TEST(Regex_matches, ecma262_v_flag_negative_lookahead_with_operation) {
 TEST(Regex_matches, ecma262_v_flag_negative_lookbehind_with_operation) {
   const auto regex{sourcemeta::core::to_regex("(?<![[a-z]--[aeiou]])x")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?<![[a-z]--[aeiou]])x"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ax"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "1x"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "bx"));
@@ -2715,6 +3058,7 @@ TEST(Regex_matches, ecma262_v_flag_negative_lookbehind_with_operation) {
 TEST(Regex_matches, ecma262_v_flag_non_capturing_group) {
   const auto regex{sourcemeta::core::to_regex("(?:[[a-z]--[aeiou]])+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(?:[[a-z]--[aeiou]])+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bcdf"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "aeiou"));
 }
@@ -2722,6 +3066,7 @@ TEST(Regex_matches, ecma262_v_flag_non_capturing_group) {
 TEST(Regex_matches, ecma262_v_flag_nested_groups_with_operation) {
   const auto regex{sourcemeta::core::to_regex("(([[a-z]--[aeiou]]))")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(([[a-z]--[aeiou]]))"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2729,11 +3074,13 @@ TEST(Regex_matches, ecma262_v_flag_nested_groups_with_operation) {
 TEST(Regex_matches, ecma262_v_flag_unknown_escape_sequence) {
   const auto regex{sourcemeta::core::to_regex("[[\\q]--[x]]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[[\\q]--[x]]"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_tilde_and_special_chars) {
   const auto regex{sourcemeta::core::to_regex("[[~!@#]--[~]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[~!@#]--[~]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "@"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "#"));
@@ -2743,6 +3090,7 @@ TEST(Regex_matches, ecma262_v_flag_tilde_and_special_chars) {
 TEST(Regex_matches, ecma262_v_flag_equals_and_less_greater) {
   const auto regex{sourcemeta::core::to_regex("[[<=>]--[=]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[<=>]--[=]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "<"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ">"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "="));
@@ -2751,6 +3099,7 @@ TEST(Regex_matches, ecma262_v_flag_equals_and_less_greater) {
 TEST(Regex_matches, ecma262_v_flag_curly_braces_in_class) {
   const auto regex{sourcemeta::core::to_regex("[[\\{\\}]--[\\{]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\{\\}]--[\\{]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "}"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "{"));
 }
@@ -2758,6 +3107,7 @@ TEST(Regex_matches, ecma262_v_flag_curly_braces_in_class) {
 TEST(Regex_matches, ecma262_v_flag_parentheses_in_class) {
   const auto regex{sourcemeta::core::to_regex("[[\\(\\)]--[\\(]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\(\\)]--[\\(]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ")"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "("));
 }
@@ -2766,6 +3116,8 @@ TEST(Regex_matches, ecma262_v_flag_complex_subtract_intersect_subtract) {
   const auto regex{
       sourcemeta::core::to_regex("[[[[a-z]--[aeiou]]&&[b-y]]--[xyz]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(
+      sourcemeta::core::is_regex_ecma("[[[[a-z]--[aeiou]]&&[b-y]]--[xyz]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "w"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2776,6 +3128,7 @@ TEST(Regex_matches, ecma262_v_flag_complex_subtract_intersect_subtract) {
 TEST(Regex_matches, ecma262_v_flag_ampersand_in_class) {
   const auto regex{sourcemeta::core::to_regex("[[&a]--[a]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[&a]--[a]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "&"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2783,6 +3136,7 @@ TEST(Regex_matches, ecma262_v_flag_ampersand_in_class) {
 TEST(Regex_matches, ecma262_v_flag_percent_and_hash) {
   const auto regex{sourcemeta::core::to_regex("[[%#]--[%]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[%#]--[%]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "#"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "%"));
 }
@@ -2790,6 +3144,7 @@ TEST(Regex_matches, ecma262_v_flag_percent_and_hash) {
 TEST(Regex_matches, ecma262_v_flag_colon_semicolon_comma) {
   const auto regex{sourcemeta::core::to_regex("[[:;,]--[;]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[:;,]--[;]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ":"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ","));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), ";"));
@@ -2798,6 +3153,7 @@ TEST(Regex_matches, ecma262_v_flag_colon_semicolon_comma) {
 TEST(Regex_matches, ecma262_v_flag_question_exclamation) {
   const auto regex{sourcemeta::core::to_regex("[[?!]--[?]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[?!]--[?]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "?"));
 }
@@ -2805,6 +3161,7 @@ TEST(Regex_matches, ecma262_v_flag_question_exclamation) {
 TEST(Regex_matches, ecma262_v_flag_underscore_intersect) {
   const auto regex{sourcemeta::core::to_regex("[[\\w]&&[^a-zA-Z0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\w]&&[^a-zA-Z0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
@@ -2813,6 +3170,7 @@ TEST(Regex_matches, ecma262_v_flag_underscore_intersect) {
 TEST(Regex_matches, ecma262_v_flag_digits_odd_only) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]--[02468]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]--[02468]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "1"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "3"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
@@ -2823,6 +3181,7 @@ TEST(Regex_matches, ecma262_v_flag_digits_odd_only) {
 TEST(Regex_matches, ecma262_v_flag_digits_even_only) {
   const auto regex{sourcemeta::core::to_regex("[[\\d]&&[02468]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\d]&&[02468]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "4"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "8"));
@@ -2833,6 +3192,7 @@ TEST(Regex_matches, ecma262_v_flag_digits_even_only) {
 TEST(Regex_matches, ecma262_v_flag_single_quote_double_quote) {
   const auto regex{sourcemeta::core::to_regex("[['\"']--[']]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[['\"']--[']]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\""));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "'"));
 }
@@ -2840,6 +3200,7 @@ TEST(Regex_matches, ecma262_v_flag_single_quote_double_quote) {
 TEST(Regex_matches, ecma262_v_flag_forward_slash_backslash) {
   const auto regex{sourcemeta::core::to_regex("[[\\\\]--[\\/]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[\\\\]--[\\/]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "/"));
 }
@@ -2847,16 +3208,19 @@ TEST(Regex_matches, ecma262_v_flag_forward_slash_backslash) {
 TEST(Regex_matches, ecma262_v_flag_invalid_unbalanced_parens) {
   const auto regex{sourcemeta::core::to_regex("([[a-z]--[aeiou]]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("([[a-z]--[aeiou]]"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_invalid_bad_quantifier) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--[aeiou]]{5,2}")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[[a-z]--[aeiou]]{5,2}"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_shorthand_intersection_valid) {
   const auto regex{sourcemeta::core::to_regex("[\\d&&[0-5]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\d&&[0-5]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "3"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "7"));
 }
@@ -2864,6 +3228,7 @@ TEST(Regex_matches, ecma262_v_flag_shorthand_intersection_valid) {
 TEST(Regex_matches, ecma262_v_flag_shorthand_subtraction_valid) {
   const auto regex{sourcemeta::core::to_regex("[\\w--[0-9]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\w--[0-9]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
 }
@@ -2871,6 +3236,7 @@ TEST(Regex_matches, ecma262_v_flag_shorthand_subtraction_valid) {
 TEST(Regex_matches, ecma262_v_flag_shorthand_intersection_with_range_valid) {
   const auto regex{sourcemeta::core::to_regex("[\\w&&[a-z]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\w&&[a-z]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "B"));
 }
@@ -2878,6 +3244,7 @@ TEST(Regex_matches, ecma262_v_flag_shorthand_intersection_with_range_valid) {
 TEST(Regex_matches, ecma262_v_flag_shorthand_subtract_single_valid) {
   const auto regex{sourcemeta::core::to_regex("[\\d--[0]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\d--[0]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "0"));
 }
@@ -2885,6 +3252,7 @@ TEST(Regex_matches, ecma262_v_flag_shorthand_subtract_single_valid) {
 TEST(Regex_matches, ecma262_v_flag_shorthand_to_shorthand_subtract_valid) {
   const auto regex{sourcemeta::core::to_regex("[\\w--\\d]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\w--\\d]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
 }
@@ -2892,6 +3260,7 @@ TEST(Regex_matches, ecma262_v_flag_shorthand_to_shorthand_subtract_valid) {
 TEST(Regex_matches, ecma262_v_flag_shorthand_to_shorthand_intersect_valid) {
   const auto regex{sourcemeta::core::to_regex("[\\d&&\\w]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\d&&\\w]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -2899,6 +3268,7 @@ TEST(Regex_matches, ecma262_v_flag_shorthand_to_shorthand_intersect_valid) {
 TEST(Regex_matches, ecma262_v_flag_chained_shorthand_ops_valid) {
   const auto regex{sourcemeta::core::to_regex("[\\w--\\d--[_]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\w--\\d--[_]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "_"));
@@ -2907,27 +3277,33 @@ TEST(Regex_matches, ecma262_v_flag_chained_shorthand_ops_valid) {
 TEST(Regex_matches, ecma262_v_flag_invalid_range_without_nesting) {
   const auto regex{sourcemeta::core::to_regex("[\\x61-\\x7a--[aeiou]]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[\\x61-\\x7a--[aeiou]]"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_invalid_mixed_ops_without_nesting) {
   const auto regex{sourcemeta::core::to_regex("[[a-z]--[aeiou]&&[a-m]]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[[a-z]--[aeiou]&&[a-m]]"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_invalid_unescaped_hyphen_in_class) {
   const auto regex{sourcemeta::core::to_regex("[[a-z-]--[x]]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[[a-z-]--[x]]"));
 }
 
 TEST(Regex_matches, ecma262_v_flag_invalid_unescaped_pipe) {
   const auto regex{sourcemeta::core::to_regex("[[|a]--[a]]")};
   EXPECT_FALSE(regex.has_value());
+  EXPECT_FALSE(sourcemeta::core::is_regex_ecma("[[|a]--[a]]"));
 }
 
 TEST(Regex_matches, ecma262_lookahead_with_negated_class) {
   const auto regex{
       sourcemeta::core::to_regex(R"(^(?=[^!*,;{}[\]~\n]+$)(?=(.*\w)).+$)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      R"(^(?=[^!*,;{}[\]~\n]+$)(?=(.*\w)).+$)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "hello"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test123"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "!invalid"));
@@ -2937,6 +3313,7 @@ TEST(Regex_matches, ecma262_lookahead_with_negated_class) {
 TEST(Regex_matches, ecma262_literal_open_bracket_in_class) {
   const auto regex{sourcemeta::core::to_regex("[[(]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[[(]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "["));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "("));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2945,6 +3322,7 @@ TEST(Regex_matches, ecma262_literal_open_bracket_in_class) {
 TEST(Regex_matches, ecma262_literal_close_bracket_in_class) {
   const auto regex{sourcemeta::core::to_regex(R"([)\]])")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(R"([)\]])"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ")"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -2953,6 +3331,7 @@ TEST(Regex_matches, ecma262_literal_close_bracket_in_class) {
 TEST(Regex_matches, ecma262_bracket_classes_in_complex_pattern) {
   const auto regex{sourcemeta::core::to_regex(R"(^[[(]\d+,\d+[)\]]$)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(R"(^[[(]\d+,\d+[)\]]$)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "[1,2]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "(1,2)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "[1,2)"));
@@ -2964,6 +3343,8 @@ TEST(Regex_matches, ecma262_datetime_range_pattern) {
   const auto regex{sourcemeta::core::to_regex(
       R"(^((\d{4}-\d{2}-\d{2})|([[(](((\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2}:\d{2}(.\d{1,6})?[Zz])?),(\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2}:\d{2}(.\d{1,6})?[Zz])?)?)|(,(\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2}:\d{2}(.\d{1,6})?[Zz])?)))[)\]]))$)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      R"(^((\d{4}-\d{2}-\d{2})|([[(](((\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2}:\d{2}(.\d{1,6})?[Zz])?),(\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2}:\d{2}(.\d{1,6})?[Zz])?)?)|(,(\d{4}-\d{2}-\d{2}([Tt]\d{2}:\d{2}:\d{2}(.\d{1,6})?[Zz])?)))[)\]]))$)"));
   EXPECT_TRUE(
       sourcemeta::core::matches(regex.value(), "[2023-04-28T00:00:00Z,]"));
   EXPECT_TRUE(
diff --git a/test/regex/regex_matches_rfc9485_test.cc b/test/regex/regex_matches_rfc9485_test.cc
index 418f63b6e..254506d41 100644
--- a/test/regex/regex_matches_rfc9485_test.cc
+++ b/test/regex/regex_matches_rfc9485_test.cc
@@ -9,6 +9,7 @@ TEST(Regex_matches, rfc9485_edge_dollar_literal) {
   // middle. We prefer ECMA-262 compliance where $ is ALWAYS an assertion.
   const auto regex{sourcemeta::core::to_regex("a$b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a$b"));
   // In ECMA-262, $ is always an end assertion, never a literal
   // Pattern "a$b" means: match "a", assert end, match "b"
   // This can NEVER match anything
@@ -21,6 +22,7 @@ TEST(Regex_matches, rfc9485_preprocessing_escaped_backslash_dollar) {
   // middle. We prefer ECMA-262 compliance where $ is ALWAYS an assertion.
   const auto regex{sourcemeta::core::to_regex("\\\\$foo")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\$foo"));
   // In ECMA-262: \\ = literal backslash, $ = end assertion, foo = literal "foo"
   // Pattern "\\$foo" means: match backslash, assert end, match "foo"
   // This can NEVER match anything
@@ -31,6 +33,7 @@ TEST(Regex_matches, rfc9485_preprocessing_escaped_backslash_dollar) {
 TEST(Regex_matches, rfc9485_literal_single_char) {
   const auto regex{sourcemeta::core::to_regex("a")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "xyz"));
@@ -39,6 +42,7 @@ TEST(Regex_matches, rfc9485_literal_single_char) {
 TEST(Regex_matches, rfc9485_literal_sequence) {
   const auto regex{sourcemeta::core::to_regex("hello")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("hello"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "hello"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "hello world"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "world"));
@@ -47,6 +51,7 @@ TEST(Regex_matches, rfc9485_literal_sequence) {
 TEST(Regex_matches, rfc9485_dot_wildcard) {
   const auto regex{sourcemeta::core::to_regex("a.c")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a.c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "axc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a1c"));
@@ -56,6 +61,7 @@ TEST(Regex_matches, rfc9485_dot_wildcard) {
 TEST(Regex_matches, rfc9485_quantifier_star) {
   const auto regex{sourcemeta::core::to_regex("ab*c")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("ab*c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ac"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abbc"));
@@ -66,6 +72,7 @@ TEST(Regex_matches, rfc9485_quantifier_star) {
 TEST(Regex_matches, rfc9485_quantifier_plus) {
   const auto regex{sourcemeta::core::to_regex("ab+c")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("ab+c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abbc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abbbc"));
@@ -75,6 +82,7 @@ TEST(Regex_matches, rfc9485_quantifier_plus) {
 TEST(Regex_matches, rfc9485_quantifier_question) {
   const auto regex{sourcemeta::core::to_regex("ab?c")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("ab?c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ac"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "abbc"));
@@ -83,6 +91,7 @@ TEST(Regex_matches, rfc9485_quantifier_question) {
 TEST(Regex_matches, rfc9485_quantifier_exact) {
   const auto regex{sourcemeta::core::to_regex("a{3}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{3}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaaa"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "aa"));
@@ -91,6 +100,7 @@ TEST(Regex_matches, rfc9485_quantifier_exact) {
 TEST(Regex_matches, rfc9485_quantifier_at_least) {
   const auto regex{sourcemeta::core::to_regex("a{2,}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{2,}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaaa"));
@@ -100,6 +110,7 @@ TEST(Regex_matches, rfc9485_quantifier_at_least) {
 TEST(Regex_matches, rfc9485_quantifier_range) {
   const auto regex{sourcemeta::core::to_regex("a{2,4}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{2,4}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaaa"));
@@ -110,6 +121,7 @@ TEST(Regex_matches, rfc9485_quantifier_range) {
 TEST(Regex_matches, rfc9485_alternation_simple) {
   const auto regex{sourcemeta::core::to_regex("cat|dog")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("cat|dog"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "cat"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "dog"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "bird"));
@@ -118,6 +130,7 @@ TEST(Regex_matches, rfc9485_alternation_simple) {
 TEST(Regex_matches, rfc9485_alternation_multiple) {
   const auto regex{sourcemeta::core::to_regex("red|green|blue")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("red|green|blue"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "red"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "green"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "blue"));
@@ -127,6 +140,7 @@ TEST(Regex_matches, rfc9485_alternation_multiple) {
 TEST(Regex_matches, rfc9485_alternation_empty_branch) {
   const auto regex{sourcemeta::core::to_regex("a|")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a|"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xyz"));
@@ -135,6 +149,7 @@ TEST(Regex_matches, rfc9485_alternation_empty_branch) {
 TEST(Regex_matches, rfc9485_charclass_simple) {
   const auto regex{sourcemeta::core::to_regex("[abc]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[abc]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
@@ -144,6 +159,7 @@ TEST(Regex_matches, rfc9485_charclass_simple) {
 TEST(Regex_matches, rfc9485_charclass_range) {
   const auto regex{sourcemeta::core::to_regex("[a-z]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a-z]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "m"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
@@ -154,6 +170,7 @@ TEST(Regex_matches, rfc9485_charclass_range) {
 TEST(Regex_matches, rfc9485_charclass_multiple_ranges) {
   const auto regex{sourcemeta::core::to_regex("[a-zA-Z0-9]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a-zA-Z0-9]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -163,6 +180,7 @@ TEST(Regex_matches, rfc9485_charclass_multiple_ranges) {
 TEST(Regex_matches, rfc9485_charclass_negated) {
   const auto regex{sourcemeta::core::to_regex("[^abc]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[^abc]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "d"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "x"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "1"));
@@ -173,6 +191,7 @@ TEST(Regex_matches, rfc9485_charclass_negated) {
 TEST(Regex_matches, rfc9485_charclass_dash_at_start) {
   const auto regex{sourcemeta::core::to_regex("[-abc]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[-abc]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
@@ -181,6 +200,7 @@ TEST(Regex_matches, rfc9485_charclass_dash_at_start) {
 TEST(Regex_matches, rfc9485_charclass_dash_at_end) {
   const auto regex{sourcemeta::core::to_regex("[abc-]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[abc-]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "x"));
@@ -189,6 +209,7 @@ TEST(Regex_matches, rfc9485_charclass_dash_at_end) {
 TEST(Regex_matches, rfc9485_escape_left_paren) {
   const auto regex{sourcemeta::core::to_regex("\\(test")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\(test"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "(test"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "test"));
 }
@@ -196,6 +217,7 @@ TEST(Regex_matches, rfc9485_escape_left_paren) {
 TEST(Regex_matches, rfc9485_escape_right_paren) {
   const auto regex{sourcemeta::core::to_regex("test\\)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("test\\)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test)"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "test"));
 }
@@ -203,6 +225,7 @@ TEST(Regex_matches, rfc9485_escape_right_paren) {
 TEST(Regex_matches, rfc9485_escape_left_bracket) {
   const auto regex{sourcemeta::core::to_regex("\\[test")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\[test"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "[test"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "test"));
 }
@@ -210,6 +233,7 @@ TEST(Regex_matches, rfc9485_escape_left_bracket) {
 TEST(Regex_matches, rfc9485_escape_right_bracket) {
   const auto regex{sourcemeta::core::to_regex("test\\]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("test\\]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "test"));
 }
@@ -217,6 +241,7 @@ TEST(Regex_matches, rfc9485_escape_right_bracket) {
 TEST(Regex_matches, rfc9485_escape_left_brace) {
   const auto regex{sourcemeta::core::to_regex("\\{test")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\{test"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "{test"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "test"));
 }
@@ -224,6 +249,7 @@ TEST(Regex_matches, rfc9485_escape_left_brace) {
 TEST(Regex_matches, rfc9485_escape_right_brace) {
   const auto regex{sourcemeta::core::to_regex("test\\}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("test\\}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test}"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "test"));
 }
@@ -231,6 +257,7 @@ TEST(Regex_matches, rfc9485_escape_right_brace) {
 TEST(Regex_matches, rfc9485_escape_asterisk) {
   const auto regex{sourcemeta::core::to_regex("a\\*b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\*b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a*b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "aab"));
@@ -239,6 +266,7 @@ TEST(Regex_matches, rfc9485_escape_asterisk) {
 TEST(Regex_matches, rfc9485_escape_plus) {
   const auto regex{sourcemeta::core::to_regex("a\\+b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\+b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a+b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -246,6 +274,7 @@ TEST(Regex_matches, rfc9485_escape_plus) {
 TEST(Regex_matches, rfc9485_escape_question) {
   const auto regex{sourcemeta::core::to_regex("a\\?b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\?b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a?b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -253,6 +282,7 @@ TEST(Regex_matches, rfc9485_escape_question) {
 TEST(Regex_matches, rfc9485_escape_dot) {
   const auto regex{sourcemeta::core::to_regex("a\\.b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\.b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a.b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "axb"));
 }
@@ -260,6 +290,7 @@ TEST(Regex_matches, rfc9485_escape_dot) {
 TEST(Regex_matches, rfc9485_escape_dash) {
   const auto regex{sourcemeta::core::to_regex("a\\-b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\-b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a-b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -267,6 +298,7 @@ TEST(Regex_matches, rfc9485_escape_dash) {
 TEST(Regex_matches, rfc9485_escape_newline) {
   const auto regex{sourcemeta::core::to_regex("a\\nb")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\nb"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\nb"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "anb"));
 }
@@ -274,6 +306,7 @@ TEST(Regex_matches, rfc9485_escape_newline) {
 TEST(Regex_matches, rfc9485_escape_carriage_return) {
   const auto regex{sourcemeta::core::to_regex("a\\rb")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\rb"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\rb"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "arb"));
 }
@@ -281,6 +314,7 @@ TEST(Regex_matches, rfc9485_escape_carriage_return) {
 TEST(Regex_matches, rfc9485_escape_tab) {
   const auto regex{sourcemeta::core::to_regex("a\\tb")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\tb"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\tb"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "atb"));
 }
@@ -288,6 +322,7 @@ TEST(Regex_matches, rfc9485_escape_tab) {
 TEST(Regex_matches, rfc9485_unicode_property_letter) {
   const auto regex{sourcemeta::core::to_regex("\\p{L}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{L}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "é"));
@@ -299,6 +334,7 @@ TEST(Regex_matches, rfc9485_unicode_property_letter) {
 TEST(Regex_matches, rfc9485_unicode_property_uppercase_letter) {
   const auto regex{sourcemeta::core::to_regex("\\p{Lu}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Lu}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -308,6 +344,7 @@ TEST(Regex_matches, rfc9485_unicode_property_uppercase_letter) {
 TEST(Regex_matches, rfc9485_unicode_property_lowercase_letter) {
   const auto regex{sourcemeta::core::to_regex("\\p{Ll}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Ll}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
@@ -317,6 +354,7 @@ TEST(Regex_matches, rfc9485_unicode_property_lowercase_letter) {
 TEST(Regex_matches, rfc9485_unicode_property_titlecase_letter) {
   const auto regex{sourcemeta::core::to_regex("\\p{Lt}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Lt}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u01C5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -324,6 +362,7 @@ TEST(Regex_matches, rfc9485_unicode_property_titlecase_letter) {
 TEST(Regex_matches, rfc9485_unicode_property_modifier_letter) {
   const auto regex{sourcemeta::core::to_regex("\\p{Lm}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Lm}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u02B0"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -331,6 +370,7 @@ TEST(Regex_matches, rfc9485_unicode_property_modifier_letter) {
 TEST(Regex_matches, rfc9485_unicode_property_other_letter) {
   const auto regex{sourcemeta::core::to_regex("\\p{Lo}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Lo}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "中"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -338,6 +378,7 @@ TEST(Regex_matches, rfc9485_unicode_property_other_letter) {
 TEST(Regex_matches, rfc9485_unicode_property_mark) {
   const auto regex{sourcemeta::core::to_regex("\\p{M}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{M}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0300"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -345,6 +386,7 @@ TEST(Regex_matches, rfc9485_unicode_property_mark) {
 TEST(Regex_matches, rfc9485_unicode_property_nonspacing_mark) {
   const auto regex{sourcemeta::core::to_regex("\\p{Mn}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Mn}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0300"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -352,6 +394,7 @@ TEST(Regex_matches, rfc9485_unicode_property_nonspacing_mark) {
 TEST(Regex_matches, rfc9485_unicode_property_spacing_mark) {
   const auto regex{sourcemeta::core::to_regex("\\p{Mc}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Mc}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0903"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -359,6 +402,7 @@ TEST(Regex_matches, rfc9485_unicode_property_spacing_mark) {
 TEST(Regex_matches, rfc9485_unicode_property_enclosing_mark) {
   const auto regex{sourcemeta::core::to_regex("\\p{Me}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Me}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0488"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -366,6 +410,7 @@ TEST(Regex_matches, rfc9485_unicode_property_enclosing_mark) {
 TEST(Regex_matches, rfc9485_unicode_property_number) {
   const auto regex{sourcemeta::core::to_regex("\\p{N}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{N}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0660"));
@@ -375,6 +420,7 @@ TEST(Regex_matches, rfc9485_unicode_property_number) {
 TEST(Regex_matches, rfc9485_unicode_property_decimal_number) {
   const auto regex{sourcemeta::core::to_regex("\\p{Nd}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Nd}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "0"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "9"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u0660"));
@@ -384,6 +430,7 @@ TEST(Regex_matches, rfc9485_unicode_property_decimal_number) {
 TEST(Regex_matches, rfc9485_unicode_property_letter_number) {
   const auto regex{sourcemeta::core::to_regex("\\p{Nl}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Nl}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u2160"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
 }
@@ -391,6 +438,7 @@ TEST(Regex_matches, rfc9485_unicode_property_letter_number) {
 TEST(Regex_matches, rfc9485_unicode_property_other_number) {
   const auto regex{sourcemeta::core::to_regex("\\p{No}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{No}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u00B2"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
 }
@@ -398,6 +446,7 @@ TEST(Regex_matches, rfc9485_unicode_property_other_number) {
 TEST(Regex_matches, rfc9485_unicode_property_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\p{P}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{P}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "."));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ","));
@@ -407,6 +456,7 @@ TEST(Regex_matches, rfc9485_unicode_property_punctuation) {
 TEST(Regex_matches, rfc9485_unicode_property_connector_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\p{Pc}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Pc}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "."));
 }
@@ -414,6 +464,7 @@ TEST(Regex_matches, rfc9485_unicode_property_connector_punctuation) {
 TEST(Regex_matches, rfc9485_unicode_property_dash_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\p{Pd}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Pd}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "."));
 }
@@ -421,6 +472,7 @@ TEST(Regex_matches, rfc9485_unicode_property_dash_punctuation) {
 TEST(Regex_matches, rfc9485_unicode_property_open_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\p{Ps}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Ps}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "("));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "["));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), ")"));
@@ -429,6 +481,7 @@ TEST(Regex_matches, rfc9485_unicode_property_open_punctuation) {
 TEST(Regex_matches, rfc9485_unicode_property_close_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\p{Pe}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Pe}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ")"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "("));
@@ -437,6 +490,7 @@ TEST(Regex_matches, rfc9485_unicode_property_close_punctuation) {
 TEST(Regex_matches, rfc9485_unicode_property_initial_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\p{Pi}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Pi}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u00AB"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "."));
 }
@@ -444,6 +498,7 @@ TEST(Regex_matches, rfc9485_unicode_property_initial_punctuation) {
 TEST(Regex_matches, rfc9485_unicode_property_final_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\p{Pf}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Pf}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u00BB"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "."));
 }
@@ -451,6 +506,7 @@ TEST(Regex_matches, rfc9485_unicode_property_final_punctuation) {
 TEST(Regex_matches, rfc9485_unicode_property_other_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\p{Po}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Po}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "."));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "("));
@@ -459,6 +515,7 @@ TEST(Regex_matches, rfc9485_unicode_property_other_punctuation) {
 TEST(Regex_matches, rfc9485_unicode_property_separator) {
   const auto regex{sourcemeta::core::to_regex("\\p{Z}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Z}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u00A0"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -467,6 +524,7 @@ TEST(Regex_matches, rfc9485_unicode_property_separator) {
 TEST(Regex_matches, rfc9485_unicode_property_space_separator) {
   const auto regex{sourcemeta::core::to_regex("\\p{Zs}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Zs}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), " "));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u00A0"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "\n"));
@@ -475,6 +533,7 @@ TEST(Regex_matches, rfc9485_unicode_property_space_separator) {
 TEST(Regex_matches, rfc9485_unicode_property_line_separator) {
   const auto regex{sourcemeta::core::to_regex("\\p{Zl}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Zl}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u2028"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), " "));
 }
@@ -482,6 +541,7 @@ TEST(Regex_matches, rfc9485_unicode_property_line_separator) {
 TEST(Regex_matches, rfc9485_unicode_property_paragraph_separator) {
   const auto regex{sourcemeta::core::to_regex("\\p{Zp}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Zp}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u2029"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), " "));
 }
@@ -489,6 +549,7 @@ TEST(Regex_matches, rfc9485_unicode_property_paragraph_separator) {
 TEST(Regex_matches, rfc9485_unicode_property_symbol) {
   const auto regex{sourcemeta::core::to_regex("\\p{S}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{S}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "©"));
@@ -498,6 +559,7 @@ TEST(Regex_matches, rfc9485_unicode_property_symbol) {
 TEST(Regex_matches, rfc9485_unicode_property_math_symbol) {
   const auto regex{sourcemeta::core::to_regex("\\p{Sm}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Sm}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "="));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "$"));
@@ -506,6 +568,7 @@ TEST(Regex_matches, rfc9485_unicode_property_math_symbol) {
 TEST(Regex_matches, rfc9485_unicode_property_currency_symbol) {
   const auto regex{sourcemeta::core::to_regex("\\p{Sc}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Sc}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "$"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "€"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "+"));
@@ -514,6 +577,7 @@ TEST(Regex_matches, rfc9485_unicode_property_currency_symbol) {
 TEST(Regex_matches, rfc9485_unicode_property_modifier_symbol) {
   const auto regex{sourcemeta::core::to_regex("\\p{Sk}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Sk}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "^"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "$"));
 }
@@ -521,6 +585,7 @@ TEST(Regex_matches, rfc9485_unicode_property_modifier_symbol) {
 TEST(Regex_matches, rfc9485_unicode_property_other_symbol) {
   const auto regex{sourcemeta::core::to_regex("\\p{So}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{So}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "©"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "$"));
 }
@@ -528,6 +593,7 @@ TEST(Regex_matches, rfc9485_unicode_property_other_symbol) {
 TEST(Regex_matches, rfc9485_unicode_property_other) {
   const auto regex{sourcemeta::core::to_regex("\\p{C}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{C}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string(1, '\0')));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -535,6 +601,7 @@ TEST(Regex_matches, rfc9485_unicode_property_other) {
 TEST(Regex_matches, rfc9485_unicode_property_control) {
   const auto regex{sourcemeta::core::to_regex("\\p{Cc}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Cc}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string(1, '\0')));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\x1F"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -543,6 +610,7 @@ TEST(Regex_matches, rfc9485_unicode_property_control) {
 TEST(Regex_matches, rfc9485_unicode_property_format) {
   const auto regex{sourcemeta::core::to_regex("\\p{Cf}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Cf}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\u00AD"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -550,11 +618,13 @@ TEST(Regex_matches, rfc9485_unicode_property_format) {
 TEST(Regex_matches, rfc9485_unicode_property_unassigned) {
   const auto regex{sourcemeta::core::to_regex("\\p{Cn}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Cn}"));
 }
 
 TEST(Regex_matches, rfc9485_unicode_property_private_use) {
   const auto regex{sourcemeta::core::to_regex("\\p{Co}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Co}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\uE000"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -562,6 +632,7 @@ TEST(Regex_matches, rfc9485_unicode_property_private_use) {
 TEST(Regex_matches, rfc9485_unicode_property_complement_letter) {
   const auto regex{sourcemeta::core::to_regex("\\P{L}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\P{L}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -570,6 +641,7 @@ TEST(Regex_matches, rfc9485_unicode_property_complement_letter) {
 TEST(Regex_matches, rfc9485_unicode_property_complement_number) {
   const auto regex{sourcemeta::core::to_regex("\\P{N}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\P{N}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
@@ -578,6 +650,7 @@ TEST(Regex_matches, rfc9485_unicode_property_complement_number) {
 TEST(Regex_matches, rfc9485_unicode_property_complement_punctuation) {
   const auto regex{sourcemeta::core::to_regex("\\P{P}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\P{P}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "!"));
@@ -586,6 +659,7 @@ TEST(Regex_matches, rfc9485_unicode_property_complement_punctuation) {
 TEST(Regex_matches, rfc9485_group_simple) {
   const auto regex{sourcemeta::core::to_regex("(ab)c")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(ab)c"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ac"));
 }
@@ -593,6 +667,7 @@ TEST(Regex_matches, rfc9485_group_simple) {
 TEST(Regex_matches, rfc9485_group_nested) {
   const auto regex{sourcemeta::core::to_regex("((ab)c)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("((ab)c)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ac"));
 }
@@ -600,6 +675,7 @@ TEST(Regex_matches, rfc9485_group_nested) {
 TEST(Regex_matches, rfc9485_group_with_quantifier) {
   const auto regex{sourcemeta::core::to_regex("(ab)+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(ab)+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ababab"));
@@ -609,6 +685,7 @@ TEST(Regex_matches, rfc9485_group_with_quantifier) {
 TEST(Regex_matches, rfc9485_group_with_alternation) {
   const auto regex{sourcemeta::core::to_regex("(cat|dog)s")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(cat|dog)s"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "cats"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "dogs"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "birds"));
@@ -617,6 +694,7 @@ TEST(Regex_matches, rfc9485_group_with_alternation) {
 TEST(Regex_matches, rfc9485_complex_email_like) {
   const auto regex{sourcemeta::core::to_regex("[a-z]+@[a-z]+\\.[a-z]+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a-z]+@[a-z]+\\.[a-z]+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "user@example.com"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test@test.org"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "invalid"));
@@ -625,6 +703,7 @@ TEST(Regex_matches, rfc9485_complex_email_like) {
 TEST(Regex_matches, rfc9485_complex_identifier) {
   const auto regex{sourcemeta::core::to_regex("[a-zA-Z_][a-zA-Z0-9_]*")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a-zA-Z_][a-zA-Z0-9_]*"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "variable1"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "_private"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "CONSTANT"));
@@ -634,6 +713,7 @@ TEST(Regex_matches, rfc9485_complex_identifier) {
 TEST(Regex_matches, rfc9485_complex_unicode_word) {
   const auto regex{sourcemeta::core::to_regex("\\p{L}+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{L}+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "hello"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "世界"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "مرحبا"));
@@ -643,6 +723,7 @@ TEST(Regex_matches, rfc9485_complex_unicode_word) {
 TEST(Regex_matches, rfc9485_complex_mixed_quantifiers) {
   const auto regex{sourcemeta::core::to_regex("a{2,3}b+c*")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{2,3}b+c*"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aabbb"));
@@ -653,6 +734,7 @@ TEST(Regex_matches, rfc9485_complex_mixed_quantifiers) {
 TEST(Regex_matches, rfc9485_complex_nested_groups_quantifiers) {
   const auto regex{sourcemeta::core::to_regex("((ab)+c)*")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("((ab)+c)*"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ababc"));
@@ -663,6 +745,7 @@ TEST(Regex_matches, rfc9485_complex_nested_groups_quantifiers) {
 TEST(Regex_matches, rfc9485_edge_empty_pattern) {
   const auto regex{sourcemeta::core::to_regex("")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "anything"));
 }
@@ -670,6 +753,7 @@ TEST(Regex_matches, rfc9485_edge_empty_pattern) {
 TEST(Regex_matches, rfc9485_edge_alternation_empty_first) {
   const auto regex{sourcemeta::core::to_regex("|abc")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("|abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xyz"));
@@ -678,6 +762,7 @@ TEST(Regex_matches, rfc9485_edge_alternation_empty_first) {
 TEST(Regex_matches, rfc9485_edge_alternation_empty_middle) {
   const auto regex{sourcemeta::core::to_regex("a||b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a||b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
@@ -687,6 +772,7 @@ TEST(Regex_matches, rfc9485_edge_alternation_empty_middle) {
 TEST(Regex_matches, rfc9485_edge_alternation_all_empty) {
   const auto regex{sourcemeta::core::to_regex("||")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("||"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "anything"));
 }
@@ -694,6 +780,7 @@ TEST(Regex_matches, rfc9485_edge_alternation_all_empty) {
 TEST(Regex_matches, rfc9485_edge_escape_backslash) {
   const auto regex{sourcemeta::core::to_regex("a\\\\b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\\\b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\\b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -701,6 +788,7 @@ TEST(Regex_matches, rfc9485_edge_escape_backslash) {
 TEST(Regex_matches, rfc9485_edge_escape_pipe) {
   const auto regex{sourcemeta::core::to_regex("a\\|b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\|b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a|b"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -708,12 +796,14 @@ TEST(Regex_matches, rfc9485_edge_escape_pipe) {
 TEST(Regex_matches, rfc9485_edge_caret_literal) {
   const auto regex{sourcemeta::core::to_regex("a\\^b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a\\^b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a^b"));
 }
 
 TEST(Regex_matches, rfc9485_edge_quantifier_zero_exact) {
   const auto regex{sourcemeta::core::to_regex("a{0}b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{0}b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ab"));
 }
@@ -721,6 +811,7 @@ TEST(Regex_matches, rfc9485_edge_quantifier_zero_exact) {
 TEST(Regex_matches, rfc9485_edge_quantifier_zero_or_more) {
   const auto regex{sourcemeta::core::to_regex("a{0,}b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{0,}b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaab"));
@@ -729,6 +820,7 @@ TEST(Regex_matches, rfc9485_edge_quantifier_zero_or_more) {
 TEST(Regex_matches, rfc9485_edge_quantifier_zero_to_n) {
   const auto regex{sourcemeta::core::to_regex("a{0,3}b")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{0,3}b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aab"));
@@ -739,6 +831,7 @@ TEST(Regex_matches, rfc9485_edge_quantifier_zero_to_n) {
 TEST(Regex_matches, rfc9485_edge_nested_groups_deep) {
   const auto regex{sourcemeta::core::to_regex("(((a)))")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(((a)))"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -746,6 +839,7 @@ TEST(Regex_matches, rfc9485_edge_nested_groups_deep) {
 TEST(Regex_matches, rfc9485_edge_charclass_only_dash) {
   const auto regex{sourcemeta::core::to_regex("[-]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[-]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
 }
@@ -753,6 +847,7 @@ TEST(Regex_matches, rfc9485_edge_charclass_only_dash) {
 TEST(Regex_matches, rfc9485_edge_charclass_dash_both_ends) {
   const auto regex{sourcemeta::core::to_regex("[-a-]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[-a-]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "-"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
@@ -761,6 +856,7 @@ TEST(Regex_matches, rfc9485_edge_charclass_dash_both_ends) {
 TEST(Regex_matches, rfc9485_edge_charclass_mixed_content) {
   const auto regex{sourcemeta::core::to_regex("[a-z\\p{N}._-]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a-z\\p{N}._-]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -773,6 +869,7 @@ TEST(Regex_matches, rfc9485_edge_charclass_mixed_content) {
 TEST(Regex_matches, rfc9485_edge_charclass_escaped_bracket) {
   const auto regex{sourcemeta::core::to_regex("[\\[\\]]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\[\\]]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "["));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "]"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a"));
@@ -781,6 +878,7 @@ TEST(Regex_matches, rfc9485_edge_charclass_escaped_bracket) {
 TEST(Regex_matches, rfc9485_edge_charclass_multiple_ranges) {
   const auto regex{sourcemeta::core::to_regex("[a-cA-C0-2]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a-cA-C0-2]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
@@ -798,6 +896,7 @@ TEST(Regex_matches, rfc9485_edge_charclass_multiple_ranges) {
 TEST(Regex_matches, rfc9485_edge_group_with_alternation_quantified) {
   const auto regex{sourcemeta::core::to_regex("(a|b){2}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(a|b){2}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ab"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ba"));
@@ -808,6 +907,7 @@ TEST(Regex_matches, rfc9485_edge_group_with_alternation_quantified) {
 TEST(Regex_matches, rfc9485_edge_multiple_dots) {
   const auto regex{sourcemeta::core::to_regex("...")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("..."));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "123"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a\nb"));
@@ -817,6 +917,7 @@ TEST(Regex_matches, rfc9485_edge_multiple_dots) {
 TEST(Regex_matches, rfc9485_edge_quantifier_large_range) {
   const auto regex{sourcemeta::core::to_regex("a{100,200}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a{100,200}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string(100, 'a')));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string(150, 'a')));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), std::string(200, 'a')));
@@ -826,6 +927,7 @@ TEST(Regex_matches, rfc9485_edge_quantifier_large_range) {
 TEST(Regex_matches, rfc9485_edge_alternation_with_groups) {
   const auto regex{sourcemeta::core::to_regex("(abc)|(def)|(ghi)")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(abc)|(def)|(ghi)"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "def"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "ghi"));
@@ -835,6 +937,7 @@ TEST(Regex_matches, rfc9485_edge_alternation_with_groups) {
 TEST(Regex_matches, rfc9485_edge_charclass_with_unicode_properties) {
   const auto regex{sourcemeta::core::to_regex("[\\p{Lu}\\p{Nd}]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\p{Lu}\\p{Nd}]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "Z"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -845,6 +948,8 @@ TEST(Regex_matches, rfc9485_all_major_categories_combined) {
   const auto regex{sourcemeta::core::to_regex(
       "[\\p{L}\\p{M}\\p{N}\\p{P}\\p{Z}\\p{S}\\p{C}]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "[\\p{L}\\p{M}\\p{N}\\p{P}\\p{Z}\\p{S}\\p{C}]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
@@ -855,6 +960,7 @@ TEST(Regex_matches, rfc9485_all_major_categories_combined) {
 TEST(Regex_matches, rfc9485_complement_all_major_categories) {
   const auto regex{sourcemeta::core::to_regex("\\P{L}\\P{N}\\P{P}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\P{L}\\P{N}\\P{P}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "   "));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "a  "));
 }
@@ -862,6 +968,7 @@ TEST(Regex_matches, rfc9485_complement_all_major_categories) {
 TEST(Regex_matches, rfc9485_edge_nested_quantifiers_group) {
   const auto regex{sourcemeta::core::to_regex("((a+)+)+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("((a+)+)+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aa"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "aaa"));
@@ -871,6 +978,7 @@ TEST(Regex_matches, rfc9485_edge_nested_quantifiers_group) {
 TEST(Regex_matches, rfc9485_edge_charclass_negated_with_range) {
   const auto regex{sourcemeta::core::to_regex("[^a-z]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[^a-z]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "!"));
@@ -881,6 +989,7 @@ TEST(Regex_matches, rfc9485_edge_charclass_negated_with_range) {
 TEST(Regex_matches, rfc9485_edge_consecutive_alternations) {
   const auto regex{sourcemeta::core::to_regex("a|b|c|d|e")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a|b|c|d|e"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "b"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "c"));
@@ -892,6 +1001,7 @@ TEST(Regex_matches, rfc9485_edge_consecutive_alternations) {
 TEST(Regex_matches, rfc9485_edge_group_quantifier_zero_or_one) {
   const auto regex{sourcemeta::core::to_regex("(abc)?")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("(abc)?"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abc"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "xyz"));
@@ -900,6 +1010,7 @@ TEST(Regex_matches, rfc9485_edge_group_quantifier_zero_or_one) {
 TEST(Regex_matches, rfc9485_edge_mixed_quantifiers_sequence) {
   const auto regex{sourcemeta::core::to_regex("a?b+c*d{2}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("a?b+c*d{2}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "bdd"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abdd"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "abbcdd"));
@@ -910,6 +1021,7 @@ TEST(Regex_matches, rfc9485_edge_mixed_quantifiers_sequence) {
 TEST(Regex_matches, rfc9485_edge_unicode_in_alternation) {
   const auto regex{sourcemeta::core::to_regex("\\p{Lu}|\\p{Ll}|\\p{Nd}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\p{Lu}|\\p{Ll}|\\p{Nd}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "A"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "5"));
@@ -919,6 +1031,7 @@ TEST(Regex_matches, rfc9485_edge_unicode_in_alternation) {
 TEST(Regex_matches, rfc9485_edge_charclass_single_char) {
   const auto regex{sourcemeta::core::to_regex("[a]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[a]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "a"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "b"));
 }
@@ -927,6 +1040,8 @@ TEST(Regex_matches, rfc9485_edge_complex_real_world_email_subset) {
   const auto regex{sourcemeta::core::to_regex(
       "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-z]{2,}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-z]{2,}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "test@example.com"));
   EXPECT_TRUE(
       sourcemeta::core::matches(regex.value(), "user.name+tag@example.co.uk"));
@@ -937,6 +1052,7 @@ TEST(Regex_matches, rfc9485_edge_complex_real_world_email_subset) {
 TEST(Regex_matches, rfc9485_edge_complex_real_world_hex_color) {
   const auto regex{sourcemeta::core::to_regex("#[0-9a-fA-F]{6}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("#[0-9a-fA-F]{6}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "#FF5733"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "#000000"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "#ffffff"));
@@ -947,6 +1063,8 @@ TEST(Regex_matches, rfc9485_edge_complex_real_world_uuid_partial) {
   const auto regex{sourcemeta::core::to_regex(
       "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(
+      "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"));
   EXPECT_TRUE(sourcemeta::core::matches(
       regex.value(), "550e8400-e29b-41d4-a716-446655440000"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "invalid-uuid"));
@@ -955,6 +1073,7 @@ TEST(Regex_matches, rfc9485_edge_complex_real_world_uuid_partial) {
 TEST(Regex_matches, rfc9485_preprocessing_literal_backslash_p) {
   const auto regex{sourcemeta::core::to_regex("\\\\p\\{L\\}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\p\\{L\\}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\p{L}"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));
 }
@@ -962,6 +1081,7 @@ TEST(Regex_matches, rfc9485_preprocessing_literal_backslash_p) {
 TEST(Regex_matches, rfc9485_preprocessing_literal_backslash_P) {
   const auto regex{sourcemeta::core::to_regex("\\\\P\\{N\\}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\P\\{N\\}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\P{N}"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "5"));
 }
@@ -969,6 +1089,7 @@ TEST(Regex_matches, rfc9485_preprocessing_literal_backslash_P) {
 TEST(Regex_matches, rfc9485_preprocessing_mixed_escaped_and_unicode) {
   const auto regex{sourcemeta::core::to_regex("\\\\p\\{L\\} \\p{L}")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("\\\\p\\{L\\} \\p{L}"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\\p{L} A"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A A"));
 }
@@ -976,6 +1097,7 @@ TEST(Regex_matches, rfc9485_preprocessing_mixed_escaped_and_unicode) {
 TEST(Regex_matches, rfc9485_quantifier_star_any_string) {
   const auto regex{sourcemeta::core::to_regex(".*")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(".*"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), ""));
 }
@@ -983,6 +1105,7 @@ TEST(Regex_matches, rfc9485_quantifier_star_any_string) {
 TEST(Regex_matches, rfc9485_quantifier_plus_non_empty) {
   const auto regex{sourcemeta::core::to_regex(".+")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma(".+"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "foobar"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), ""));
 }
@@ -990,18 +1113,21 @@ TEST(Regex_matches, rfc9485_quantifier_plus_non_empty) {
 TEST(Regex_matches, rfc9485_dot_matches_newline) {
   const auto regex{sourcemeta::core::to_regex(".")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("."));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\n"));
 }
 
 TEST(Regex_matches, rfc9485_dot_matches_carriage_return) {
   const auto regex{sourcemeta::core::to_regex(".")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("."));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\r"));
 }
 
 TEST(Regex_matches, rfc9485_unicode_range_4byte_deseret) {
   const auto regex{sourcemeta::core::to_regex("[\\u{10400}-\\u{1044F}]")};
   EXPECT_TRUE(regex.has_value());
+  EXPECT_TRUE(sourcemeta::core::is_regex_ecma("[\\u{10400}-\\u{1044F}]"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\U00010400"));
   EXPECT_TRUE(sourcemeta::core::matches(regex.value(), "\U0001044F"));
   EXPECT_FALSE(sourcemeta::core::matches(regex.value(), "A"));