corvus_json_schema 0.1.0

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

@@ -0,0 +1,403 @@
+//! Loads schema documents, identifies resources and anchors, and resolves references.
+//! A port of `SchemaLoader` (via the TypeScript port's `loader.ts`): elements are identified by (document, JSON
+//! pointer), and a value's address identifies it within the compile (documents are boxed and never mutated).
+
+use std::collections::HashMap;
+
+use serde_json::Value;
+
+use crate::dialect::{Dialect, SubschemaKind, known_dialect, subschema_kind, vocab, vocabulary_flag};
+use crate::metaschemas::metaschema;
+use crate::options::{CompileOptions, SchemaCompilationError};
+use crate::uri::{decode_fragment, escape_pointer_token, normalize, resolve, resolve_pointer, split};
+
+const DEFAULT_ROOT_URI: &str = "https://corvus-oss.org/runtime-evaluator/root.json";
+
+/// The identity of a JSON value within a loaded document.
+#[inline]
+pub(crate) fn addr(v: &Value) -> usize {
+    v as *const Value as usize
+}
+
+pub(crate) struct SchemaDocument {
+    pub root: Box<Value>,
+    /// The resource that owns each visited schema value.
+    pub resource_of: HashMap<usize, u32>,
+}
+
+pub(crate) struct SchemaResource {
+    pub document: u32,
+    pub root_pointer: String,
+    pub uri: String,
+    pub dialect: Dialect,
+    pub vocabularies: u32,
+    pub recursive_anchor: bool,
+    pub anchors: HashMap<String, String>,
+    pub dynamic_anchors: HashMap<String, String>,
+}
+
+/// The target of a reference: a value in a document, and the resource it belongs to.
+#[derive(Clone)]
+pub(crate) struct SchemaTarget {
+    pub document: u32,
+    pub pointer: String,
+    pub value: *const Value,
+    pub resource: u32,
+}
+
+impl SchemaTarget {
+    /// The target value. Valid while the loader that produced the target lives (documents are boxed and
+    /// never mutated or dropped before the loader).
+    #[inline]
+    pub fn value<'a>(&self) -> &'a Value {
+        // SAFETY: see above; the compiler never lets a target outlive its loader.
+        unsafe { &*self.value }
+    }
+}
+
+pub(crate) struct SchemaLoader<'o> {
+    pub documents: Vec<SchemaDocument>,
+    pub resources: Vec<SchemaResource>,
+    resources_by_uri: HashMap<String, u32>,
+    documents_by_uri: HashMap<String, u32>,
+    metaschema_info: HashMap<String, (Dialect, u32)>,
+    metaschema_loading: Vec<String>,
+    reference_cache: HashMap<(u32, String), Option<SchemaTarget>>,
+    options: &'o CompileOptions,
+}
+
+fn is_schema_value(v: &Value) -> bool {
+    v.is_boolean() || v.is_object()
+}
+
+impl<'o> SchemaLoader<'o> {
+    pub fn new(options: &'o CompileOptions) -> SchemaLoader<'o> {
+        SchemaLoader {
+            documents: Vec::new(),
+            resources: Vec::new(),
+            resources_by_uri: HashMap::new(),
+            documents_by_uri: HashMap::new(),
+            metaschema_info: HashMap::new(),
+            metaschema_loading: Vec::new(),
+            reference_cache: HashMap::new(),
+            options,
+        }
+    }
+
+    pub fn load_root(&mut self, schema: Value, base_uri: Option<&str>) -> Result<u32, SchemaCompilationError> {
+        let uri = base_uri.map(normalize).unwrap_or_else(|| DEFAULT_ROOT_URI.to_string());
+        let doc = self.add_document(uri, schema)?;
+        let d = &self.documents[doc as usize];
+        Ok(d.resource_of[&addr(&d.root)])
+    }
+
+    pub fn load_root_from_uri(&mut self, uri: &str) -> Result<u32, SchemaCompilationError> {
+        let normalized = normalize(uri);
+        if !self.try_load_document(&normalized)? {
+            return Err(SchemaCompilationError::new(format!("Unable to resolve the schema document '{uri}'.")));
+        }
+        let doc = self.documents_by_uri[&normalized];
+        let d = &self.documents[doc as usize];
+        Ok(d.resource_of[&addr(&d.root)])
+    }
+
+    /// The root value of a resource.
+    pub fn resource_root(&self, resource: u32) -> &Value {
+        let r = &self.resources[resource as usize];
+        let doc = &self.documents[r.document as usize];
+        resolve_pointer(&doc.root, &r.root_pointer).map(|(v, _)| v).unwrap_or(&doc.root)
+    }
+
+    pub fn root_target(&self, resource: u32) -> SchemaTarget {
+        let r = &self.resources[resource as usize];
+        SchemaTarget {
+            document: r.document,
+            pointer: r.root_pointer.clone(),
+            value: self.resource_root(resource) as *const Value,
+            resource,
+        }
+    }
+
+    pub fn resource_of(&self, document: u32, value: &Value) -> Option<u32> {
+        self.documents[document as usize].resource_of.get(&addr(value)).copied()
+    }
+
+    pub fn try_resolve_reference(
+        &mut self,
+        from: u32,
+        reference: &str,
+    ) -> Result<Option<SchemaTarget>, SchemaCompilationError> {
+        let key = (from, reference.to_string());
+        if let Some(t) = self.reference_cache.get(&key) {
+            return Ok(t.clone());
+        }
+        let target = self.resolve_reference(from, reference)?;
+        self.reference_cache.insert(key, target.clone());
+        Ok(target)
+    }
+
+    fn resolve_reference(
+        &mut self,
+        from: u32,
+        reference: &str,
+    ) -> Result<Option<SchemaTarget>, SchemaCompilationError> {
+        let (uri_part, fragment) = split(reference);
+        let absolute = resolve(&self.resources[from as usize].uri, uri_part);
+        let resource = match self.resources_by_uri.get(&absolute) {
+            Some(&r) => r,
+            None => {
+                if !self.try_load_document(&absolute)? {
+                    return Ok(None);
+                }
+                match self.resources_by_uri.get(&absolute) {
+                    Some(&r) => r,
+                    None => return Ok(None),
+                }
+            }
+        };
+        Ok(self.try_resolve_fragment(resource, &decode_fragment(fragment)))
+    }
+
+    pub fn try_resolve_fragment(&self, resource: u32, fragment: &str) -> Option<SchemaTarget> {
+        if fragment.is_empty() {
+            return Some(self.root_target(resource));
+        }
+        let r = &self.resources[resource as usize];
+        if fragment.starts_with('/') {
+            let root = self.resource_root(resource);
+            let (value, path) = resolve_pointer(root, fragment)?;
+            let owner = self.resource_of(r.document, value).unwrap_or(resource);
+            return Some(SchemaTarget {
+                document: r.document,
+                pointer: format!("{}{}", r.root_pointer, path),
+                value: value as *const Value,
+                resource: owner,
+            });
+        }
+        let anchor = r.anchors.get(fragment)?;
+        let doc = &self.documents[r.document as usize];
+        let (value, _) = resolve_pointer(&doc.root, anchor)?;
+        Some(SchemaTarget { document: r.document, pointer: anchor.clone(), value: value as *const Value, resource })
+    }
+
+    pub fn get_dialect_info(&mut self, schema_uri: &str) -> Result<(Dialect, u32), SchemaCompilationError> {
+        // The standard metaschema URIs, as usually written, need no URI normalisation.
+        if let Some(d) = known_dialect(schema_uri.strip_suffix('#').unwrap_or(schema_uri)) {
+            return Ok((d, vocab::ALL_ANNOTATING_FORMAT));
+        }
+        let normalized = normalize(schema_uri);
+        if let Some(d) = known_dialect(&normalized) {
+            return Ok((d, vocab::ALL_ANNOTATING_FORMAT));
+        }
+        if let Some(&info) = self.metaschema_info.get(&normalized) {
+            return Ok(info);
+        }
+        if self.metaschema_loading.contains(&normalized) {
+            return Ok((self.options.default_dialect, vocab::ALL_ANNOTATING_FORMAT));
+        }
+        self.metaschema_loading.push(normalized.clone());
+        let result = self.load_metaschema_info(&normalized);
+        self.metaschema_loading.retain(|u| u != &normalized);
+        let info = result?;
+        self.metaschema_info.insert(normalized, info);
+        Ok(info)
+    }
+
+    fn load_metaschema_info(&mut self, normalized: &str) -> Result<(Dialect, u32), SchemaCompilationError> {
+        let meta_resource = match self.resources_by_uri.get(normalized) {
+            Some(&r) => r,
+            None => {
+                if !self.try_load_document(normalized)? {
+                    return Ok((self.options.default_dialect, vocab::ALL_ANNOTATING_FORMAT));
+                }
+                match self.resources_by_uri.get(normalized) {
+                    Some(&r) => r,
+                    None => return Ok((self.options.default_dialect, vocab::ALL_ANNOTATING_FORMAT)),
+                }
+            }
+        };
+        let mut vocabularies = vocab::ALL_ANNOTATING_FORMAT;
+        if let Some(Value::Object(v)) = self.resource_root(meta_resource).get("$vocabulary") {
+            vocabularies = vocab::NONE;
+            for name in v.keys() {
+                vocabularies |= vocabulary_flag(name);
+            }
+            vocabularies |= vocab::CORE;
+        }
+        Ok((self.resources[meta_resource as usize].dialect, vocabularies))
+    }
+
+    fn try_load_document(&mut self, absolute_uri: &str) -> Result<bool, SchemaCompilationError> {
+        if self.documents_by_uri.contains_key(absolute_uri) {
+            return Ok(true);
+        }
+        if let Some(resolver) = &self.options.resolve_document {
+            if let Some(doc) = resolver(absolute_uri) {
+                self.add_document(absolute_uri.to_string(), doc)?;
+                return Ok(true);
+            }
+        }
+        if let Some(text) = metaschema(absolute_uri) {
+            let doc: Value = serde_json::from_str(text).expect("embedded metaschemas are valid JSON");
+            self.add_document(absolute_uri.to_string(), doc)?;
+            return Ok(true);
+        }
+        Ok(false)
+    }
+
+    fn add_document(&mut self, uri: String, root: Value) -> Result<u32, SchemaCompilationError> {
+        let id = self.documents.len() as u32;
+        self.documents.push(SchemaDocument { root: Box::new(root), resource_of: HashMap::new() });
+        self.documents_by_uri.insert(uri.clone(), id);
+        // SAFETY: the boxed root is never moved or dropped while the loader lives.
+        let root: &Value = unsafe { &*(self.documents[id as usize].root.as_ref() as *const Value) };
+        let (dialect, vocabularies) = match root.get("$schema") {
+            Some(Value::String(s)) if root.is_object() => self.get_dialect_info(s)?,
+            _ => (self.options.default_dialect, vocab::ALL_ANNOTATING_FORMAT),
+        };
+        let resource = self.create_resource(id, String::new(), uri, dialect, vocabularies);
+        self.walk(id, root, String::new(), resource, true)?;
+        Ok(id)
+    }
+
+    fn create_resource(
+        &mut self,
+        document: u32,
+        pointer: String,
+        uri: String,
+        dialect: Dialect,
+        vocabularies: u32,
+    ) -> u32 {
+        let id = self.resources.len() as u32;
+        self.resources.push(SchemaResource {
+            document,
+            root_pointer: pointer,
+            uri: uri.clone(),
+            dialect,
+            vocabularies,
+            recursive_anchor: false,
+            anchors: HashMap::new(),
+            dynamic_anchors: HashMap::new(),
+        });
+        self.resources_by_uri.entry(uri).or_insert(id);
+        id
+    }
+
+    fn add_anchor(&mut self, resource: u32, name: &str, pointer: &str) {
+        self.resources[resource as usize].anchors.entry(name.to_string()).or_insert_with(|| pointer.to_string());
+    }
+
+    fn walk(
+        &mut self,
+        doc: u32,
+        element: &Value,
+        pointer: String,
+        mut resource: u32,
+        mut is_resource_root: bool,
+    ) -> Result<(), SchemaCompilationError> {
+        let Value::Object(map) = element else {
+            self.documents[doc as usize].resource_of.insert(addr(element), resource);
+            return Ok(());
+        };
+
+        let (mut dialect, mut vocabularies) = {
+            let r = &self.resources[resource as usize];
+            (r.dialect, r.vocabularies)
+        };
+        if !is_resource_root {
+            if let Some(Value::String(s)) = map.get("$schema") {
+                (dialect, vocabularies) = self.get_dialect_info(s)?;
+            }
+        }
+
+        let legacy_ref_overrides_siblings = dialect.is_legacy() && matches!(map.get("$ref"), Some(Value::String(_)));
+        if !legacy_ref_overrides_siblings {
+            let id_value = if dialect == Dialect::Draft4 { map.get("id") } else { map.get("$id") };
+            if let Some(Value::String(id)) = id_value {
+                let (uri_part, fragment) = split(id);
+                if uri_part.is_empty() {
+                    if !fragment.is_empty() && dialect.is_legacy() {
+                        self.add_anchor(resource, fragment, &pointer);
+                    }
+                } else {
+                    let absolute = resolve(&self.resources[resource as usize].uri, uri_part);
+                    if !is_resource_root || absolute != self.resources[resource as usize].uri {
+                        if is_resource_root {
+                            self.resources_by_uri.entry(absolute.clone()).or_insert(resource);
+                            self.resources[resource as usize].uri = absolute;
+                        } else {
+                            resource = self.create_resource(doc, pointer.clone(), absolute, dialect, vocabularies);
+                            is_resource_root = true;
+                        }
+                    }
+                    if !fragment.is_empty() && dialect.is_legacy() {
+                        self.add_anchor(resource, fragment, &pointer);
+                    }
+                }
+            }
+            if dialect >= Dialect::Draft201909 {
+                if let Some(Value::String(a)) = map.get("$anchor") {
+                    self.add_anchor(resource, a, &pointer);
+                }
+            }
+            if dialect >= Dialect::Draft202012 {
+                if let Some(Value::String(name)) = map.get("$dynamicAnchor") {
+                    self.resources[resource as usize]
+                        .dynamic_anchors
+                        .entry(name.clone())
+                        .or_insert_with(|| pointer.clone());
+                    self.add_anchor(resource, name, &pointer);
+                }
+            }
+            if dialect == Dialect::Draft201909
+                && is_resource_root
+                && map.get("$recursiveAnchor") == Some(&Value::Bool(true))
+            {
+                self.resources[resource as usize].recursive_anchor = true;
+            }
+        }
+
+        self.documents[doc as usize].resource_of.insert(addr(element), resource);
+
+        for (name, value) in map {
+            let base = || format!("{pointer}/{}", escape_pointer_token(name));
+            match subschema_kind(name, dialect, legacy_ref_overrides_siblings) {
+                SubschemaKind::Single => {
+                    if is_schema_value(value) {
+                        self.walk(doc, value, base(), resource, false)?;
+                    }
+                }
+                SubschemaKind::SingleOrArray => {
+                    if let Value::Array(items) = value {
+                        let b = base();
+                        for (i, v) in items.iter().enumerate() {
+                            self.walk(doc, v, format!("{b}/{i}"), resource, false)?;
+                        }
+                    } else if is_schema_value(value) {
+                        self.walk(doc, value, base(), resource, false)?;
+                    }
+                }
+                SubschemaKind::Array => {
+                    if let Value::Array(items) = value {
+                        let b = base();
+                        for (i, v) in items.iter().enumerate() {
+                            self.walk(doc, v, format!("{b}/{i}"), resource, false)?;
+                        }
+                    }
+                }
+                SubschemaKind::Map => {
+                    if let Value::Object(entries) = value {
+                        let b = base();
+                        for (entry, v) in entries {
+                            if is_schema_value(v) {
+                                self.walk(doc, v, format!("{b}/{}", escape_pointer_token(entry)), resource, false)?;
+                            }
+                        }
+                    }
+                }
+                SubschemaKind::None => {}
+            }
+        }
+        Ok(())
+    }
+}

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

@@ -0,0 +1,29 @@
+// <auto-generated> by tests/metaschemas.rs from src/Corvus.Text.Json/metaschema. Do not edit.
+
+/// The standard metaschemas, keyed by their canonical URI (no trailing empty fragment).
+pub(crate) fn metaschema(uri: &str) -> Option<&'static str> {
+    match uri {
+        "http://json-schema.org/draft-04/schema" => Some(r####"{"id":"http://json-schema.org/draft-04/schema#","$schema":"http://json-schema.org/draft-04/schema#","description":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"positiveInteger":{"type":"integer","minimum":0},"positiveIntegerDefault0":{"allOf":[{"$ref":"#/definitions/positiveInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"minItems":1,"uniqueItems":true}},"type":"object","properties":{"id":{"type":"string"},"$schema":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"multipleOf":{"type":"number","minimum":0,"exclusiveMinimum":true},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"boolean","default":false},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"boolean","default":false},"maxLength":{"$ref":"#/definitions/positiveInteger"},"minLength":{"$ref":"#/definitions/positiveIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/positiveInteger"},"minItems":{"$ref":"#/definitions/positiveIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxProperties":{"$ref":"#/definitions/positiveInteger"},"minProperties":{"$ref":"#/definitions/positiveIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"anyOf":[{"type":"boolean"},{"$ref":"#"}],"default":{}},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"dependencies":{"exclusiveMaximum":["maximum"],"exclusiveMinimum":["minimum"]},"default":{}}"####),
+        "http://json-schema.org/draft-06/schema" => Some(r####"{"$schema":"http://json-schema.org/draft-06/schema#","$id":"http://json-schema.org/draft-06/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"title":{"type":"string"},"description":{"type":"string"},"default":{},"examples":{"type":"array","items":{}},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":{}},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":{},"enum":{"type":"array","minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":{}}"####),
+        "http://json-schema.org/draft-07/schema" => Some(r####"{"$schema":"http://json-schema.org/draft-07/schema#","$id":"http://json-schema.org/draft-07/schema#","title":"Core schema meta-schema","definitions":{"schemaArray":{"type":"array","minItems":1,"items":{"$ref":"#"}},"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"allOf":[{"$ref":"#/definitions/nonNegativeInteger"},{"default":0}]},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}},"type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference"},"$schema":{"type":"string","format":"uri"},"$ref":{"type":"string","format":"uri-reference"},"$comment":{"type":"string"},"title":{"type":"string"},"description":{"type":"string"},"default":true,"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/definitions/nonNegativeInteger"},"minLength":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"additionalItems":{"$ref":"#"},"items":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/schemaArray"}],"default":true},"maxItems":{"$ref":"#/definitions/nonNegativeInteger"},"minItems":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"contains":{"$ref":"#"},"maxProperties":{"$ref":"#/definitions/nonNegativeInteger"},"minProperties":{"$ref":"#/definitions/nonNegativeIntegerDefault0"},"required":{"$ref":"#/definitions/stringArray"},"additionalProperties":{"$ref":"#"},"definitions":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"properties":{"type":"object","additionalProperties":{"$ref":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$ref":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependencies":{"type":"object","additionalProperties":{"anyOf":[{"$ref":"#"},{"$ref":"#/definitions/stringArray"}]}},"propertyNames":{"$ref":"#"},"const":true,"enum":{"type":"array","items":true,"minItems":1,"uniqueItems":true},"type":{"anyOf":[{"$ref":"#/definitions/simpleTypes"},{"type":"array","items":{"$ref":"#/definitions/simpleTypes"},"minItems":1,"uniqueItems":true}]},"format":{"type":"string"},"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"if":{"$ref":"#"},"then":{"$ref":"#"},"else":{"$ref":"#"},"allOf":{"$ref":"#/definitions/schemaArray"},"anyOf":{"$ref":"#/definitions/schemaArray"},"oneOf":{"$ref":"#/definitions/schemaArray"},"not":{"$ref":"#"}},"default":true}"####),
+        "https://json-schema.org/draft/2019-09/schema" => Some(r####"{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/schema","$vocabulary":{"https://json-schema.org/draft/2019-09/vocab/core":true,"https://json-schema.org/draft/2019-09/vocab/applicator":true,"https://json-schema.org/draft/2019-09/vocab/validation":true,"https://json-schema.org/draft/2019-09/vocab/meta-data":true,"https://json-schema.org/draft/2019-09/vocab/format":false,"https://json-schema.org/draft/2019-09/vocab/content":true},"$recursiveAnchor":true,"title":"Core and Validation specifications meta-schema","allOf":[{"$ref":"meta/core"},{"$ref":"meta/applicator"},{"$ref":"meta/validation"},{"$ref":"meta/meta-data"},{"$ref":"meta/format"},{"$ref":"meta/content"}],"type":["object","boolean"],"properties":{"definitions":{"$comment":"While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.","type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}},"dependencies":{"$comment":"\"dependencies\" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to \"dependentSchemas\" and \"dependentRequired\"","type":"object","additionalProperties":{"anyOf":[{"$recursiveRef":"#"},{"$ref":"meta/validation#/$defs/stringArray"}]}}}}"####),
+        "https://json-schema.org/draft/2020-12/schema" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/schema","$vocabulary":{"https://json-schema.org/draft/2020-12/vocab/core":true,"https://json-schema.org/draft/2020-12/vocab/applicator":true,"https://json-schema.org/draft/2020-12/vocab/unevaluated":true,"https://json-schema.org/draft/2020-12/vocab/validation":true,"https://json-schema.org/draft/2020-12/vocab/meta-data":true,"https://json-schema.org/draft/2020-12/vocab/format-annotation":true,"https://json-schema.org/draft/2020-12/vocab/content":true},"$dynamicAnchor":"meta","title":"Core and Validation specifications meta-schema","allOf":[{"$ref":"meta/core"},{"$ref":"meta/applicator"},{"$ref":"meta/unevaluated"},{"$ref":"meta/validation"},{"$ref":"meta/meta-data"},{"$ref":"meta/format-annotation"},{"$ref":"meta/content"}],"type":["object","boolean"],"$comment":"This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.","properties":{"definitions":{"$comment":"\"definitions\" has been replaced by \"$defs\".","type":"object","additionalProperties":{"$dynamicRef":"#meta"},"deprecated":true,"default":{}},"dependencies":{"$comment":"\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.","type":"object","additionalProperties":{"anyOf":[{"$dynamicRef":"#meta"},{"$ref":"meta/validation#/$defs/stringArray"}]},"deprecated":true,"default":{}},"$recursiveAnchor":{"$comment":"\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".","$ref":"meta/core#/$defs/anchorString","deprecated":true},"$recursiveRef":{"$comment":"\"$recursiveRef\" has been replaced by \"$dynamicRef\".","$ref":"meta/core#/$defs/uriReferenceString","deprecated":true}}}"####),
+        "https://json-schema.org/draft/2019-09/meta/applicator" => Some(r####"{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/applicator","$recursiveAnchor":true,"title":"Applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"additionalItems":{"$recursiveRef":"#"},"unevaluatedItems":{"$recursiveRef":"#"},"items":{"anyOf":[{"$recursiveRef":"#"},{"$ref":"#/$defs/schemaArray"}]},"contains":{"$recursiveRef":"#"},"additionalProperties":{"$recursiveRef":"#"},"unevaluatedProperties":{"$recursiveRef":"#"},"properties":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"propertyNames":{"format":"regex"},"default":{}},"dependentSchemas":{"type":"object","additionalProperties":{"$recursiveRef":"#"}},"propertyNames":{"$recursiveRef":"#"},"if":{"$recursiveRef":"#"},"then":{"$recursiveRef":"#"},"else":{"$recursiveRef":"#"},"allOf":{"$ref":"#/$defs/schemaArray"},"anyOf":{"$ref":"#/$defs/schemaArray"},"oneOf":{"$ref":"#/$defs/schemaArray"},"not":{"$recursiveRef":"#"}},"$defs":{"schemaArray":{"type":"array","minItems":1,"items":{"$recursiveRef":"#"}}}}"####),
+        "https://json-schema.org/draft/2019-09/meta/content" => Some(r####"{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/content","$recursiveAnchor":true,"title":"Content vocabulary meta-schema","type":["object","boolean"],"properties":{"contentMediaType":{"type":"string"},"contentEncoding":{"type":"string"},"contentSchema":{"$recursiveRef":"#"}}}"####),
+        "https://json-schema.org/draft/2019-09/meta/core" => Some(r####"{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/core","$recursiveAnchor":true,"title":"Core vocabulary meta-schema","type":["object","boolean"],"properties":{"$id":{"type":"string","format":"uri-reference","$comment":"Non-empty fragments not allowed.","pattern":"^[^#]*#?$"},"$schema":{"type":"string","format":"uri"},"$anchor":{"type":"string","pattern":"^[A-Za-z][-A-Za-z0-9.:_]*$"},"$ref":{"type":"string","format":"uri-reference"},"$recursiveRef":{"type":"string","format":"uri-reference"},"$recursiveAnchor":{"type":"boolean","default":false},"$vocabulary":{"type":"object","propertyNames":{"type":"string","format":"uri"},"additionalProperties":{"type":"boolean"}},"$comment":{"type":"string"},"$defs":{"type":"object","additionalProperties":{"$recursiveRef":"#"},"default":{}}}}"####),
+        "https://json-schema.org/draft/2019-09/meta/format" => Some(r####"{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/format","$recursiveAnchor":true,"title":"Format vocabulary meta-schema","type":["object","boolean"],"properties":{"format":{"type":"string"}}}"####),
+        "https://json-schema.org/draft/2019-09/meta/hyper-schema" => Some(r####"{"$schema":"https://json-schema.org/draft/2019-09/hyper-schema","$id":"https://json-schema.org/draft/2019-09/meta/hyper-schema","$recursiveAnchor":true,"title":"JSON Hyper-Schema Vocabulary Schema","type":["object","boolean"],"properties":{"base":{"type":"string","format":"uri-template"},"links":{"type":"array","items":{"$ref":"https://json-schema.org/draft/2019-09/links"}}},"links":[{"rel":"self","href":"{+%24id}"}]}"####),
+        "https://json-schema.org/draft/2019-09/meta/meta-data" => Some(r####"{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/meta-data","$recursiveAnchor":true,"title":"Meta-data vocabulary meta-schema","type":["object","boolean"],"properties":{"title":{"type":"string"},"description":{"type":"string"},"default":true,"deprecated":{"type":"boolean","default":false},"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true}}}"####),
+        "https://json-schema.org/draft/2019-09/meta/validation" => Some(r####"{"$schema":"https://json-schema.org/draft/2019-09/schema","$id":"https://json-schema.org/draft/2019-09/meta/validation","$recursiveAnchor":true,"title":"Validation vocabulary meta-schema","type":["object","boolean"],"properties":{"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/$defs/nonNegativeInteger"},"minLength":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"maxItems":{"$ref":"#/$defs/nonNegativeInteger"},"minItems":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxContains":{"$ref":"#/$defs/nonNegativeInteger"},"minContains":{"$ref":"#/$defs/nonNegativeInteger","default":1},"maxProperties":{"$ref":"#/$defs/nonNegativeInteger"},"minProperties":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"required":{"$ref":"#/$defs/stringArray"},"dependentRequired":{"type":"object","additionalProperties":{"$ref":"#/$defs/stringArray"}},"const":true,"enum":{"type":"array","items":true},"type":{"anyOf":[{"$ref":"#/$defs/simpleTypes"},{"type":"array","items":{"$ref":"#/$defs/simpleTypes"},"minItems":1,"uniqueItems":true}]}},"$defs":{"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"$ref":"#/$defs/nonNegativeInteger","default":0},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}}}"####),
+        "https://json-schema.org/draft/2020-12/meta/applicator" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/applicator","$dynamicAnchor":"meta","title":"Applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"prefixItems":{"$ref":"#/$defs/schemaArray"},"items":{"$dynamicRef":"#meta"},"contains":{"$dynamicRef":"#meta"},"additionalProperties":{"$dynamicRef":"#meta"},"properties":{"type":"object","additionalProperties":{"$dynamicRef":"#meta"},"default":{}},"patternProperties":{"type":"object","additionalProperties":{"$dynamicRef":"#meta"},"propertyNames":{"format":"regex"},"default":{}},"dependentSchemas":{"type":"object","additionalProperties":{"$dynamicRef":"#meta"},"default":{}},"propertyNames":{"$dynamicRef":"#meta"},"if":{"$dynamicRef":"#meta"},"then":{"$dynamicRef":"#meta"},"else":{"$dynamicRef":"#meta"},"allOf":{"$ref":"#/$defs/schemaArray"},"anyOf":{"$ref":"#/$defs/schemaArray"},"oneOf":{"$ref":"#/$defs/schemaArray"},"not":{"$dynamicRef":"#meta"}},"$defs":{"schemaArray":{"type":"array","minItems":1,"items":{"$dynamicRef":"#meta"}}}}"####),
+        "https://json-schema.org/draft/2020-12/meta/content" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/content","$dynamicAnchor":"meta","title":"Content vocabulary meta-schema","type":["object","boolean"],"properties":{"contentEncoding":{"type":"string"},"contentMediaType":{"type":"string"},"contentSchema":{"$dynamicRef":"#meta"}}}"####),
+        "https://json-schema.org/draft/2020-12/meta/core" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/core","$dynamicAnchor":"meta","title":"Core vocabulary meta-schema","type":["object","boolean"],"properties":{"$id":{"$ref":"#/$defs/uriReferenceString","$comment":"Non-empty fragments not allowed.","pattern":"^[^#]*#?$"},"$schema":{"$ref":"#/$defs/uriString"},"$ref":{"$ref":"#/$defs/uriReferenceString"},"$anchor":{"$ref":"#/$defs/anchorString"},"$dynamicRef":{"$ref":"#/$defs/uriReferenceString"},"$dynamicAnchor":{"$ref":"#/$defs/anchorString"},"$vocabulary":{"type":"object","propertyNames":{"$ref":"#/$defs/uriString"},"additionalProperties":{"type":"boolean"}},"$comment":{"type":"string"},"$defs":{"type":"object","additionalProperties":{"$dynamicRef":"#meta"}}},"$defs":{"anchorString":{"type":"string","pattern":"^[A-Za-z_][-A-Za-z0-9._]*$"},"uriString":{"type":"string","format":"uri"},"uriReferenceString":{"type":"string","format":"uri-reference"}}}"####),
+        "https://json-schema.org/draft/2020-12/meta/format-annotation" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/format-annotation","$dynamicAnchor":"meta","title":"Format vocabulary meta-schema for annotation results","type":["object","boolean"],"properties":{"format":{"type":"string"}}}"####),
+        "https://json-schema.org/draft/2020-12/meta/format-assertion" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/format-assertion","$dynamicAnchor":"meta","title":"Format vocabulary meta-schema for assertion results","type":["object","boolean"],"properties":{"format":{"type":"string"}}}"####),
+        "https://json-schema.org/draft/2020-12/meta/hyper-schema" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/hyper-schema","$id":"https://json-schema.org/draft/2020-12/meta/hyper-schema","$dynamicAnchor":"meta","title":"JSON Hyper-Schema Vocabulary Schema","type":["object","boolean"],"properties":{"base":{"type":"string","format":"uri-template"},"links":{"type":"array","items":{"$ref":"https://json-schema.org/draft/2020-12/links"}}},"links":[{"rel":"self","href":"{+%24id}"}]}"####),
+        "https://json-schema.org/draft/2020-12/meta/meta-data" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/meta-data","$dynamicAnchor":"meta","title":"Meta-data vocabulary meta-schema","type":["object","boolean"],"properties":{"title":{"type":"string"},"description":{"type":"string"},"default":true,"deprecated":{"type":"boolean","default":false},"readOnly":{"type":"boolean","default":false},"writeOnly":{"type":"boolean","default":false},"examples":{"type":"array","items":true}}}"####),
+        "https://json-schema.org/draft/2020-12/meta/unevaluated" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/unevaluated","$dynamicAnchor":"meta","title":"Unevaluated applicator vocabulary meta-schema","type":["object","boolean"],"properties":{"unevaluatedItems":{"$dynamicRef":"#meta"},"unevaluatedProperties":{"$dynamicRef":"#meta"}}}"####),
+        "https://json-schema.org/draft/2020-12/meta/validation" => Some(r####"{"$schema":"https://json-schema.org/draft/2020-12/schema","$id":"https://json-schema.org/draft/2020-12/meta/validation","$dynamicAnchor":"meta","title":"Validation vocabulary meta-schema","type":["object","boolean"],"properties":{"type":{"anyOf":[{"$ref":"#/$defs/simpleTypes"},{"type":"array","items":{"$ref":"#/$defs/simpleTypes"},"minItems":1,"uniqueItems":true}]},"const":true,"enum":{"type":"array","items":true},"multipleOf":{"type":"number","exclusiveMinimum":0},"maximum":{"type":"number"},"exclusiveMaximum":{"type":"number"},"minimum":{"type":"number"},"exclusiveMinimum":{"type":"number"},"maxLength":{"$ref":"#/$defs/nonNegativeInteger"},"minLength":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"pattern":{"type":"string","format":"regex"},"maxItems":{"$ref":"#/$defs/nonNegativeInteger"},"minItems":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"uniqueItems":{"type":"boolean","default":false},"maxContains":{"$ref":"#/$defs/nonNegativeInteger"},"minContains":{"$ref":"#/$defs/nonNegativeInteger","default":1},"maxProperties":{"$ref":"#/$defs/nonNegativeInteger"},"minProperties":{"$ref":"#/$defs/nonNegativeIntegerDefault0"},"required":{"$ref":"#/$defs/stringArray"},"dependentRequired":{"type":"object","additionalProperties":{"$ref":"#/$defs/stringArray"}}},"$defs":{"nonNegativeInteger":{"type":"integer","minimum":0},"nonNegativeIntegerDefault0":{"$ref":"#/$defs/nonNegativeInteger","default":0},"simpleTypes":{"enum":["array","boolean","integer","null","number","object","string"]},"stringArray":{"type":"array","items":{"type":"string"},"uniqueItems":true,"default":[]}}}"####),
+        _ => None,
+    }
+}