corvus_json_schema 0.1.4 → 0.2.0

data/ext/corvus_json_schema/vendor/corvus-json-schema/src/pattern.rs

@@ -8,33 +8,75 @@
 //! - anchored sequences of quantified ASCII character classes and literals (`^[a-z][a-z0-9_]{0,29}$`, `^x-`,
 //!   `^[@$_#]`), matched in one pass over the string (the TypeScript evaluator's class-sequence fast path);
 //! - alternatives of such sequences once groups are multiplied out (`^([a|A]uto)|([n|N]one)$`,
-//!   `^[Ee][Ss]2015(\.([Cc]ore|[Pp]roxy))?$`), sets of literals, and separated lists (`^([a-z]+)(\.[a-z]+)*$`),
-//!   as the C# evaluator's pattern matchers do;
-//! - patterns within the common subset of ECMA-262 and the `regex` crate's syntax, translated with ECMA semantics
-//!   (`\d`/`\w` ASCII-only, ECMA's `\s` and `.`) and run by `regex`, which searches in linear time without
-//!   allocating per match;
-//! - anything else (lookarounds, backreferences, `\B`, modifier groups, and every pattern `regex` is not given) by
-//!   the crate's own ECMA-262 engine (`ecmaregex`), a port of the engine of the Go module. It answers every pattern
-//!   as ECMA-262 does, as the pattern is written.
+//!   `^[Ee][Ss]2015(\.([Cc]ore|[Pp]roxy))?$`) and sets of literals, as the C# evaluator's pattern matchers do,
+//!   where they were measured faster than the engine (see [`MOST_LITERALS`]);
+//! - anything else by [Corvus.Regex.Ecma262](https://docs.rs/corvus-regex-ecma262), an ECMA-262 engine that answers
+//!   every pattern as V8 does, as the pattern is written, and matches a pattern with no backreference in time
+//!   proportional to the pattern's size times the string.
 //!
-//! Whether a pattern is valid is the engine's parser's answer, whichever matcher runs it, and so are the limits of
-//! size: a pattern over one is refused before any matcher reads it.
+//! Whether a pattern is valid is the engine's answer, whichever matcher runs it, in the grammar of the edition the
+//! dialect reads patterns with (ECMAScript 2020 for draft 2019-09 and draft 2020-12, today's for the others; see
+//! [`Grammar`]), and so are the limits of size: a pattern over one is refused before any matcher reads it.
 //!
-//! Patterns compile once per process (a pattern is immutable, so identical patterns share one matcher).
+//! Patterns compile once per process for each grammar (a pattern is immutable, so identical patterns share one
+//! matcher).
 
 use std::collections::{HashMap, VecDeque};
 use std::fmt;
-use std::sync::{Arc, LazyLock, Mutex, OnceLock};
+use std::sync::{Arc, LazyLock, Mutex};
 use std::time::Duration;
 
-use crate::ecmaregex;
+use corvus_regex_ecma262::{Edition, Flags, MatchError, Regex, RegexBuilder, UnicodeVersion};
+
+use crate::dialect::Dialect;
 use crate::options::{
-    PatternMatchLimitError, PatternTooLargeError, SchemaCompilationError, SchemaCompilationErrorKind,
+    CompileOptions, PatternMatchLimitError, PatternTooLargeError, SchemaCompilationError, SchemaCompilationErrorKind,
 };
 
