corvus_json_schema 0.1.3 → 0.1.4

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

@@ -272,11 +272,9 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
         };
         let legacy = dialect.is_legacy();
 
-        if legacy {
-            if let Some(Value::String(r)) = e.get("$ref") {
-                // In draft 7 and earlier, $ref replaces every sibling keyword.
-                return self.compile_ref(id, target, r);
-            }
+        if legacy && let Some(Value::String(r)) = e.get("$ref") {
+            // In draft 7 and earlier, $ref replaces every sibling keyword.
+            return self.compile_ref(id, target, r);
         }
 
         let applicator = legacy || voc & vocab::APPLICATOR != 0;
@@ -295,15 +293,15 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
         if let Some(Value::String(r)) = e.get("$ref") {
             self.compile_ref(id, target, r)?;
         }
-        if dialect >= Dialect::Draft202012 {
-            if let Some(Value::String(r)) = e.get("$dynamicRef") {
-                self.compile_dynamic_ref(id, target, r, false)?;
-            }
+        if dialect >= Dialect::Draft202012
+            && let Some(Value::String(r)) = e.get("$dynamicRef")
+        {
+            self.compile_dynamic_ref(id, target, r, false)?;
         }
-        if dialect == Dialect::Draft201909 {
-            if let Some(Value::String(r)) = e.get("$recursiveRef") {
-                self.compile_dynamic_ref(id, target, r, true)?;
-            }
+        if dialect == Dialect::Draft201909
+            && let Some(Value::String(r)) = e.get("$recursiveRef")
+        {
+            self.compile_dynamic_ref(id, target, r, true)?;
         }
 
         // Applicators.
@@ -321,18 +319,18 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                 let c = self.child(target, v, "/not");
                 self.nodes[id as usize].not = Some(c);
             }
-            if dialect >= Dialect::Draft7 {
-                if let Some(v) = e.get("if") {
-                    let c = self.child(target, v, "/if");
-                    self.nodes[id as usize].if_ = Some(c);
-                    if let Some(v) = e.get("then") {
-                        let c = self.child(target, v, "/then");
-                        self.nodes[id as usize].then = Some(c);
-                    }
-                    if let Some(v) = e.get("else") {
-                        let c = self.child(target, v, "/else");
-                        self.nodes[id as usize].else_ = Some(c);
-                    }
+            if dialect >= Dialect::Draft7
+                && let Some(v) = e.get("if")
+            {
+                let c = self.child(target, v, "/if");
+                self.nodes[id as usize].if_ = Some(c);
+                if let Some(v) = e.get("then") {
+                    let c = self.child(target, v, "/then");
+                    self.nodes[id as usize].then = Some(c);
+                }
+                if let Some(v) = e.get("else") {
+                    let c = self.child(target, v, "/else");
+                    self.nodes[id as usize].else_ = Some(c);
                 }
             }
             if let Some(Value::Object(props)) = e.get("properties") {
@@ -346,11 +344,7 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             if let Some(Value::Object(pp)) = e.get("patternProperties") {
                 let mut list = Vec::with_capacity(pp.len());
                 for (pattern, v) in pp {
-                    let compiled = crate::pattern::compile(pattern).ok_or_else(|| {
-                        SchemaCompilationError::new(format!(
-                            "Invalid regular expression '{pattern}' in patternProperties."
-                        ))
-                    })?;
+                    let compiled = crate::pattern::compile(pattern).map_err(|e| e.of(pattern, "patternProperties"))?;
                     let c = self.child(target, v, &format!("/patternProperties/{}", escape_pointer_token(pattern)));
                     list.push(PatternProperty { pattern: compiled, node: c });
                 }
@@ -384,11 +378,11 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                     self.nodes[id as usize].prefix_items =
                         self.child_array(target, e.get("prefixItems"), "prefixItems");
                 }
-                if let Some(v) = e.get("items") {
-                    if !v.is_array() {
-                        let c = self.child(target, v, &kw("items"));
-                        self.nodes[id as usize].items = Some(c);
-                    }
+                if let Some(v) = e.get("items")
+                    && !v.is_array()
+                {
+                    let c = self.child(target, v, &kw("items"));
+                    self.nodes[id as usize].items = Some(c);
                 }
             } else if let Some(v) = e.get("items") {
                 if v.is_array() {
@@ -431,10 +425,10 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                 n.type_mask = mask;
                 n.has_type = true;
             }
-            if dialect >= Dialect::Draft6 {
-                if let Some(c) = e.get("const") {
-                    n.const_value = Some(c.clone());
-                }
+            if dialect >= Dialect::Draft6
+                && let Some(c) = e.get("const")
+            {
+                n.const_value = Some(c.clone());
             }
             if let Some(Value::Array(values)) = e.get("enum") {
                 n.enum_values = Some(values.clone());
@@ -450,18 +444,18 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                 n.required_list = Some(list);
                 n.required = Some(dedup);
             }
-            if dialect >= Dialect::Draft201909 {
-                if let Some(Value::Object(dr)) = e.get("dependentRequired") {
-                    let deps = dependencies.get_or_insert_with(Vec::new);
-                    for (name, v) in dr {
-                        if let Value::Array(list) = v {
-                            deps.push(DependencyEntry {
-                                keyword: DependencyKeyword::DependentRequired,
-                                name: name.clone(),
-                                required: Some(strings(list)),
-                                schema: None,
-                            });
-                        }
+            if dialect >= Dialect::Draft201909
+                && let Some(Value::Object(dr)) = e.get("dependentRequired")
+            {
+                let deps = dependencies.get_or_insert_with(Vec::new);
+                for (name, v) in dr {
+                    if let Value::Array(list) = v {
+                        deps.push(DependencyEntry {
+                            keyword: DependencyKeyword::DependentRequired,
+                            name: name.clone(),
+                            required: Some(strings(list)),
+                            schema: None,
+                        });
                     }
                 }
             }
@@ -473,9 +467,7 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             n.min_length = get_uint(e.get("minLength"));
             n.max_length = get_uint(e.get("maxLength"));
             if let Some(Value::String(p)) = e.get("pattern") {
-                n.pattern = Some(crate::pattern::compile(p).ok_or_else(|| {
-                    SchemaCompilationError::new(format!("Invalid regular expression '{p}' in pattern."))
-                })?);
+                n.pattern = Some(crate::pattern::compile(p).map_err(|e| e.of(p, "pattern"))?);
             }
             if let Some(Value::Number(m)) = e.get("multipleOf") {
                 n.multiple_of = Some(m.clone());
@@ -577,17 +569,17 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
                 }
             }
         }
-        if dialect >= Dialect::Draft201909 {
-            if let Some(Value::Object(ds)) = e.get("dependentSchemas") {
-                for (name, v) in ds {
-                    let c = self.child(target, v, &format!("/dependentSchemas/{}", escape_pointer_token(name)));
-                    out.push(DependencyEntry {
-                        keyword: DependencyKeyword::DependentSchemas,
-                        name: name.clone(),
-                        required: None,
-                        schema: Some(c),
-                    });
-                }
+        if dialect >= Dialect::Draft201909
+            && let Some(Value::Object(ds)) = e.get("dependentSchemas")
+        {
+            for (name, v) in ds {
+                let c = self.child(target, v, &format!("/dependentSchemas/{}", escape_pointer_token(name)));
+                out.push(DependencyEntry {
+                    keyword: DependencyKeyword::DependentSchemas,
+                    name: name.clone(),
+                    required: None,
+                    schema: Some(c),
+                });
             }
         }
         out
@@ -906,15 +898,15 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
 
     fn compute_discriminators(&mut self) {
         for i in 0..self.nodes.len() {
-            if let Some(branches) = self.nodes[i].one_of.clone() {
-                if branches.len() > 1 {
-                    self.nodes[i].one_of_discriminator = self.build_discriminator(&branches).map(Box::new);
-                }
+            if let Some(branches) = self.nodes[i].one_of.clone()
+                && branches.len() > 1
+            {
+                self.nodes[i].one_of_discriminator = self.build_discriminator(&branches).map(Box::new);
             }
-            if let Some(branches) = self.nodes[i].any_of.clone() {
-                if branches.len() > 1 {
-                    self.nodes[i].any_of_discriminator = self.build_discriminator(&branches).map(Box::new);
-                }
+            if let Some(branches) = self.nodes[i].any_of.clone()
+                && branches.len() > 1
+            {
+                self.nodes[i].any_of_discriminator = self.build_discriminator(&branches).map(Box::new);
             }
         }
     }
@@ -986,32 +978,32 @@ impl<'l, 'o> SchemaCompiler<'l, 'o> {
             return Class::Wildcard;
         };
         let p = self.effective_node(child);
-        if let Some(c) = &p.const_value {
-            if let Some(v) = primitive(c) {
-                return Class::Positive(vec![v]);
-            }
+        if let Some(c) = &p.const_value
+            && let Some(v) = primitive(c)
+        {
+            return Class::Positive(vec![v]);
         }
-        if let Some(values) = &p.enum_values {
-            if !values.is_empty() {
-                let prims: Vec<DiscriminatorValue> = values.iter().filter_map(primitive).collect();
-                if prims.len() == values.len() {
-                    return Class::Positive(prims);
-                }
+        if let Some(values) = &p.enum_values
+            && !values.is_empty()
+        {
+            let prims: Vec<DiscriminatorValue> = values.iter().filter_map(primitive).collect();
+            if prims.len() == values.len() {
+                return Class::Positive(prims);
             }
         }
-        if let Some(not) = p.not {
-            if p.has_type && p.type_mask == type_mask::STRING {
-                let not = self.effective_node(not);
-                if let Some(values) = &not.enum_values {
-                    if values.iter().all(Value::is_string)
-                        && !not.has_type
-                        && not.const_value.is_none()
-                        && !not.has_string_keywords()
-                        && !not.has_in_place_applicators()
-                    {
-                        return Class::Negative(values.iter().filter_map(primitive).collect());
-                    }
-                }
+        if let Some(not) = p.not
+            && p.has_type
+            && p.type_mask == type_mask::STRING
+        {
+            let not = self.effective_node(not);
+            if let Some(values) = &not.enum_values
+                && values.iter().all(Value::is_string)
+                && !not.has_type
+                && not.const_value.is_none()
+                && !not.has_string_keywords()
+                && !not.has_in_place_applicators()
+            {
+                return Class::Negative(values.iter().filter_map(primitive).collect());
             }
         }
         Class::Wildcard

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

@@ -552,9 +552,9 @@ impl<'s> Parser<'s> {
             return;
         }
         let mut kept: Vec<Node> = Vec::with_capacity(pairs.len());
-        for p in pairs.chunks_exact(2) {
+        for p in pairs.as_chunks::<2>().0 {
             let name = self.key_str(&p[0]);
-            match kept.chunks_exact(2).position(|q| self.key_str(&q[0]) == name) {
+            match kept.as_chunks::<2>().0.iter().position(|q| self.key_str(&q[0]) == name) {
                 Some(at) => kept[2 * at + 1] = p[1],
                 None => kept.extend_from_slice(p),
             }

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

@@ -0,0 +1,271 @@
+//! Sets of code points, the classes ECMA-262 defines, and the sets of the Unicode properties (`charset.go`).
+
+use std::collections::HashMap;
+use std::sync::{Arc, LazyLock, Mutex};
+
+use super::Rune;
+use super::ucd;
+
+/// The last Unicode code point.
+pub(crate) const MAX_RUNE: Rune = ucd::MAX_RUNE;
+
+/// An immutable set of code points. The ranges are sorted, inclusive, and neither overlap nor touch. The two words
+/// of `ascii` repeat the membership of the code points below 128 so that the common case is one bit test.
+#[derive(Debug, PartialEq, Eq)]
+pub(crate) struct CharSet {
+    pub(crate) ranges: Vec<Rune>,
+    pub(crate) ascii: [u64; 2],
+}
+
+impl CharSet {
+    /// Builds a set from inclusive pairs in any order, which may overlap. With `negate` it builds the complement.
+    pub(crate) fn new(pairs: &[Rune], negate: bool) -> CharSet {
+        let mut idx: Vec<usize> = (0..pairs.len() / 2).collect();
+        idx.sort_by_key(|&i| pairs[2 * i]);
+        let mut merged: Vec<Rune> = Vec::with_capacity(pairs.len());
+        for i in idx {
+            let (lo, hi) = (pairs[2 * i], pairs[2 * i + 1]);
+            if let Some(last) = merged.last_mut()
+                && lo <= *last + 1
+            {
+                if hi > *last {
+                    *last = hi;
+                }
+                continue;
+            }
+            merged.push(lo);
+            merged.push(hi);
+        }
+        if negate {
+            let mut inverse = Vec::with_capacity(merged.len() + 2);
+            let mut next: Rune = 0;
+            for &[lo, hi] in merged.as_chunks::<2>().0 {
+                if lo > next {
+                    inverse.push(next);
+                    inverse.push(lo - 1);
+                }
+                next = hi + 1;
+            }
+            if next <= MAX_RUNE {
+                inverse.push(next);
+                inverse.push(MAX_RUNE);
+            }
+            merged = inverse;
+        }
+        let mut ascii = [0u64; 2];
+        for &[lo, hi] in merged.as_chunks::<2>().0 {
+            if lo >= 128 {
+                break;
+            }
+            let mut c = lo;
+            while c <= hi && c < 128 {
+                ascii[(c >> 6) as usize] |= 1 << (c & 63);
+                c += 1;
+            }
+        }
+        CharSet { ranges: merged, ascii }
+    }
+
+    /// [`CharSet::new`], shared.
+    pub(crate) fn shared(pairs: &[Rune], negate: bool) -> Arc<CharSet> {
+        Arc::new(CharSet::new(pairs, negate))
+    }
+
+    /// Whether the set holds the ASCII character.
+    #[inline(always)]
+    pub(crate) fn has_ascii(&self, c: u8) -> bool {
+        (self.ascii[(c >> 6) as usize & 1] >> (c & 63)) & 1 != 0
+    }
+
+    /// Whether the set holds the code point.
+    #[inline]
+    pub(crate) fn contains(&self, r: Rune) -> bool {
+        if (0..128).contains(&r) {
+            return (self.ascii[(r >> 6) as usize] >> (r & 63)) & 1 != 0;
+        }
+        let ranges = &self.ranges[..];
+        let (mut lo, mut hi) = (0, ranges.len() / 2);
+        while lo < hi {
+            let mid = (lo + hi) >> 1;
+            if r > ranges[2 * mid + 1] {
+                lo = mid + 1;
+            } else if r < ranges[2 * mid] {
+                hi = mid;
+            } else {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// Whether the set holds no code point.
+    pub(crate) fn is_empty(&self) -> bool {
+        self.ranges.is_empty()
+    }
+}
+
+// The classes ECMA-262 defines. \d and \w are ASCII only, \s is WhiteSpace and LineTerminator, and . is everything
+// but the four line terminators.
+pub(crate) const DIGIT_PAIRS: &[Rune] = &[0x30, 0x39];
+pub(crate) const WORD_PAIRS: &[Rune] = &[0x30, 0x39, 0x41, 0x5A, 0x5F, 0x5F, 0x61, 0x7A];
+pub(crate) const SPACE_PAIRS: &[Rune] = &[
+    0x9, 0xD, 0x20, 0x20, 0xA0, 0xA0, 0x1680, 0x1680, 0x2000, 0x200A, 0x2028, 0x2029, 0x202F, 0x202F, 0x205F, 0x205F,
+    0x3000, 0x3000, 0xFEFF, 0xFEFF,
+];
+pub(crate) const LINE_TERMINATOR_PAIRS: &[Rune] = &[0xA, 0xA, 0xD, 0xD, 0x2028, 0x2029];
+
+pub(crate) static DOT_SET: LazyLock<Arc<CharSet>> = LazyLock::new(|| CharSet::shared(LINE_TERMINATOR_PAIRS, true));
+
+/// Whether a byte is an ECMA-262 word character. Every word character is ASCII, so a word boundary can be decided
+/// from the bytes on either side of a position.
+#[inline(always)]
+pub(crate) fn is_word_byte(b: u8) -> bool {
+    b.is_ascii_alphanumeric() || b == b'_'
+}
+
+/// The short name of a General_Category value, from its long name, an alias or the short name itself.
+fn category_name(value: &str) -> Option<&'static str> {
+    Some(match value {
+        "Letter" | "L" => "L",
+        "Lowercase_Letter" | "Ll" => "Ll",
+        "Uppercase_Letter" | "Lu" => "Lu",
+        "Titlecase_Letter" | "Lt" => "Lt",
+        "Cased_Letter" | "LC" => "LC",
+        "Modifier_Letter" | "Lm" => "Lm",
+        "Other_Letter" | "Lo" => "Lo",
+        "Mark" | "Combining_Mark" | "M" => "M",
+        "Nonspacing_Mark" | "Mn" => "Mn",
+        "Spacing_Mark" | "Mc" => "Mc",
+        "Enclosing_Mark" | "Me" => "Me",
+        "Number" | "N" => "N",
+        "Decimal_Number" | "digit" | "Nd" => "Nd",
+        "Letter_Number" | "Nl" => "Nl",
+        "Other_Number" | "No" => "No",
+        "Punctuation" | "punct" | "P" => "P",
+        "Connector_Punctuation" | "Pc" => "Pc",
+        "Dash_Punctuation" | "Pd" => "Pd",
+        "Open_Punctuation" | "Ps" => "Ps",
+        "Close_Punctuation" | "Pe" => "Pe",
+        "Initial_Punctuation" | "Pi" => "Pi",
+        "Final_Punctuation" | "Pf" => "Pf",
+        "Other_Punctuation" | "Po" => "Po",
+        "Symbol" | "S" => "S",
+        "Math_Symbol" | "Sm" => "Sm",
+        "Currency_Symbol" | "Sc" => "Sc",
+        "Modifier_Symbol" | "Sk" => "Sk",
+        "Other_Symbol" | "So" => "So",
+        "Separator" | "Z" => "Z",
+        "Space_Separator" | "Zs" => "Zs",
+        "Line_Separator" | "Zl" => "Zl",
+        "Paragraph_Separator" | "Zp" => "Zp",
+        "Other" | "C" => "C",
+        "Control" | "cntrl" | "Cc" => "Cc",
+        "Format" | "Cf" => "Cf",
+        "Surrogate" | "Cs" => "Cs",
+        "Private_Use" | "Co" => "Co",
+        "Unassigned" | "Cn" => "Cn",
+        _ => return None,
+    })
+}
+
+/// The canonical name of a binary property ECMA-262 lists, from the name or an alias.
+fn binary_name(name: &str) -> Option<&'static str> {
+    Some(match name {
+        "ASCII" => "ASCII",
+        "ASCII_Hex_Digit" | "AHex" => "ASCII_Hex_Digit",
+        "Alphabetic" | "Alpha" => "Alphabetic",
+        "Any" => "Any",
+        "Assigned" => "Assigned",
+        "Bidi_Control" | "Bidi_C" => "Bidi_Control",
+        "Bidi_Mirrored" | "Bidi_M" => "Bidi_Mirrored",
+        "Case_Ignorable" | "CI" => "Case_Ignorable",
+        "Cased" => "Cased",
+        "Changes_When_Casefolded" | "CWCF" => "Changes_When_Casefolded",
+        "Changes_When_Casemapped" | "CWCM" => "Changes_When_Casemapped",
+        "Changes_When_Lowercased" | "CWL" => "Changes_When_Lowercased",
+        "Changes_When_NFKC_Casefolded" | "CWKCF" => "Changes_When_NFKC_Casefolded",
+        "Changes_When_Titlecased" | "CWT" => "Changes_When_Titlecased",
+        "Changes_When_Uppercased" | "CWU" => "Changes_When_Uppercased",
+        "Dash" => "Dash",
+        "Default_Ignorable_Code_Point" | "DI" => "Default_Ignorable_Code_Point",
+        "Deprecated" | "Dep" => "Deprecated",
+        "Diacritic" | "Dia" => "Diacritic",
+        "Emoji" => "Emoji",
+        "Emoji_Component" | "EComp" => "Emoji_Component",
+        "Emoji_Modifier" | "EMod" => "Emoji_Modifier",
+        "Emoji_Modifier_Base" | "EBase" => "Emoji_Modifier_Base",
+        "Emoji_Presentation" | "EPres" => "Emoji_Presentation",
+        "Extended_Pictographic" | "ExtPict" => "Extended_Pictographic",
+        "Extender" | "Ext" => "Extender",
+        "Grapheme_Base" | "Gr_Base" => "Grapheme_Base",
+        "Grapheme_Extend" | "Gr_Ext" => "Grapheme_Extend",
+        "Hex_Digit" | "Hex" => "Hex_Digit",
+        "IDS_Binary_Operator" | "IDSB" => "IDS_Binary_Operator",
+        "IDS_Trinary_Operator" | "IDST" => "IDS_Trinary_Operator",
+        "ID_Continue" | "IDC" => "ID_Continue",
+        "ID_Start" | "IDS" => "ID_Start",
+        "Ideographic" | "Ideo" => "Ideographic",
+        "Join_Control" | "Join_C" => "Join_Control",
+        "Logical_Order_Exception" | "LOE" => "Logical_Order_Exception",
+        "Lowercase" | "Lower" => "Lowercase",
+        "Math" => "Math",
+        "Noncharacter_Code_Point" | "NChar" => "Noncharacter_Code_Point",
+        "Pattern_Syntax" | "Pat_Syn" => "Pattern_Syntax",
+        "Pattern_White_Space" | "Pat_WS" => "Pattern_White_Space",
+        "Quotation_Mark" | "QMark" => "Quotation_Mark",
+        "Radical" => "Radical",
+        "Regional_Indicator" | "RI" => "Regional_Indicator",
+        "Sentence_Terminal" | "STerm" => "Sentence_Terminal",
+        "Soft_Dotted" | "SD" => "Soft_Dotted",
+        "Terminal_Punctuation" | "Term" => "Terminal_Punctuation",
+        "Unified_Ideograph" | "UIdeo" => "Unified_Ideograph",
+        "Uppercase" | "Upper" => "Uppercase",
+        "Variation_Selector" | "VS" => "Variation_Selector",
+        "White_Space" | "space" => "White_Space",
+        "XID_Continue" | "XIDC" => "XID_Continue",
+        "XID_Start" | "XIDS" => "XID_Start",
+        _ => return None,
+    })
+}
+
+/// The sets already built for property expressions. A property set can have hundreds of ranges, and schemas tend to
+/// repeat the same few. Only an expression ECMA-262 defines is kept, and those are a fixed few hundred, so the
+/// cache is bounded.
+static PROPERTY_CACHE: LazyLock<Mutex<HashMap<String, Arc<CharSet>>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
+
+/// Resolves the expression between the braces of `\p{...}` to its set. `None` for a name or value that ECMA-262
+/// does not define.
+pub(crate) fn property_set(expr: &str) -> Option<Arc<CharSet>> {
+    if let Some(cached) = PROPERTY_CACHE.lock().unwrap_or_else(|e| e.into_inner()).get(expr) {
+        return Some(cached.clone());
+    }
+    let pairs = property_pairs(expr)?;
+    let set = CharSet::shared(&pairs, false);
+    PROPERTY_CACHE.lock().unwrap_or_else(|e| e.into_inner()).insert(expr.to_string(), set.clone());
+    Some(set)
+}
+
+/// The ranges of a property expression. Every range comes from the tables of `ucd`, which hold one fixed version of
+/// Unicode, so the answer does not depend on the toolchain.
+fn property_pairs(expr: &str) -> Option<Vec<Rune>> {
+    if let Some((name, value)) = expr.split_once('=') {
+        return match name {
+            "General_Category" | "gc" => category_pairs(value),
+            "Script" | "sc" => ucd::script(value).map(|t| t.pairs()),
+            "Script_Extensions" | "scx" => ucd::script_extensions(value).map(|t| t.pairs()),
+            _ => None,
+        };
+    }
+    if let Some(pairs) = category_pairs(expr) {
+        return Some(pairs);
+    }
+    match binary_name(expr)? {
+        "ASCII" => Some(vec![0, 0x7F]),
+        "Any" => Some(vec![0, MAX_RUNE]),
+        canonical => ucd::binary(canonical).map(|t| t.pairs()),
+    }
+}
+
+fn category_pairs(value: &str) -> Option<Vec<Rune>> {
+    ucd::category(category_name(value)?).map(|t| t.pairs())
+}