+/// The grammar a pattern is read in: the edition of ECMA-262 and the version of Unicode.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub(crate) struct Grammar {
+    pub edition: Edition,
+    pub unicode_version: UnicodeVersion,
+}
+
+impl Grammar {
+    /// The grammar of a dialect's patterns: the edition the options give, or by default ECMAScript 2020 for draft
+    /// 2019-09 and draft 2020-12, which cite it, and today's for the earlier drafts; and the options' version of
+    /// Unicode.
+    pub(crate) fn of(dialect: Dialect, options: &CompileOptions) -> Grammar {
+        let edition = options.regex_edition.unwrap_or(if dialect >= Dialect::Draft201909 {
+            Edition::Es2020
+        } else {
+            Edition::Current
+        });
+        Grammar { edition, unicode_version: options.regex_unicode_version }
+    }
+
+    /// The flags of the grammar of the `u` flag, or of no flag.
+    fn flags(unicode: bool) -> Flags {
+        Flags { unicode, ..Flags::default() }
+    }
+
+    /// The pattern compiled in this grammar, with the `u` flag or with none.
+    fn build(self, pattern: &str, unicode: bool) -> Result<Regex, corvus_regex_ecma262::Error> {
+        RegexBuilder::new(pattern)
+            .with_flags(Grammar::flags(unicode))
+            .edition(self.edition)
+            .unicode_version(self.unicode_version)
+            .build()
+    }
+
+    /// Whether the pattern is valid in this grammar with the `u` flag.
+    fn is_valid_unicode(self, pattern: &str) -> bool {
+        Regex::is_valid_with(pattern, Grammar::flags(true), self.edition, self.unicode_version)
+    }
+}
+
 /// A compiled `pattern`.
 pub(crate) struct Pattern {
     pub source: String,
+    grammar: Grammar,
     matcher: Matcher,
     /// What the pattern is counted as in the cache of compiled patterns, in bytes (see [`Cache`]).
     retained: usize,
@@ -49,7 +91,6 @@ enum Matcher {
         whole: bool,
     },
     Sequence(Sequence),
-    SeparatedList(SeparatedList),
     /// `.+` (`^.+` with `start`): some (the first) character is not a line terminator.
     HasContent {
         start: bool,
@@ -69,14 +110,9 @@ enum Matcher {
         set: CharSet,
         bangs: bool,
     },
-    Regex(Linear),
-    /// A pattern that is valid only without the `u` flag (an identity escape such as `\&`), so matching UTF-16 code
-    /// units: translated for `regex`, which decides it exactly on strings with no character beyond the Basic
-    /// Multilingual Plane (where code units are characters). The engine decides the rest, by code unit.
-    RegexBmp(Linear),
-    /// The crate's ECMA-262 engine: by character for a pattern with the `u` flag, and by UTF-16 code unit for one
-    /// that is valid only without it.
-    Engine(ecmaregex::Regexp),
+    /// The `corvus-regex-ecma262` engine: by character for a pattern with the `u` flag, and by UTF-16 code unit for
+    /// one that is valid only without it.
+    Engine(Box<Regex>),
 }
 
 impl fmt::Debug for Pattern {
@@ -85,55 +121,17 @@ impl fmt::Debug for Pattern {
     }
 }
 
-/// A pattern compiled by the `regex` crate, which matches in time proportional to its program times the string and
-/// cannot be stopped, with the engine for the strings it is not given.
-struct Linear {
-    re: regex::Regex,
-    /// The number of instructions estimated for the program (`ecmaregex::Facts::linear_cost`), and one at least.
-    cost: u64,
-    /// The engine for the pattern: compiled with the pattern when it is valid only without the `u` flag, and
-    /// otherwise for the first string that is too long for `regex` to answer within the limit of a match.
-    engine: OnceLock<Option<ecmaregex::Regexp>>,
-}
-
-impl Linear {
-    /// Whether `regex` answers the string within the limit of a match: its program times the string, at
-    /// [`LINEAR_STEP`] for each, is within the limit. With no limit every string is.
-    #[inline(always)]
-    fn fits(&self, s: &str, budget: &PatternBudget) -> bool {
-        (s.len() as u64).saturating_mul(self.cost) <= budget.limit.linear
-    }
-
-    #[cold]
-    fn engine(&self, source: &str) -> Option<&ecmaregex::Regexp> {
-        self.engine.get_or_init(|| ecmaregex::compile(source).ok()).as_ref()
-    }
-}
-
-/// The time the `regex` crate can take for one instruction of its program and one byte of the string, when every
-/// instruction has a thread on it (it then runs its simulation of the automaton, which is its slowest matcher). A
-/// match on `regex` cannot be stopped, so a match with a limit goes there only when the size of the program times
-/// the length of the string times this is within the limit. Any other goes to the engine, which reads the clock.
-/// The figure is the Go module's for the regexp package of Go. For the `regex` crate the most that was measured,
-/// with patterns that defeat its lazy automaton on a text of 100,000 bytes, was 3.6 ns.
-const LINEAR_STEP: Duration = Duration::from_nanos(16);
-
 /// The limit of a match, as a validator holds it.
 #[derive(Clone, Copy, Debug)]
 pub(crate) struct PatternLimit {
     /// The time one match may take, or `None` for no limit.
     limit: Option<Duration>,
-    /// The program of a `regex` matcher times the bytes of a string that the limit allows (see [`LINEAR_STEP`]).
-    linear: u64,
 }
 
 impl PatternLimit {
     /// A limit of `limit` for each match. `None` and zero are no limit.
     pub(crate) fn new(limit: Option<Duration>) -> PatternLimit {
-        let limit = limit.filter(|l| !l.is_zero());
-        let linear =
-            limit.map_or(u64::MAX, |l| u64::try_from(l.as_nanos() / LINEAR_STEP.as_nanos()).unwrap_or(u64::MAX));
-        PatternLimit { limit, linear }
+        PatternLimit { limit: limit.filter(|l| !l.is_zero()) }
     }
 }
 
@@ -164,20 +162,19 @@ impl PatternBudget {
 
     /// Matches the string on the engine within the budget. When a limit is reached the answer is false, and it is
     /// not an answer: the caller of the evaluation gets the error.
-    fn engine_match(&mut self, engine: Option<&ecmaregex::Regexp>, source: &str, s: &str) -> bool {
+    fn engine_match(&mut self, engine: &Regex, source: &str, s: &str) -> bool {
         if self.failure.is_some() {
             return false;
         }
-        let result = match engine {
-            Some(engine) => engine.match_limit(s, self.limit.limit),
-            // No engine could be made for the pattern (see `ecmaregex::compile`), so there is no answer.
-            None => Err(ecmaregex::MatchError::Memory),
+        let result = match self.limit.limit {
+            Some(limit) => engine.is_match_within(s, limit),
+            None => engine.is_match(s),
         };
         result.unwrap_or_else(|e| {
             self.failure = Some(Box::new(PatternMatchLimitError::new(
                 source,
                 self.limit.limit.unwrap_or_default(),
-                e == ecmaregex::MatchError::Memory,
+                e == MatchError::Memory,
             )));
             false
         })
@@ -199,7 +196,6 @@ impl Pattern {
                 }
             }
             Matcher::Sequence(seq) => seq.is_match(s),
-            Matcher::SeparatedList(list) => list.is_match(s),
             Matcher::HasContent { start } => {
                 if *start {
                     s.chars().next().is_some_and(|c| !is_line_terminator(c))
@@ -232,22 +228,7 @@ impl Pattern {
                 }
                 word
             }
-            Matcher::Regex(linear) => {
-                if linear.fits(s, budget) {
-                    linear.re.is_match(s)
-                } else {
-                    budget.engine_match(linear.engine(&self.source), &self.source, s)
-                }
-            }
-            // A UTF-8 lead byte of 0xF0 or above starts a character beyond the BMP.
-            Matcher::RegexBmp(linear) => {
-                if linear.fits(s, budget) && !ecmaregex::has_supplementary(s.as_bytes()) {
-                    linear.re.is_match(s)
-                } else {
-                    budget.engine_match(linear.engine(&self.source), &self.source, s)
-                }
-            }
-            Matcher::Engine(engine) => budget.engine_match(Some(engine), &self.source, s),
+            Matcher::Engine(engine) => budget.engine_match(engine, &self.source, s),
         }
     }
 }
@@ -256,14 +237,11 @@ impl Pattern {
 #[cfg(test)]
 pub(crate) fn kind(p: &Pattern) -> &'static str {
     match &p.matcher {
-        Matcher::Regex(_) => "regex",
-        Matcher::RegexBmp(..) => "regex-bmp",
-        Matcher::Engine(engine) if engine.unicode() => "engine",
+        Matcher::Engine(engine) if engine.flags().unicode => "engine",
         Matcher::Engine(_) => "engine-units",
         Matcher::Everything => "everything",
         Matcher::Literal { .. } => "literal",
         Matcher::Sequence(_) => "sequence",
-        Matcher::SeparatedList(_) => "list",
         Matcher::HasContent { .. } => "has-content",
         Matcher::Line { .. } => "line",
         Matcher::Literals(_) => "literals",
@@ -294,30 +272,34 @@ fn line_length(s: &str) -> Option<usize> {
     Some(n)
 }
 
-/// A set of strings: compared in turn when there are few, hashed otherwise.
-enum Literals {
-    Few(Box<[Box<str>]>),
-    Many(std::collections::HashSet<Box<str>>),
-}
+/// A set of at most [`MOST_LITERALS`] strings, compared in turn.
+struct Literals(Box<[Box<str>]>);
 
 impl Literals {
     fn new(texts: Vec<String>) -> Literals {
-        if texts.len() <= 8 {
-            Literals::Few(texts.into_iter().map(String::into_boxed_str).collect())
-        } else {
-            Literals::Many(texts.into_iter().map(String::into_boxed_str).collect())
-        }
+        Literals(texts.into_iter().map(String::into_boxed_str).collect())
     }
 
     #[inline]
     fn contains(&self, s: &str) -> bool {
-        match self {
-            Literals::Few(texts) => texts.iter().any(|t| **t == *s),
-            Literals::Many(set) => set.contains(s),
-        }
+        self.0.iter().any(|t| **t == *s)
     }
 }
 
+// What the dedicated matchers are kept for: each was timed against the engine, pattern by pattern, over the strings of
+// the jsonschema-benchmark corpora (`corpus_patterns::time_corpus_patterns`), and a form is kept only where its matcher
+// was the faster. Four literals compared in turn took 0.78 of the engine's time, and ten 3.2 times it. Two alternatives
+// of which neither is anchored at both ends (`^([a|A]uto)|([n|N]one)$`) took 0.21 of it, since the engine searches for
+// the unanchored one; three such took 1.4 to 1.6 times it, and every alternative anchored at both ends was faster on
+// the engine (by 1.1 to 2.7 times), which reads the whole string once whatever the alternatives. A separated list was
+// no faster than the engine (the same total time over the seven in the corpora), so it has no matcher of its own.
+
+/// The most literals of [`Matcher::Literals`].
+const MOST_LITERALS: usize = 4;
+
+/// The most alternatives of [`Matcher::Alternatives`].
+const MOST_ALTERNATIVES: usize = 2;
+
 /// One alternative of [`Matcher::Alternatives`]: a literal anchored at either end (or neither), a class sequence
 /// anchored at the start, or a fixed-width class sequence anchored at the end.
 enum Alternative {
@@ -384,22 +366,12 @@ impl Alternative {
 const MAX_CACHED_PATTERNS: usize = 1024;
 
 /// The most the patterns of the cache come to, in the bytes counted for each: 64 MiB. A pattern is counted as its
-/// source, the size the engine's parser counted for it four times over (its program is proportional to that), and
-/// for a pattern on the `regex` crate the memory estimated for that crate's program (`ecmaregex::Facts::linear_size`,
-/// which is an estimate: the crate does not say what it holds), up to three times [`REGEX_SIZE_LIMIT`].
+/// source and an estimate of what its matcher holds (see [`compile`]).
 const MAX_CACHED_BYTES: usize = 64 << 20;
 
 /// A pattern counted as more than this is compiled for the schema that has it and not kept in the cache.
 const MAX_CACHED_PATTERN_BYTES: usize = MAX_CACHED_BYTES / 32;
 
-/// The largest program the `regex` crate compiles for a pattern, in bytes: 2 MiB. (Its own default is 10 MiB.) A
-/// pattern that needs more is the engine's, which holds a class once however often the pattern repeats it.
-const REGEX_SIZE_LIMIT: usize = 2 << 20;
-
-/// The most the `regex` crate's lazy automaton caches for one pattern and one thread, in bytes: 2 MiB, which is
-/// that crate's default, said here so that it stays so.
-const REGEX_DFA_SIZE_LIMIT: usize = 2 << 20;
-
 /// The compiled patterns of the process, so that identical patterns share one matcher. It is bounded in number and
 /// in size, since the patterns of a schema may come from outside: when it is over either bound the patterns that
 /// were compiled first go, oldest first. A validator holds the patterns of its schema itself, so a pattern that has
@@ -407,16 +379,16 @@ const REGEX_DFA_SIZE_LIMIT: usize = 2 << 20;
 /// later.
 #[derive(Default)]
 struct Cache {
-    patterns: HashMap<Arc<str>, Arc<Pattern>>,
-    /// The sources in the order they were compiled.
-    order: VecDeque<Arc<str>>,
+    patterns: HashMap<(Arc<str>, Grammar), Arc<Pattern>>,
+    /// The sources and their grammars in the order they were compiled.
+    order: VecDeque<(Arc<str>, Grammar)>,
     /// The sum of what the patterns are counted as.
     bytes: usize,
 }
 
 impl Cache {
-    fn get(&self, source: &str) -> Option<Arc<Pattern>> {
-        self.patterns.get(source).cloned()
+    fn get(&self, source: &str, grammar: Grammar) -> Option<Arc<Pattern>> {
+        self.patterns.get(&(Arc::from(source), grammar)).cloned()
     }
 
     /// Keeps a pattern, and returns the one to use: the pattern itself, or the one another thread kept for the same
@@ -425,13 +397,13 @@ impl Cache {
         if pattern.retained > MAX_CACHED_PATTERN_BYTES {
             return pattern;
         }
-        if let Some(kept) = self.patterns.get(pattern.source.as_str()) {
+        let key: (Arc<str>, Grammar) = (Arc::from(pattern.source.as_str()), pattern.grammar);
+        if let Some(kept) = self.patterns.get(&key) {
             return kept.clone();
         }
-        let source: Arc<str> = Arc::from(pattern.source.as_str());
         self.bytes += pattern.retained;
-        self.patterns.insert(source.clone(), pattern.clone());
-        self.order.push_back(source);
+        self.patterns.insert(key.clone(), pattern.clone());
+        self.order.push_back(key);
         while self.patterns.len() > MAX_CACHED_PATTERNS || self.bytes > MAX_CACHED_BYTES {
             let Some(oldest) = self.order.pop_front() else { break };
             if let Some(evicted) = self.patterns.remove(&oldest) {
@@ -454,7 +426,7 @@ pub(crate) enum PatternError {
     /// It is not a valid ECMA-262 regular expression.
     Invalid,
     /// It is over a limit of size. It was not read to its end, so nothing is known of whether it is valid.
-    TooLarge(ecmaregex::TooLargeError),
+    TooLarge(corvus_regex_ecma262::TooLargeError),
 }
 
 impl PatternError {
@@ -474,11 +446,12 @@ impl PatternError {
     }
 }
 
-impl From<ecmaregex::Error> for PatternError {
-    fn from(e: ecmaregex::Error) -> PatternError {
+impl From<corvus_regex_ecma262::Error> for PatternError {
+    fn from(e: corvus_regex_ecma262::Error) -> PatternError {
         match e {
-            ecmaregex::Error::TooLarge(large) => PatternError::TooLarge(large),
-            ecmaregex::Error::Invalid(_) => PatternError::Invalid,
+            corvus_regex_ecma262::Error::TooLarge(large) => PatternError::TooLarge(large),
+            // Not valid in the grammar, or (not given here) flags that are not.
+            _ => PatternError::Invalid,
         }
     }
 }
@@ -496,79 +469,44 @@ pub(crate) fn shown_pattern(pattern: &str) -> String {
     format!("'{}...' ({} bytes)", &pattern[..cut], pattern.len())
 }
 
-/// Compiles (or fetches from the process-wide cache) a pattern.
-pub(crate) fn compile(pattern: &str) -> Result<Arc<Pattern>, PatternError> {
-    if let Some(p) = cache().get(pattern) {
+/// Compiles (or fetches from the process-wide cache) a pattern, in the grammar of its dialect.
+pub(crate) fn compile(pattern: &str, grammar: Grammar) -> Result<Arc<Pattern>, PatternError> {
+    if let Some(p) = cache().get(pattern, grammar) {
         return Ok(p);
     }
-    // The limits of size come first: nothing below reads a pattern that is over one. Validity is ECMA-262's: a
-    // pattern the engine's parser rejects is an error, whichever matcher would run it.
-    let facts = ecmaregex::check(pattern)?;
-    let matcher = match choose(pattern, &facts) {
-        Some(m) => m,
-        // Without the flag the pattern matches UTF-16 code units. `regex` matches characters, which is the same
-        // thing on a string with no character beyond the Basic Multilingual Plane.
-        None => match (!facts.unicode).then(|| linear(pattern, &facts)).flatten() {
-            Some(linear) => Matcher::RegexBmp(linear),
-            None => Matcher::Engine(ecmaregex::compile(pattern)?),
+    // Validity is ECMA-262's: a pattern the engine refuses is an error, whichever matcher would run it. A pattern is
+    // read with the u flag, and failing that with no flag, whose grammar (Annex B) many schemas need. A pattern valid
+    // with the flag that a dedicated matcher takes is read and never built: building the engine's program and
+    // automata costs far more than reading. The engine is built only for the patterns it matches, and for those over
+    // a limit of size, which it refuses (the reading refuses them too, without saying why).
+    let matcher = match grammar.is_valid_unicode(pattern).then(|| choose(pattern, true, grammar)).flatten() {
+        Some(shape) => shape,
+        None => match grammar.build(pattern, true) {
+            Ok(engine) => Matcher::Engine(Box::new(engine)),
+            Err(corvus_regex_ecma262::Error::TooLarge(large)) => return Err(PatternError::TooLarge(large)),
+            Err(_) => {
+                let engine = grammar.build(pattern, false)?;
+                choose(pattern, false, grammar).unwrap_or_else(|| Matcher::Engine(Box::new(engine)))
+            }
         },
     };
-    // What the cache counts for the pattern (see `MAX_CACHED_BYTES`).
+    // What the cache counts for the pattern (see `MAX_CACHED_BYTES`): its source, and for the engine an estimate of
+    // its program and automata, which grow with the pattern.
     let mut retained = pattern.len() + 256;
-    if matches!(matcher, Matcher::Regex(_) | Matcher::RegexBmp(_) | Matcher::Engine(_)) {
-        retained += 4 * facts.size;
-    }
-    if matches!(matcher, Matcher::Regex(_) | Matcher::RegexBmp(_)) {
-        retained += (facts.linear_size as usize).min(3 * REGEX_SIZE_LIMIT);
-    }
-    Ok(cache().insert(Arc::new(Pattern { source: pattern.to_string(), matcher, retained })))
-}
-
-/// The pattern translated for the `regex` crate and compiled by it, when it is in the syntax both have and its
-/// program is not large (see `ecmaregex::MAX_RE2_COST`: `regex` writes a counted repetition out, and takes time
-/// proportional to its program to compile and, for every character of a text, to match).
-fn linear(pattern: &str, facts: &ecmaregex::Facts) -> Option<Linear> {
-    if facts.re2_cost > ecmaregex::MAX_RE2_COST {
-        return None;
+    if matches!(matcher, Matcher::Engine(_)) {
+        retained += 16 * pattern.len();
     }
-    let translation = translate(pattern, facts.unicode)?;
-    let re = if ecmaregex::shallow(pattern) {
-        regex::RegexBuilder::new(&translation)
-            .size_limit(REGEX_SIZE_LIMIT)
-            .dfa_size_limit(REGEX_DFA_SIZE_LIMIT)
-            .build()
-            .ok()?
-    } else {
-        // `regex` reads 250 levels of nesting unless it is told otherwise, because what it does with a pattern goes
-        // a level deeper for each. A pattern that opens many groups is compiled on a thread with a stack for the
-        // 1,000 levels the engine's own limit allows (a group, its quantifier and a class inside it are three
-        // levels to `regex`), so that it is not the engine's for its nesting alone.
-        ecmaregex::deep(|| {
-            regex::RegexBuilder::new(&translation)
-                .size_limit(REGEX_SIZE_LIMIT)
-                .dfa_size_limit(REGEX_DFA_SIZE_LIMIT)
-                .nest_limit(4 * ecmaregex::MAX_NESTING as u32)
-                .build()
-                .ok()
-        })??
-    };
-    let engine = OnceLock::new();
-    if !facts.unicode || !ecmaregex::shallow(pattern) {
-        // The engine has the strings with a character beyond the Basic Multilingual Plane, so it is compiled now.
-        // So is that of a pattern that nests deeply, which is compiled on a stack of its own.
-        let _ = engine.set(Some(ecmaregex::compile(pattern).ok()?));
-    }
-    Some(Linear { re, cost: facts.linear_cost.max(1) as u64, engine })
+    Ok(cache().insert(Arc::new(Pattern { source: pattern.to_string(), grammar, matcher, retained })))
 }
 
-fn choose(pattern: &str, facts: &ecmaregex::Facts) -> Option<Matcher> {
+fn choose(pattern: &str, unicode: bool, grammar: Grammar) -> Option<Matcher> {
     // Unanchored (or start-anchored) `.*` finds an empty match in any string; `^.*$` does not (`.` stops at a line
     // terminator), so it is not listed.
     if matches!(pattern, "" | ".*" | "^.*" | ".*$" | "(.*)" | "^(.*)" | "[\\s\\S]*" | "^[\\s\\S]*" | "^[\\s\\S]*$") {
         return Some(Matcher::Everything);
     }
     // Without the `u` flag, a pattern matches UTF-16 code units rather than characters: only the engine has that.
-    if !facts.unicode {
+    if !unicode {
         return None;
     }
     match pattern {
@@ -582,9 +520,8 @@ fn choose(pattern: &str, facts: &ecmaregex::Facts) -> Option<Matcher> {
         && rest.len() > 1
         && !ends_with_escape(rest)
         && !rest.ends_with(['*', '+', '?', '}', '|', '(', '^'])
-        && let Ok(rest_facts) = ecmaregex::check(rest)
-        && rest_facts.unicode
-        && let Some(m) = choose(rest, &rest_facts)
+        && grammar.is_valid_unicode(rest)
+        && let Some(m) = choose(rest, true, grammar)
     {
         return Some(m);
     }
@@ -592,24 +529,28 @@ fn choose(pattern: &str, facts: &ecmaregex::Facts) -> Option<Matcher> {
         return Some(Matcher::Line { min, max });
     }
     if let Some(texts) = whole_alternatives(pattern) {
-        return Some(Matcher::Literals(Literals::new(texts)));
+        return (texts.len() <= MOST_LITERALS).then(|| Matcher::Literals(Literals::new(texts)));
     }
     if let Some(alts) = alternatives(pattern) {
-        return Some(Matcher::Alternatives(alts));
-    }
-    if let Some(list) = SeparatedList::parse(pattern) {
-        return Some(Matcher::SeparatedList(list));
+        let whole = |a: &Alternative| match a {
+            Alternative::Literal { start, end, .. } => *start && *end,
+            Alternative::Start(seq) => seq.to_end,
+            Alternative::End { .. } | Alternative::Anywhere { .. } => false,
+        };
+        return (alts.len() <= MOST_ALTERNATIVES && !alts.iter().any(whole)).then_some(Matcher::Alternatives(alts));
     }
     if let Some((set, bangs)) = excluded_class_with_word(pattern) {
         return Some(Matcher::ExcludedClassWithWord { set, bangs });
     }
     if let Some(seq) = Sequence::parse(pattern) {
         return Some(match seq.literal() {
+            // `^[a-z]*` with nothing it requires: every string.
+            Some(text) if text.is_empty() && !seq.to_end => Matcher::Everything,
             Some(text) => Matcher::Literal { text: text.into(), whole: seq.to_end },
             None => Matcher::Sequence(seq),
         });
     }
-    linear(pattern, facts).map(Matcher::Regex)
+    None
 }
 
 /// `^.{m,n}$` (and `^.*$`, `^.+$`, `^.{m}$`, `^.{m,}$`, each also as `^(.…)$`): the bounds on the length of a line.
@@ -867,10 +808,13 @@ fn excluded_class_with_word(p: &str) -> Option<(CharSet, bool)> {
         .then_some((excluded, bangs))
 }
 
-/// The `regex` format: a valid ECMA-262 regular expression (with the `u` flag). A string over a limit of size is
-/// not read to its end and is not valid.
-pub(crate) fn is_valid_ecma_regex(s: &str) -> bool {
-    ecmaregex::valid(s)
+/// The `regex` format: a valid ECMA-262 regular expression in the grammar of the `u` flag, of the edition and version
+/// of Unicode the dialect reads patterns with. It asks the grammar alone, as the .NET library's check does: the
+/// engine's limits of size belong to compiling a pattern, so a string too large to compile is valid when its grammar
+/// is. The engine's grammar-only reader takes time in proportion to the string and allocates nothing for one of
+/// ordinary size.
+pub(crate) fn is_valid_ecma_regex(s: &str, grammar: Grammar) -> bool {
+    Regex::is_valid_pattern_with(s, Grammar::flags(true), grammar.edition, grammar.unicode_version)
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -1028,6 +972,16 @@ impl Sequence {
                 }
             }
         }
+        if !to_end {
+            // Without `$` a match needs only the start of the string: items at the end that can match nothing are
+            // dropped, and the last of the rest needs only its least count (`^[a-z]+` is `^[a-z]`).
+            while items.last().is_some_and(|item| item.min == 0) {
+                items.pop();
+            }
+            if let Some(last) = items.last_mut() {
+                last.max = last.min;
+            }
+        }
         Some(Sequence { items: items.into_boxed_slice(), to_end })
     }
 
@@ -1083,231 +1037,6 @@ impl Sequence {
         }
         !self.to_end || at == b.len()
     }
-
-    /// Greedily matches the items at the start of `s` (ignoring `to_end`): the bytes taken.
-    fn consume(&self, s: &str) -> Option<usize> {
-        let b = s.as_bytes();
-        let mut at = 0;
-        for item in self.items.iter() {
-            let mut n = 0u32;
-            while n < item.max && at < b.len() {
-                let c = b[at];
-                if c < 0x80 {
-                    if !item.set.has_ascii(c) {
-                        break;
-                    }
-                    at += 1;
-                } else {
-                    let ch = s[at..].chars().next()?;
-                    if !item.set.contains(ch) {
-                        break;
-                    }
-                    at += ch.len_utf8();
-                }
-                n += 1;
-            }
-            if n < item.min {
-                return None;
-            }
-        }
-        Some(at)
-    }
-
-    /// Whether greedy matching is exact when `next` can follow the items: every variable item is disjoint from the
-    /// items that can directly follow it (up to the first that cannot match nothing), `next` included.
-    fn greedy_before(items: &[Item], next: CharSet) -> bool {
-        items.iter().enumerate().all(|(i, item)| {
-            if item.min == item.max {
-                return true;
-            }
-            for following in &items[i + 1..] {
-                if !item.set.disjoint(following.set) {
-                    return false;
-                }
-                if following.min > 0 {
-                    return true;
-                }
-            }
-            item.set.disjoint(next)
-        })
-    }
-}
-
-/// A list of items between separators: `^I(SR)*$` or `^I(SR)+$` (`final_` is `None`), or `^(RS)*F$` and
-/// `^(RS)+F$`. The separator is a fixed sequence and no variable class can run into what follows it, so greedy
-/// matching splits the string exactly where the pattern does.
-#[derive(Debug)]
-struct SeparatedList {
-    /// `I` of the first form.
-    first: Option<Sequence>,
-    repeated: Sequence,
-    separator: Sequence,
-    /// `F` of the second form, matched against the whole remainder.
-    final_: Option<Sequence>,
-    min_repeats: u32,
-}
-
-impl SeparatedList {
-    fn is_match(&self, s: &str) -> bool {
-        let mut rest = s;
-        let mut repeats = 0;
-        if let Some(first) = &self.first {
-            let Some(n) = first.consume(rest) else { return false };
-            rest = &rest[n..];
-            loop {
-                if rest.is_empty() {
-                    return repeats >= self.min_repeats;
-                }
-                let Some(n) = self.separator.consume(rest) else { return false };
-                rest = &rest[n..];
-                let Some(n) = self.repeated.consume(rest) else { return false };
-                rest = &rest[n..];
-                repeats += 1;
-            }
-        }
-        let final_ = self.final_.as_ref().expect("a separated list has a first or a final item");
-        // Whether the text is ASCII is worked out once, for the whole of it. The final sequence is tried after
-        // every item, and reading what is left of the text each time to see whether it is ASCII made the match take
-        // time quadratic in the number of items.
-        let ascii = s.is_ascii();
-        loop {
-            if repeats >= self.min_repeats
-                && (if ascii { final_.is_match_ascii(rest.as_bytes()) } else { final_.is_match_chars(rest) })
-            {
-                return true;
-            }
-            let Some(n) = self.repeated.consume(rest) else { return false };
-            let Some(m) = self.separator.consume(&rest[n..]) else { return false };
-            rest = &rest[n + m..];
-            repeats += 1;
-        }
-    }
-
-    fn parse(p: &str) -> Option<SeparatedList> {
-        let body = p.strip_prefix('^')?.strip_suffix('$')?;
-        if ends_with_escape(body) {
-            return None;
-        }
-        let b = body.as_bytes();
-        // Top-level groups: (start, end) of each, where end is the index of its `)`.
-        let mut groups = Vec::new();
-        let (mut depth, mut in_class, mut i, mut open) = (0usize, false, 0, 0);
-        while i < b.len() {
-            match b[i] {
-                b'\\' => i += 1,
-                b'[' if !in_class => in_class = true,
-                b']' if in_class => in_class = false,
-                b'(' if !in_class => {
-                    if depth == 0 {
-                        open = i;
-                    }
-                    depth += 1;
-                }
-                b')' if !in_class => {
-                    depth = depth.checked_sub(1)?;
-                    if depth == 0 {
-                        groups.push((open, i));
-                    }
-                }
-                _ => {}
-            }
-            i += 1;
-        }
-        let quantified: Vec<_> = groups.iter().filter(|&&(_, e)| matches!(b.get(e + 1), Some(b'*' | b'+'))).collect();
-        let &&(open, close) = quantified.first().filter(|_| quantified.len() == 1)?;
-        let min_repeats = u32::from(b[close + 1] == b'+');
-        let group = strip_group(&body[open..=close])?;
-        let before = &body[..open];
-        let after = &body[close + 2..];
-        // The items of a text that is a class sequence. A `$` at the end of the text is not an item, and the list has
-        // no place for it: `^x(,a$)*$` is not `^x(,a)*$`. Such a text is not a part of a list.
-        let items = |t: &str| Sequence::parse(&format!("^{t}")).filter(|s| !s.to_end).map(|s| s.items.into_vec());
-        let seq = |items: &[Item], to_end| Sequence { items: items.into(), to_end };
-        let fixed = |items: &[Item]| !items.is_empty() && items.iter().all(|i| i.min == i.max && i.min > 0);
-        let g = items(group)?;
-        match (before.is_empty(), after.is_empty()) {
-            // ^I(SR)*$
-            (false, true) => {
-                let first = items(unwrap_group(before)?)?;
-                (1..g.len()).find_map(|k| {
-                    let (separator, repeated) = g.split_at(k);
-                    let next = separator[0].set;
-                    (fixed(separator)
-                        && Sequence::greedy_before(&first, next)
-                        && Sequence::greedy_before(repeated, next))
-                    .then(|| SeparatedList {
-                        first: Some(seq(&first, false)),
-                        repeated: seq(repeated, false),
-                        separator: seq(separator, false),
-                        final_: None,
-                        min_repeats,
-                    })
-                })
-            }
-            // ^(RS)*F$
-            (true, false) => {
-                let final_ = Sequence::parse(&format!("^{}$", unwrap_group(after)?))?;
-                (1..g.len()).find_map(|k| {
-                    let (repeated, separator) = g.split_at(k);
-                    (fixed(separator)
-                        && Sequence::greedy_before(repeated, separator[0].set)
-                        && final_stops_at(&final_, separator[0].set))
-                    .then(|| SeparatedList {
-                        first: None,
-                        repeated: seq(repeated, false),
-                        separator: seq(separator, false),
-                        final_: Some(Sequence { items: final_.items.clone(), to_end: true }),
-                        min_repeats,
-                    })
-                })
-            }
-            _ => None,
-        }
-    }
-}
-
-/// Whether the final sequence of a list cannot read past the separator that follows an item: no item of it holds a
-/// character the first item of the separator holds. Tried at the start of an item, it then fails at that separator
-/// at the latest, so trying it after every item reads the text a bounded number of times. A final sequence that can
-/// read through separators would read to the end of the text from every item.
-fn final_stops_at(final_: &Sequence, separator: CharSet) -> bool {
-    final_.items.iter().all(|item| item.set.disjoint(separator))
-}
-
-/// The inside of `(...)` or `(?:...)`; `None` for other groups.
-fn strip_group(g: &str) -> Option<&str> {
-    let inner = g.strip_prefix('(')?.strip_suffix(')')?;
-    match inner.strip_prefix("?:") {
-        Some(rest) => Some(rest),
-        None if inner.starts_with('?') => None,
-        None => Some(inner),
-    }
-}
-
-/// A text that is one group wrapping everything, unwrapped; otherwise the text itself.
-fn unwrap_group(t: &str) -> Option<&str> {
-    if t.starts_with('(') && t.ends_with(')') {
-        let inner = strip_group(t)?;
-        // Only when the parentheses enclose the whole text (`(a)(b)` is two groups).
-        let mut depth = 0i32;
-        let mut escaped = false;
-        for c in inner.chars() {
-            match c {
-                _ if escaped => escaped = false,
-                '\\' => escaped = true,
-                '(' => depth += 1,
-                ')' => {
-                    depth -= 1;
-                    if depth < 0 {
-                        return None;
-                    }
-                }
-                _ => {}
-            }
-        }
-        return Some(inner);
-    }
-    Some(t)
 }
 
 /// The set of a class escape (`\d`, `\w`, their negations, or an escaped punctuation character); `None` for `\s`
@@ -1427,338 +1156,26 @@ fn parse_quantifier(b: &[u8], mut i: usize) -> Option<(u32, u32, usize)> {
     Some((min, max, i))
 }
 
-// ---------------------------------------------------------------------------------------------------------------------
-// Translation to the regex crate
-
-/// ECMA-262 `\s`: WhiteSpace and LineTerminator.
-const ECMA_SPACE: &str =
-    r"\t\n\x{B}\x{C}\r \x{A0}\x{1680}\x{2000}-\x{200A}\x{2028}\x{2029}\x{202F}\x{205F}\x{3000}\x{FEFF}";
-
-/// Translates an ECMA-262 pattern to the `regex` crate's syntax with the same meaning, or `None` when it uses
-/// something outside the common subset. With `unicode` false, the pattern is read without the `u` flag (identity
-/// escapes of any non-alphanumeric character), and the translation has its meaning on strings within the BMP.
-fn translate(p: &str, unicode: bool) -> Option<String> {
-    let c: Vec<char> = p.chars().collect();
-    // Without the flag a character beyond the BMP is two code units, and what is around it (a quantifier, the ends
-    // of a range) applies to one of them. That has no translation.
-    if !unicode && c.iter().any(|&ch| ch as u32 > 0xFFFF) {
-        return None;
-    }
-    let mut out = String::with_capacity(p.len() * 2);
-    let mut i = 0;
-    while i < c.len() {
-        match c[i] {
-            '\\' => {
-                let (text, next) = escape(&c, i + 1, false, unicode)?;
-                out.push_str(&text);
-                i = next;
-            }
-            '[' => {
-                let (text, next) = class(&c, i + 1, unicode)?;
-                out.push_str(&text);
-                i = next;
-            }
-            '(' => {
-                if c.get(i + 1) == Some(&'?') {
-                    match (c.get(i + 2), c.get(i + 3)) {
-                        (Some(':'), _) => i += 3,
-                        // A named group; lookbehinds (`(?<=`, `(?<!`) are not supported.
-                        (Some('<'), Some(n)) if *n != '=' && *n != '!' => {
-                            i += 3 + c[i + 3..].iter().position(|&x| x == '>')? + 1;
-                        }
-                        _ => return None,
-                    }
-                } else {
-                    i += 1;
-                }
-                out.push_str("(?:");
-            }
-            '{' => {
-                let end = i + c[i..].iter().position(|&x| x == '}')?;
-                let body: String = c[i + 1..end].iter().collect();
-                if body.is_empty() || !body.chars().all(|x| x.is_ascii_digit() || x == ',') {
-                    return None;
-                }
-                out.push('{');
-                out.push_str(&body);
-                out.push('}');
-                i = end + 1;
-            }
-            '.' => {
-                out.push_str(r"[^\n\r\x{2028}\x{2029}]");
-                i += 1;
-            }
-            ch @ (')' | '|' | '^' | '$' | '*' | '+' | '?') => {
-                out.push(ch);
-                i += 1;
-            }
-            ch => {
-                push_literal(&mut out, ch);
-                i += 1;
-            }
-        }
-    }
-    Some(out)
-}
-
-fn push_literal(out: &mut String, ch: char) {
-    use std::fmt::Write;
-    let _ = write!(out, "\\x{{{:X}}}", ch as u32);
-}
-
-/// An escape after `\` at `i`: its translation and the index after it.
-fn escape(c: &[char], i: usize, in_class: bool, unicode: bool) -> Option<(String, usize)> {
-    let e = *c.get(i)?;
-    let mut out = String::new();
-    let next = match e {
-        'd' => {
-            out.push_str(if in_class { "0-9" } else { "[0-9]" });
-            i + 1
-        }
-        'D' => {
-            out.push_str("[^0-9]");
-            i + 1
-        }
-        'w' => {
-            out.push_str(if in_class { "0-9A-Za-z_" } else { "[0-9A-Za-z_]" });
-            i + 1
-        }
-        'W' => {
-            out.push_str("[^0-9A-Za-z_]");
-            i + 1
-        }
-        's' => {
-            if in_class {
-                out.push_str(ECMA_SPACE);
-            } else {
-                out.push('[');
-                out.push_str(ECMA_SPACE);
-                out.push(']');
-            }
-            i + 1
-        }
-        'S' => {
-            out.push_str("[^");
-            out.push_str(ECMA_SPACE);
-            out.push(']');
-            i + 1
-        }
-        'n' | 'r' | 't' | 'f' | 'v' => {
-            let ch = match e {
-                'n' => '\n',
-                'r' => '\r',
-                't' => '\t',
-                'f' => '\x0C',
-                _ => '\x0B',
-            };
-            push_literal(&mut out, ch);
-            i + 1
-        }
-        '0' if !c.get(i + 1).is_some_and(char::is_ascii_digit) => {
-            push_literal(&mut out, '\0');
-            i + 1
-        }
-        'b' if in_class => {
-            push_literal(&mut out, '\x08');
-            i + 1
-        }
-        // ECMA's word boundaries are between ASCII word characters and the rest.
-        'b' => {
-            out.push_str("(?-u:\\b)");
-            i + 1
-        }
-        // `\B` has no translation. `(?-u:\B)` also holds between the bytes of a character that takes several, where
-        // no match may start or end, and `regex` 1.13.1 then says there is no match where it finds one: for
-        // `s*?(?-u:\B)|..$` on `k\u{17f}k`, `is_match` is false and `find` is not. The engine has it.
-        'B' => return None,
-        // A Unicode property is written as the ranges of the engine's own tables, and never by its name: the
-        // `regex` crate has tables of its own, of the version of Unicode its release carries, and a name would
-        // match what that version says. Without the `u` flag `\p` is the letter.
-        'p' | 'P' if unicode && c.get(i + 1) == Some(&'{') => {
-            let end = i + 1 + c[i + 1..].iter().position(|&x| x == '}')?;
-            let body: String = c[i + 2..end].iter().collect();
-            let set = ecmaregex::property_set(&body)?;
-            let negated = e == 'P';
-            if set.ranges.is_empty() {
-                // No character has the property: nothing, or with `\P` everything.
-                out.push_str(if negated { r"[\x{0}-\x{10FFFF}]" } else { r"[^\x{0}-\x{10FFFF}]" });
-            } else if in_class && !negated {
-                push_ranges(&mut out, &set);
-            } else {
-                // A class of its own, which is also how a class holds the complement of a property.
-                out.push_str(if negated { "[^" } else { "[" });
-                push_ranges(&mut out, &set);
-                out.push(']');
-            }
-            end + 1
-        }
-        'x' => {
-            let hex: String = c.get(i + 1..i + 3)?.iter().collect();
-            push_literal(&mut out, char::from_u32(u32::from_str_radix(&hex, 16).ok()?)?);
-            i + 3
-        }
-        // Without the `u` flag, `\u{...}` is not a code point escape.
-        'u' if unicode || c.get(i + 1) != Some(&'{') => {
-            let (code, next) = unicode_escape(c, i + 1)?;
-            // Without the flag, two escapes that are a surrogate pair are two code units.
-            if !unicode && code > 0xFFFF {
-                return None;
-            }
-            push_literal(&mut out, char::from_u32(code)?);
-            next
-        }
-        // Identity escapes of syntax characters and `/` (and `-` in a class).
-        '^' | '$' | '\\' | '.' | '*' | '+' | '?' | '(' | ')' | '[' | ']' | '{' | '}' | '|' | '/' | '-' => {
-            push_literal(&mut out, e);
-            i + 1
-        }
-        // Without the `u` flag, any other non-alphanumeric character escapes to itself.
-        e if !unicode && !e.is_ascii_alphanumeric() => {
-            push_literal(&mut out, e);
-            i + 1
-        }
-        // Backreferences, \c, \k and the rest.
-        _ => return None,
-    };
-    Some((out, next))
-}
-
-/// The ranges of a set, each end spelled as an escape. A surrogate is no character to the `regex` crate, and no
-/// string holds one, so a range is written without the surrogates it spans. Two ranges that then touch, one ending
-/// at U+D7FF and the next starting at U+E000, are written as one: see [`class`] for what `regex` makes of the two.
-fn push_ranges(out: &mut String, set: &ecmaregex::CharSet) {
-    // The range that has been read and not yet written.
-    let mut pending: Option<(u32, u32)> = None;
-    let write = |out: &mut String, (lo, hi): (u32, u32)| {
-        if let (Some(lo), Some(hi)) = (char::from_u32(lo), char::from_u32(hi)) {
-            push_literal(out, lo);
-            if lo != hi {
-                out.push('-');
-                push_literal(out, hi);
-            }
-        }
-    };
-    for &[lo, hi] in set.ranges.as_chunks::<2>().0 {
-        // The ends that are surrogates move out of the surrogates. A range of surrogates alone is nothing.
-        let lo = if (0xD800..=0xDFFF).contains(&lo) { 0xE000 } else { lo as u32 };
-        let hi = if (0xD800..=0xDFFF).contains(&hi) { 0xD7FF } else { hi as u32 };
-        if lo > hi {
-            continue;
-        }
-        match pending {
-            Some((first, 0xD7FF)) if lo == 0xE000 => pending = Some((first, hi)),
-            Some(range) => {
-                write(out, range);
-                pending = Some((lo, hi));
-            }
-            None => pending = Some((lo, hi)),
-        }
-    }
-    if let Some(range) = pending {
-        write(out, range);
-    }
-}
-
-/// `\u` escapes after the `u`: `XXXX` (joining a surrogate pair) or `{X...}`.
-fn unicode_escape(c: &[char], i: usize) -> Option<(u32, usize)> {
-    if c.get(i) == Some(&'{') {
-        let end = i + c[i..].iter().position(|&x| x == '}')?;
-        let hex: String = c[i + 1..end].iter().collect();
-        return Some((u32::from_str_radix(&hex, 16).ok()?, end + 1));
-    }
-    let four = |at: usize| -> Option<u32> {
-        let hex: String = c.get(at..at + 4)?.iter().collect();
-        if hex.len() != 4 {
-            return None;
-        }
-        u32::from_str_radix(&hex, 16).ok()
-    };
-    let hi = four(i)?;
-    if (0xD800..0xDC00).contains(&hi) {
-        if c.get(i + 4) == Some(&'\\') && c.get(i + 5) == Some(&'u') {
-            let lo = four(i + 6)?;
-            if (0xDC00..0xE000).contains(&lo) {
-                return Some((0x10000 + ((hi - 0xD800) << 10) + (lo - 0xDC00), i + 10));
-            }
-        }
-        return None;
-    }
-    Some((hi, i + 4))
-}
-
-/// A class after `[` at `i`: its translation (every member spelled as an escape, so nothing in it is special to the
-/// `regex` crate) and the index after `]`.
-fn class(c: &[char], mut i: usize, unicode: bool) -> Option<(String, usize)> {
-    let mut out = String::from("[");
-    if c.get(i) == Some(&'^') {
-        out.push('^');
-        i += 1;
-    }
-    let mut members = 0;
-    loop {
-        let ch = *c.get(i)?;
-        if ch == ']' {
-            i += 1;
-            break;
-        }
-        // One atom: a character (which can start a range) or a class escape.
-        let (atom, single, next) = if ch == '\\' {
-            let e = *c.get(i + 1)?;
-            let (text, next) = escape(c, i + 1, true, unicode)?;
-            let single = match e {
-                'd' | 'D' | 'w' | 'W' | 's' | 'S' | 'p' | 'P' => None,
-                _ => Some(text.clone()),
-            };
-            (text, single, next)
-        } else {
-            let mut t = String::new();
-            push_literal(&mut t, ch);
-            (t.clone(), Some(t), i + 1)
-        };
-        i = next;
-        members += 1;
-        if c.get(i) == Some(&'-') && c.get(i + 1).is_some_and(|&n| n != ']') {
-            // A range: both ends single characters.
-            let lo = single?;
-            let (hi, next) = if c[i + 1] == '\\' {
-                let e = *c.get(i + 2)?;
-                if matches!(e, 'd' | 'D' | 'w' | 'W' | 's' | 'S' | 'p' | 'P') {
-                    return None;
-                }
-                escape(c, i + 2, true, unicode)?
-            } else {
-                let mut t = String::new();
-                push_literal(&mut t, c[i + 1]);
-                (t, i + 2)
-            };
-            out.push_str(&lo);
-            out.push('-');
-            out.push_str(&hi);
-            i = next;
-        } else {
-            out.push_str(&atom);
-        }
-    }
-    if members == 0 {
-        return None; // `[]` and `[^]` have no counterpart.
-    }
-    // `regex` 1.13.1 (regex-syntax 0.8.11) negates wrongly a class with a range that ends at U+D7FF and another
-    // that starts at U+E000, the characters on either side of the surrogates: the complement takes both in, so
-    // `[^\x{D7FF}\x{E000}]` matches every character. A negated class that names both (every literal here is
-    // spelled `\x{...}`, so a `^` is a negation) is left to the engine.
-    if out.contains('^') && out.contains(r"\x{D7FF}") && out.contains(r"\x{E000}") {
-        return None;
-    }
-    out.push(']');
-    Some((out, i))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    const G: Grammar = Grammar { edition: Edition::Current, unicode_version: UnicodeVersion::Default };
+
+    /// A pattern compiled in today's grammar.
+    fn compile(p: &str) -> Result<Arc<Pattern>, PatternError> {
+        super::compile(p, G)
+    }
+
     const PATTERNS: &[&str] = &[
         "",
+        // Sequences without `$`, which need only the start of the string.
+        "^[a-z]+",
+        "^[a-z]*",
+        "^[a-zA-Z0-9_\\.\\-]*",
+        "^a[b-c]{2,5}",
+        "^[a-z]+[0-9]*",
+        "^[a-z]{0,3}[0-9]{2,4}",
         ".*",
         "^.*",
         ".*$",
@@ -1919,18 +1336,17 @@ mod tests {
             seed
         };
         for &p in PATTERNS {
-            let reference = ecmaregex::compile(p).unwrap();
+            let reference = G.build(p, true).or_else(|_| G.build(p, false)).unwrap();
             let compiled = compile(p).unwrap();
             for _ in 0..4000 {
                 let len = next() % 9;
                 let s: String = (0..len).map(|_| alphabet[(next() % alphabet.len() as u64) as usize]).collect();
                 // Without the `u` flag the engine matches the UTF-16 code units of the string.
-                let found = reference.match_backtrack(&s, None).unwrap();
+                let found = reference.is_match(&s).unwrap();
                 for limit in [None, Some(Duration::from_secs(60)), Some(Duration::from_nanos(1))] {
                     let mut budget = PatternBudget::new(PatternLimit::new(limit));
                     let got = compiled.is_match(&s, &mut budget);
-                    // A limit of a nanosecond gives `regex` no string, so this is the engine for every pattern on
-                    // it. A match that reached its first check has no answer.
+                    // A match on the engine that reached its first check of the clock has no answer.
                     assert!(got == found || budget.failed(), "{p:?} on {s:?} with a limit of {limit:?}");
                     assert!(limit.is_some_and(|l| l.as_nanos() == 1) || !budget.failed(), "{p:?} on {s:?}");
                 }
@@ -1946,71 +1362,55 @@ mod tests {
         for p in ["^x-", "^\\/", "^abc$"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::Literal { .. }), "{p}");
         }
-        for p in ["^[a-z]*a$", "(base64key|awskms)://(.*)"] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::Regex(_)), "{p}");
-        }
+        assert!(matches!(compile("^[a-z]*a$").unwrap().matcher, Matcher::Engine(_)));
         for p in [".+", "^.+", "(.+)"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::HasContent { .. }), "{p}");
         }
         for p in ["^.{1,256}$", "^.+$", "^.*$", "^(.*)$", "^(.+)$"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::Line { .. }), "{p}");
         }
-        for p in ["^(ab|cd)$", "^(?:es|ES|x-)$"] {
+        for p in ["^(ab|cd)$", "^(?:es|ES|x-)$", "^(CRLF|LF|crlf|lf)$"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::Literals(_)), "{p}");
         }
+        // Without `$`, a sequence is read only as far as it must be.
+        for p in ["^[a-z]+", "^a[b-c]{2,5}"] {
+            assert!(
+                matches!(&compile(p).unwrap().matcher, Matcher::Sequence(seq) if seq.items.last().unwrap().max == seq.items.last().unwrap().min),
+                "{p}"
+            );
+        }
+        assert!(matches!(&compile("^[a-zA-Z0-9_\\.\\-]*").unwrap().matcher, Matcher::Everything));
+        // At most two alternatives, neither anchored at both ends.
+        for p in ["^ab|cd$", "a|b", "^([a|A][u|U][t|T][o|O])|([n|N][o|O][n|N][e|E])$", "(base64key|awskms)://(.*)"] {
+            assert!(matches!(compile(p).unwrap().matcher, Matcher::Alternatives(_)), "{p}");
+        }
+        // The engine is faster for more literals, more alternatives, an alternative anchored at both ends, and a
+        // separated list.
         for p in [
-            "^ab|cd$",
-            "a|b",
-            "^([a|A][u|U][t|T][o|O])|([n|N][o|O][n|N][e|E])$",
+            "^(schemas|responses|parameters|examples|requestBodies)$",
             "^[Ee][Ss]2015(\\.([Cc][Oo][Rr][Ee]|[Pp][Rr][Oo][Xx][Yy]))?$",
             "^[1-5](?:[0-9]{2}|XX)$",
             "(^([0-9]+)\\.([0-9]+)$)|(^\\{[A-F0-9]{8}(-[A-F0-9]{4}){3}-[A-F0-9]{12}\\}$)",
             "^([t|T][o|O][p|P])|([c|C][e|E][n|N][t|T][e|E][r|R])|([b|B][o|O][t|T][t|T][o|O][m|M])$",
             "^([A-Za-z_][-A-Za-z0-9_.:]*)$",
-        ] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::Alternatives(_)), "{p}");
-        }
-        for p in [
+            "default|^[0-9]+$",
             "^([a-zA-Z0-9]{2,3})(-[a-zA-Z0-9]{1,6})*$",
             "^([a-zA-Z_$][a-zA-Z0-9_$]{0,39}\\.)*([a-zA-Z_$][a-zA-Z0-9_$]{0,39})$",
-            "^([a-z_$][a-z0-9_$]{0,39}\\.)*([a-zA-Z_$][a-zA-Z0-9_$]{0,39})$",
-            // An escaped `$` or `^` is a literal character of the list.
             "^x(,a\\$)*$",
-            "^x\\$(,a)*$",
-            "^(a\\$,)*b$",
-            "^x(,\\^a)*$",
-            "^(a,)*b\\$$",
-            "^x(,[$^]a)*$",
-        ] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::SeparatedList(_)), "{p}");
-        }
-        // A list with an anchor or an assertion inside it has no shape.
-        for p in [
             "^x(,a$)*$",
-            "^x(?:,a$)+$",
-            "^x$(,a)*$",
-            "^(x$)(,a)*$",
-            "^$(,a)*$",
-            "^(a,$)*b$",
-            "^x(^,a)*$",
-            "^(^a,)*b$",
-            "^x(,(a$))*$",
-            "^x(,a\\b)*$",
-            "^x\\B(,a)*$",
-            "^x(,a(?=,|$))*$",
             "^x(?=,)(,a)*$",
         ] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::Regex(_) | Matcher::Engine(_)), "{p}");
+            assert!(matches!(compile(p).unwrap().matcher, Matcher::Engine(_)), "{p}");
         }
         assert!(matches!(
             compile("^(?=[^!*,;{}[\\]~\\n]+$)(?=(.*\\w)).+$").unwrap().matcher,
             Matcher::ExcludedClassWithWord { .. }
         ));
         for p in ["\\bfoo", "^\\p{L}+$"] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::Regex(_)), "{p}");
+            assert!(matches!(compile(p).unwrap().matcher, Matcher::Engine(_)), "{p}");
         }
         for p in ["^\\/[^\\*\\?\\&\\%]*(\\/\\*)?$", "a\\&.b", "^\\-a"] {
-            assert!(matches!(compile(p).unwrap().matcher, Matcher::RegexBmp(..)), "{p}");
+            assert!(matches!(&compile(p).unwrap().matcher, Matcher::Engine(engine) if !engine.flags().unicode), "{p}");
         }
         for p in ["^((\\.(?!\\.)\\/)?\\w+\\/?)+$", "^\\1(a)", "\\Bs", "(?i:a)", "^[]", "\\cA"] {
             assert!(matches!(compile(p).unwrap().matcher, Matcher::Engine(_)), "{p}");
@@ -2018,7 +1418,7 @@ mod tests {
         // Valid only without the `u` flag, and not in the syntax `regex` takes: the engine, by code unit.
         for p in ["^\\p{L}\\&", "^\\-?\u{10400}*$", "^\\-(?=a)"] {
             let compiled = compile(p).unwrap();
-            assert!(matches!(&compiled.matcher, Matcher::Engine(engine) if !engine.unicode()), "{p}");
+            assert!(matches!(&compiled.matcher, Matcher::Engine(engine) if !engine.flags().unicode), "{p}");
         }
     }
 }
@@ -2027,6 +1427,13 @@ mod tests {
 mod limits {
     use super::*;
 
+    const G: Grammar = Grammar { edition: Edition::Current, unicode_version: UnicodeVersion::Default };
+
+    /// A pattern compiled in today's grammar.
+    fn compile(p: &str) -> Result<Arc<Pattern>, PatternError> {
+        super::compile(p, G)
+    }
+
     /// Which matcher a pattern gets (the Go module's `TestAWideSearchIsLeftToTheEngine`). A sequence or a literal
     /// that would be searched for at every position of the text keeps its matcher up to 64 characters, and beyond
     /// that is left to a matcher that takes time proportional to the text or has the limit of a match.
@@ -2047,55 +1454,10 @@ mod limits {
         ] {
             let found = kind(&compile(&pattern).unwrap());
             assert_eq!(found == "alternatives", alternatives, "{pattern:.30} has the matcher {found}");
-            assert!(alternatives || matches!(found, "regex" | "engine"), "{pattern:.30} has the matcher {found}");
-        }
-        // The final sequence of a list must stop at the separator.
-        for (pattern, list) in [
-            (r"^(?:[a-z]+,)*[a-z]{2}[0-9]$", true),
-            (r"^(?:[a-z]+,)*[a-z,]+[0-9]$", false),
-            (r"^(?:[a-z]+,)*[0-9]{1,3}$", true),
-        ] {
-            let found = kind(&compile(pattern).unwrap());
-            assert_eq!(found == "list", list, "{pattern} has the matcher {found}");
-        }
-    }
-
-    /// The `regex` crate is given no large program (the Go module's `TestTheRegexpPackageIsGivenNoLargeProgram`):
-    /// it writes a counted repetition out, so the pattern goes to the engine when the copies are many.
-    #[test]
-    fn regex_is_given_no_large_program() {
-        for (pattern, want) in [
-            (r"a{1000}".to_string(), "regex"),
-            (r"(?:a|b|ab)*c".to_string(), "regex"),
-            (r"\p{L}{1000}".repeat(90), "engine"),
-            (r"(?:[ab]{1000}){50}c".to_string(), "engine"),
-            (r"(?:a{100}){101}".to_string(), "engine"),
-            (r"(?:(?:a?){100}){100}b".to_string(), "engine"),
-        ] {
-            assert_eq!(kind(&compile(&pattern).unwrap()), want, "{pattern:.40}");
+            assert!(alternatives || found == "engine", "{pattern:.30} has the matcher {found}");
         }
     }
 
-    /// A string too long for `regex` to answer within the limit of a match goes to the engine, which can be
-    /// stopped (the Go module's `TestALongTextIsNotGivenToTheRegexpPackage`).
-    #[test]
-    fn a_long_string_is_not_given_to_regex() {
-        let compiled = compile(r"^(?:[a-c\u00e9]{0,500}x)*$").unwrap();
-        let Matcher::Regex(linear) = &compiled.matcher else { panic!("the pattern is on {}", kind(&compiled)) };
-        assert!(linear.cost >= 500, "a program of {} instructions", linear.cost);
-        let short = "\u{e9}abcx".to_string();
-        let long = "\u{e9}abcx".repeat(100000);
-        let second = PatternLimit::new(Some(Duration::from_secs(1)));
-        let mut budget = PatternBudget::new(second);
-        assert!(linear.fits(&short, &budget) && !linear.fits(&long, &budget), "the strings are not on each side");
-        assert!(compiled.is_match(&short, &mut budget) && linear.engine.get().is_none(), "a short string");
-        assert!(compiled.is_match(&long, &mut budget) && !budget.failed(), "a long string");
-        assert!(matches!(linear.engine.get(), Some(Some(_))), "the engine was not made for the long string");
-        // With no limit every string is `regex`'s.
-        let mut unlimited = PatternBudget::new(PatternLimit::new(None));
-        assert!(linear.fits(&long, &unlimited) && !compiled.is_match(&format!("{long}y"), &mut unlimited));
-    }
-
     /// The cache of compiled patterns is bounded in number and in size, and a pattern that has left it is still
     /// matched by whoever holds it.
     #[test]
@@ -2109,7 +1471,7 @@ mod limits {
             assert!(cache.patterns.len() <= MAX_CACHED_PATTERNS && cache.bytes <= MAX_CACHED_BYTES);
             assert_eq!(cache.patterns.len(), cache.order.len());
             assert_eq!(cache.bytes, cache.patterns.values().map(|p| p.retained).sum::<usize>());
-            assert!(cache.get("^cache-bound-0+$").is_none(), "the oldest pattern is still in the cache");
+            assert!(cache.get("^cache-bound-0+$", G).is_none(), "the oldest pattern is still in the cache");
         }
         assert!(first.is_match("cache-bound-000", &mut budget));
         assert!(held[0].is_match("cache-bound-0x", &mut budget) && !held[7].is_match("cache-bound-0x", &mut budget));
@@ -2122,154 +1484,162 @@ mod limits {
         assert!(large[0].retained > 256 << 10, "a large pattern is counted as {} bytes", large[0].retained);
         assert!(cache().bytes <= MAX_CACHED_BYTES);
         // A pattern too large for the cache is not kept at all.
-        let huge = compile(&format!("^(?=huge){}$", "a".repeat(15000))).unwrap();
-        assert!(huge.retained > MAX_CACHED_PATTERN_BYTES && cache().get(&huge.source).is_none());
+        let huge = compile(&format!("^(?=huge){}$", class.repeat(4))).unwrap();
+        assert!(huge.retained > MAX_CACHED_PATTERN_BYTES && cache().get(&huge.source, G).is_none());
     }
+}
 
-    /// The `regex` crate compiles no program over its limit of size: a class of a Unicode property repeated often
-    /// is the engine's, which holds the class once.
-    #[test]
-    fn regex_compiles_no_program_over_its_limit() {
-        for (pattern, want) in [
-            (r"^\p{L}+$", "regex"),
-            (r"^[\p{L}\p{N}_-]{1,8}$", "regex"),
-            (r"^[\p{L}\p{N}_-]{1,64}$", "engine"),
-            (r"^[\p{Alphabetic}\p{Nd}]{1,255}$", "engine"),
-        ] {
-            let compiled = compile(pattern).unwrap();
-            assert_eq!(kind(&compiled), want, "{pattern}");
-            let mut budget = PatternBudget::new(PatternLimit::new(Some(Duration::from_secs(1))));
-            assert!(compiled.is_match("caf\u{e9}", &mut budget) && !compiled.is_match("caf\u{e9}!", &mut budget));
-        }
+#[cfg(test)]
+mod corpus_patterns {
+    use std::sync::Arc;
+
+    use super::{Edition, Grammar, Pattern, PatternError, UnicodeVersion};
+
+    const G: Grammar = Grammar { edition: Edition::Current, unicode_version: UnicodeVersion::Default };
+
+    /// A pattern compiled in today's grammar.
+    fn compile(p: &str) -> Result<Arc<Pattern>, PatternError> {
+        super::compile(p, G)
     }
 
-    /// Alternatives of one character each are one class to a linear matcher, so a long alternation is a small
-    /// program, and `regex` keeps a long string for it. And a pattern that nests more deeply than `regex` reads by
-    /// default is still compiled by it, on a thread with a stack for the nesting.
+    /// Lists which matcher each pattern in `CORVUS_PATTERNS` (corpus<TAB>pattern lines) gets, and what the cache
+    /// counts for it.
     #[test]
-    fn regex_keeps_a_long_alternation_and_a_deep_nest() {
-        let alternatives: Vec<String> = (0..495u32).map(|k| char::from_u32(0x4E00 + k).unwrap().to_string()).collect();
-        let compiled = compile(&format!("(?:{})*z", alternatives.join("|"))).unwrap();
-        let Matcher::Regex(linear) = &compiled.matcher else { panic!("the alternation is on {}", kind(&compiled)) };
-        assert!(linear.cost <= 4, "a program of {} instructions", linear.cost);
-        let text = alternatives.concat().repeat(70);
-        assert!(text.len() >= 100_000);
-        let mut budget = PatternBudget::new(PatternLimit::new(Some(Duration::from_secs(1))));
-        assert!(linear.fits(&text, &budget) && !compiled.is_match(&text, &mut budget) && !budget.failed());
-        assert!(compiled.is_match(&format!("{text}z"), &mut budget) && linear.engine.get().is_none());
-
-        for depth in [300, 999] {
-            let nested = format!("^{}a{}b$", "(".repeat(depth), "*)".repeat(depth));
-            let compiled = compile(&nested).unwrap();
-            assert_eq!(kind(&compiled), "regex", "{depth} nested groups");
-            let start = std::time::Instant::now();
-            assert!(
-                compiled.is_match("aaaab", &mut budget)
-                    && !compiled.is_match("\u{e9}aaaaaaaaaaaaaaaaaaaaaaaaa", &mut budget)
-            );
-            assert!(!budget.failed() && start.elapsed() < Duration::from_secs(20), "{depth} nested groups");
+    #[ignore]
+    fn classify_corpus_patterns() {
+        let Ok(path) = std::env::var("CORVUS_PATTERNS") else { return };
+        for line in std::fs::read_to_string(path).unwrap().lines() {
+            let (corpus, p) = line.split_once('\t').unwrap();
+            let kind = compile(p).map(|c| super::kind(&c)).unwrap_or("invalid");
+            let retained = compile(p).map_or(0, |c| c.retained);
+            println!("{kind}\t{corpus}\t{p}\t{retained}");
         }
     }
 
-    /// The translation for `regex` names no Unicode class: every property is written as the ranges of the engine's
-    /// own tables, so the answer does not depend on the tables of the `regex` crate.
+    /// Times each dedicated matcher against the engine over the corpora of jsonschema-benchmark in `CORVUS_CORPORA`
+    /// (a directory of `<name>-schema.json` and `<name>-instances.jsonl`), so that a matcher the engine beats can be
+    /// removed. The inputs of a pattern are the distinct strings of the corpus's instances (for `pattern`) or their
+    /// property names (for `patternProperties`), at most 1,000. Each figure is the least of 7 rounds of at least 20 ms,
+    /// after a warm-up of 200 ms, through `Pattern::is_match` with the default limit of a match. Run it with
+    /// `cargo test --release --lib time_corpus_patterns -- --ignored --nocapture --test-threads 1`.
     #[test]
-    fn the_translation_carries_no_unicode_class() {
-        for p in [
-            r"^\p{L}+$",
-            r"\P{Lu}",
-            r"[\p{Script=Greek}\p{Nd}]",
-            r"[^\p{scx=Hira}]",
-            r"\d\w\s.",
-            r"\p{Any}\p{Assigned}\p{ASCII}",
-        ] {
-            let compiled = compile(p).unwrap();
-            assert_eq!(kind(&compiled), "regex", "{p}");
-            let translated = translate(p, true).unwrap();
-            for bad in [r"\p", r"\P", "(?i", "[[:", r"\d", r"\w", r"\s"] {
-                assert!(!translated.contains(bad), "the translation of {p} contains {bad}");
+    #[ignore]
+    fn time_corpus_patterns() {
+        use std::collections::BTreeSet;
+        use std::time::{Duration, Instant};
+
+        use super::{Literals, Matcher, PatternBudget, PatternLimit};
+
+        fn collect(v: &serde_json::Value, strings: &mut BTreeSet<String>, keys: &mut BTreeSet<String>) {
+            match v {
+                serde_json::Value::String(s) => {
+                    strings.insert(s.clone());
+                }
+                serde_json::Value::Array(a) => a.iter().for_each(|v| collect(v, strings, keys)),
+                serde_json::Value::Object(o) => o.iter().for_each(|(k, v)| {
+                    keys.insert(k.clone());
+                    collect(v, strings, keys);
+                }),
+                _ => {}
             }
         }
-        // The four scripts Unicode 17 added are in the tables, whatever the `regex` crate's own tables hold.
-        let mut budget = PatternBudget::new(PatternLimit::new(None));
-        for (p, text) in [
-            (r"^\p{sc=Sidt}$", "\u{10940}"),
-            (r"^\p{sc=Tols}$", "\u{11DB0}"),
-            (r"^\p{sc=Berf}$", "\u{16EA0}"),
-            (r"^\p{sc=Tayo}$", "\u{1E6C0}"),
-            (r"^[\p{sc=Sidt}a]$", "\u{10940}"),
-            (r"^[^\P{sc=Sidt}]$", "\u{10940}"),
-        ] {
-            let compiled = compile(p).unwrap();
-            assert_eq!(kind(&compiled), "regex", "{p}");
-            assert!(compiled.is_match(text, &mut budget) && !compiled.is_match("a!", &mut budget), "{p}");
-        }
-        // The complement of a set whose ranges meet at the surrogates, which `regex` gets wrong when it is given
-        // the two ranges: Unknown holds U+D7FC to U+D7FF and U+E000 to U+F8FF. And the same written by hand, which
-        // is the engine's.
-        for (p, want) in [
-            (r"^\P{sc=Unknown}$", "regex"),
-            (r"^[^\p{scx=Unknown}]$", "regex"),
-            (r"^[^\p{Script=Unknown}a]$", "regex"),
-            (r"^[^\ud7ff\ue000]$", "engine"),
-            (r"^[^\ud7fc-\ud7ff\ue000-\uf8ff]$", "engine"),
-            (r"^[^\p{Co}\ud7ff]$", "engine"),
-            (r"^[^\p{Cn}\ue000]$", "engine"),
-        ] {
-            let compiled = compile(p).unwrap();
-            assert_eq!(kind(&compiled), want, "{p}");
-            let engine = ecmaregex::compile(p).unwrap();
-            for text in ["\u{D7FB}", "\u{D7FC}", "\u{D7FF}", "\u{E000}", "\u{E001}", "\u{F8FF}", "\u{F900}", "a", "b"] {
-                assert_eq!(
-                    compiled.is_match(text, &mut budget),
-                    engine.match_backtrack(text, None).unwrap(),
-                    "{p} on {text:?}"
-                );
+        fn patterns(v: &serde_json::Value, out: &mut BTreeSet<(&'static str, String)>) {
+            match v {
+                serde_json::Value::Array(a) => a.iter().for_each(|v| patterns(v, out)),
+                serde_json::Value::Object(o) => {
+                    if let Some(serde_json::Value::String(p)) = o.get("pattern") {
+                        out.insert(("pattern", p.clone()));
+                    }
+                    if let Some(serde_json::Value::Object(pp)) = o.get("patternProperties") {
+                        pp.keys().for_each(|p| {
+                            out.insert(("patternProperties", p.clone()));
+                        });
+                    }
+                    o.values().for_each(|v| patterns(v, out));
+                }
+                _ => {}
             }
-            assert!(!compiled.is_match("\u{E000}", &mut budget), "{p} matches U+E000");
-        }
-        // A set with a range on each side of the surrogates and none of them is written as one range, and a range
-        // of surrogates alone as nothing.
-        let mut written = String::new();
-        push_ranges(&mut written, &ecmaregex::CharSet::new(&[0x61, 0x7A, 0xD700, 0xD7FF, 0xE000, 0xE0FF], false));
-        assert_eq!(written, r"\x{61}-\x{7A}\x{D700}-\x{E0FF}");
-        written.clear();
-        push_ranges(&mut written, &ecmaregex::CharSet::new(&[0xD7FF, 0xDBFF, 0xDC00, 0xDFFF, 0xDFFF, 0xE000], false));
-        assert_eq!(written, r"\x{D7FF}-\x{E000}");
-        written.clear();
-        push_ranges(&mut written, &ecmaregex::CharSet::new(&[0xD800, 0xDFFF], false));
-        assert_eq!(written, "");
-        // A property no character has, and its complement.
-        for (p, yes, no) in
-            [(r"^\P{sc=Hrkt}$", "a", "aa"), (r"^[\p{sc=Hrkt}a]$", "a", "b"), (r"^[^\P{sc=Hrkt}]?$", "", "a")]
-        {
-            let compiled = compile(p).unwrap();
-            assert_eq!(kind(&compiled), "regex", "{p}");
-            assert!(compiled.is_match(yes, &mut budget) && !compiled.is_match(no, &mut budget), "{p}");
         }
-    }
-}
-
-#[cfg(test)]
-mod corpus_patterns {
-    /// Lists which matcher each pattern in `CORVUS_PATTERNS` (corpus<TAB>pattern lines) gets.
-    #[test]
-    #[ignore]
-    fn classify_corpus_patterns() {
-        let Ok(path) = std::env::var("CORVUS_PATTERNS") else { return };
-        for line in std::fs::read_to_string(path).unwrap().lines() {
-            let (corpus, p) = line.split_once('\t').unwrap();
-            let kind = super::compile(p).map(|c| super::kind(&c)).unwrap_or("invalid");
-            // What the `regex` crate is given: the translation.
-            let unicode = crate::ecmaregex::valid(p);
-            let given = match kind {
-                "regex" | "regex-bmp" => super::translate(p, unicode).unwrap_or_default(),
-                _ => String::new(),
+        fn time(p: &Pattern, inputs: &[String]) -> f64 {
+            let limit = PatternLimit::new(Some(crate::DEFAULT_PATTERN_MATCH_LIMIT));
+            let pass = || {
+                let mut budget = PatternBudget::new(limit);
+                inputs.iter().filter(|s| p.is_match(s, &mut budget)).count()
             };
-            // And what the cache counts for the pattern, which for a pattern on `regex` holds the estimate of
-            // that crate's program.
-            let retained = super::compile(p).map_or(0, |c| c.retained);
-            println!("{kind}\t{corpus}\t{p}\t{given}\t{retained}");
+            let warm = Instant::now();
+            while warm.elapsed() < Duration::from_millis(200) {
+                std::hint::black_box(pass());
+            }
+            let mut best = f64::MAX;
+            for _ in 0..7 {
+                let (start, mut calls) = (Instant::now(), 0usize);
+                while start.elapsed() < Duration::from_millis(20) {
+                    std::hint::black_box(pass());
+                    calls += inputs.len();
+                }
+                best = best.min(start.elapsed().as_nanos() as f64 / calls as f64);
+            }
+            best
+        }
+
+        let Ok(dir) = std::env::var("CORVUS_CORPORA") else { return };
+        let mut names: Vec<String> = std::fs::read_dir(&dir)
+            .unwrap()
+            .filter_map(|e| e.unwrap().file_name().to_str()?.strip_suffix("-schema.json").map(str::to_string))
+            .collect();
+        names.sort();
+        // The alternatives a matcher tries one after another.
+        fn alternatives(m: &Matcher) -> usize {
+            match m {
+                Matcher::Alternatives(a) => a.len(),
+                Matcher::Literals(Literals(t)) => t.len(),
+                _ => 1,
+            }
+        }
+        println!("corpus\trole\tkind\talternatives\tshape ns\tengine ns\tshape/engine\tinputs\tpattern");
+        for name in names {
+            let schema: serde_json::Value =
+                serde_json::from_str(&std::fs::read_to_string(format!("{dir}/{name}-schema.json")).unwrap()).unwrap();
+            let (mut strings, mut keys) = (BTreeSet::new(), BTreeSet::new());
+            for line in std::fs::read_to_string(format!("{dir}/{name}-instances.jsonl")).unwrap().lines() {
+                if !line.trim().is_empty() {
+                    collect(&serde_json::from_str(line).unwrap(), &mut strings, &mut keys);
+                }
+            }
+            let strings: Vec<String> = strings.into_iter().take(1000).collect();
+            let keys: Vec<String> = keys.into_iter().take(1000).collect();
+            let mut found = BTreeSet::new();
+            patterns(&schema, &mut found);
+            for (role, source) in found {
+                let Ok(shape) = compile(&source) else { continue };
+                if matches!(shape.matcher, Matcher::Engine(_)) {
+                    continue;
+                }
+                let inputs = if role == "pattern" { &strings } else { &keys };
+                if inputs.is_empty() {
+                    continue;
+                }
+                let regex = G.build(&source, true).or_else(|_| G.build(&source, false)).unwrap();
+                let engine = Pattern {
+                    source: source.clone(),
+                    grammar: G,
+                    matcher: Matcher::Engine(Box::new(regex)),
+                    retained: 0,
+                };
+                // The two must agree before their times mean anything.
+                let mut budget = PatternBudget::new(PatternLimit::new(None));
+                for s in inputs {
+                    assert_eq!(shape.is_match(s, &mut budget), engine.is_match(s, &mut budget), "{source:?} on {s:?}");
+                }
+                let (a, b) = (time(&shape, inputs), time(&engine, inputs));
+                println!(
+                    "{name}\t{role}\t{}\t{}\t{a:.1}\t{b:.1}\t{:.3}\t{}\t{source}",
+                    super::kind(&shape),
+                    alternatives(&shape.matcher),
+                    a / b,
+                    inputs.len()
+                );
+            }
         }
     }
 }