polyxml 0.33.1__tar.gz → 0.33.2__tar.gz

{polyxml-0.33.1 → polyxml-0.33.2}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.33.1"
+version = "0.33.2"
 dependencies = [
  "criterion",
  "heck",
@@ -629,14 +629,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.33.1"
+version = "0.33.2"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.33.1"
+version = "0.33.2"
 dependencies = [
  "clap",
  "glob",
@@ -650,7 +650,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.33.1"
+version = "0.33.2"
 dependencies = [
  "napi",
  "napi-build",
@@ -660,7 +660,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.33.1"
+version = "0.33.2"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -670,7 +670,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.33.1"
+version = "0.33.2"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.33.1 → polyxml-0.33.2}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/polyxml-core", "crates/polyxml-python"]
 
 [workspace.package]
-version = "0.33.1"
+version = "0.33.2"
 edition = "2021"
 rust-version = "1.80"
 license = "MIT"

{polyxml-0.33.1 → polyxml-0.33.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.33.1
+Version: 0.33.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyxml-0.33.1 → polyxml-0.33.2}/crates/polyxml-core/src/codegen/go/mod.rs

@@ -447,6 +447,14 @@ impl GoCodegen {
                 self.emit_struct(out, s, ir);
             }
         }
+
+        let has_any_element = ir.emitted_types().any(|t| match t {
+            TypeDef::Struct(s) => s.fields.iter().any(|f| f.kind == FieldKind::Any),
+            _ => false,
+        });
+        if has_any_element {
+            out.push_str("// AnyElement represents an unmapped wildcard XML element (xs:any).\ntype AnyElement struct {\n    XMLName xml.Name\n    Attrs   []xml.Attr `xml:\",any,attr\" json:\"attrs,omitempty\"`\n    Content string     `xml:\",innerxml\" json:\"content,omitempty\"`\n}\n\n");
+        }
     }
 
     fn emit_simple_type(&self, out: &mut String, simple: &SimpleTypeDef, ir: &SchemaIR) {
@@ -1104,6 +1112,15 @@ impl GoCodegen {
         if f.kind == FieldKind::AnyAttribute {
             return "[]xml.Attr".to_string();
         }
+        if f.kind == FieldKind::Any {
+            if f.cardinality.is_list() {
+                return "[]AnyElement".to_string();
+            } else if f.is_cycle_cut || f.cardinality.is_optional() || f.nillable {
+                return "*AnyElement".to_string();
+            } else {
+                return "AnyElement".to_string();
+            }
+        }
         let base_type = self.context.map_type_ref(&f.type_ref);
 
         if f.cardinality.is_list() {
@@ -1156,6 +1173,15 @@ impl GoCodegen {
                 if self.options.backend == GoBackend::Sonic {
                     parts.push("sonic:\"-\"".to_string());
                 }
+            } else if f.kind == FieldKind::Any {
+                let is_opt = f.cardinality.is_optional() || f.nillable;
+                let tag = if is_opt { "any,omitempty" } else { "any" };
+                if self.options.emit_json_tags {
+                    parts.push(format!("json:\"{}\"", tag));
+                }
+                if self.options.backend == GoBackend::Sonic {
+                    parts.push(format!("sonic:\"{}\"", tag));
+                }
             } else {
                 let is_opt = f.cardinality.is_optional() || f.nillable;
                 let raw_json_name = if f.kind == FieldKind::Text {

{polyxml-0.33.1 → polyxml-0.33.2}/crates/polyxml-core/src/parser.rs

@@ -256,6 +256,40 @@ fn append_general_ref(
     Ok(())
 }
 
+#[derive(Debug)]
+struct AnyElementFrame {
+    qname: String,
+    attributes: HashMap<String, PolyValue>,
+    text: String,
+    children: Vec<PolyValue>,
+}
+
+fn resolve_element_qname(
+    e: &BytesStart,
+    scope: &HashMap<String, String>,
+) -> (Option<String>, String) {
+    let raw = e.name().into_inner();
+    let (prefix, local) = match raw.split_once(':') {
+        Some((p, l)) => (p, l),
+        None => ("", raw),
+    };
+    let ns = scope.get(prefix).cloned();
+    (ns, local.to_string())
+}
+
+fn parse_any_element_attrs(e: &BytesStart) -> Result<HashMap<String, PolyValue>> {
+    let mut attributes = HashMap::new();
+    for attr in e.attributes().flatten() {
+        let key = attr.key.as_ref();
+        if key == "xmlns" || key.starts_with("xmlns:") {
+            continue;
+        }
+        let unescaped = quick_xml::escape::unescape(attr.value.as_ref())?;
+        attributes.insert(key.to_string(), PolyValue::String(unescaped.to_string()));
+    }
+    Ok(attributes)
+}
+
 pub const DEFAULT_MAX_DEPTH: usize = 256;
 
 impl XmlDeserializer {
@@ -324,6 +358,7 @@ impl XmlDeserializer {
         let mut active_scalar_field: Option<(usize, ScalarType, bool)> = None;
         let mut active_mixed_scalar: Option<(String, ScalarType)> = None;
         let mut unknown_depth: usize = 0;
+        let mut any_stack: Vec<AnyElementFrame> = Vec::new();
         let mut text_buf: Vec<u8> = Vec::new();
         let mut buf = Vec::new();
 
@@ -339,6 +374,23 @@ impl XmlDeserializer {
                         unknown_depth = 1;
                         continue;
                     }
+                    if !any_stack.is_empty() {
+                        let scope = namespace_stack.last().unwrap();
+                        let (ns, local) = resolve_element_qname(e, scope);
+                        let qname = if let Some(uri) = ns {
+                            format!("{{{}}}{}", uri, local)
+                        } else {
+                            local
+                        };
+                        let attributes = parse_any_element_attrs(e)?;
+                        any_stack.push(AnyElementFrame {
+                            qname,
+                            attributes,
+                            text: String::new(),
+                            children: Vec::new(),
+                        });
+                        continue;
+                    }
                     if stack.len() >= max_depth {
                         return Err(PolyXmlError::MaxDepthExceeded {
                             max_depth,
@@ -445,6 +497,44 @@ impl XmlDeserializer {
                         } else {
                             unknown_depth = 1;
                         }
+                    } else if let Some(any_idx) = current_schema.any_element_field {
+                        let scope = namespace_stack.last().unwrap();
+                        let (ns, local) = resolve_element_qname(e, scope);
+                        let any_field = &current_schema.fields[any_idx];
+                        let allowed = match any_field.namespace.as_deref() {
+                            Some("##other") => {
+                                match (ns.as_deref(), current_schema.namespace.as_deref()) {
+                                    (Some(elem_ns), Some(target_ns)) => elem_ns != target_ns,
+                                    (None, Some(_)) => true,
+                                    (Some(_), None) => true,
+                                    (None, None) => false,
+                                }
+                            }
+                            Some("##targetNamespace") => {
+                                ns.as_deref() == current_schema.namespace.as_deref()
+                            }
+                            Some("##local") => ns.is_none(),
+                            Some(allowed_ns) if allowed_ns != "##any" => {
+                                ns.as_deref() == Some(allowed_ns)
+                            }
+                            _ => true,
+                        };
+                        if allowed {
+                            let qname = if let Some(uri) = ns {
+                                format!("{{{}}}{}", uri, local)
+                            } else {
+                                local
+                            };
+                            let attributes = parse_any_element_attrs(e)?;
+                            any_stack.push(AnyElementFrame {
+                                qname,
+                                attributes,
+                                text: String::new(),
+                                children: Vec::new(),
+                            });
+                        } else {
+                            unknown_depth = 1;
+                        }
                     } else {
                         unknown_depth = 1;
                     }
@@ -456,6 +546,27 @@ impl XmlDeserializer {
                     {
                         continue;
                     }
+                    if !any_stack.is_empty() {
+                        let scope = namespace_scope(namespace_stack.last().unwrap(), e);
+                        let (ns, local) = resolve_element_qname(e, &scope);
+                        let qname = if let Some(uri) = ns {
+                            format!("{{{}}}{}", uri, local)
+                        } else {
+                            local
+                        };
+                        let attributes = parse_any_element_attrs(e)?;
+                        let mut obj = HashMap::new();
+                        obj.insert("qname".to_string(), PolyValue::String(qname));
+                        obj.insert("attributes".to_string(), PolyValue::Object(attributes));
+                        obj.insert("text".to_string(), PolyValue::String(String::new()));
+                        obj.insert("children".to_string(), PolyValue::List(Vec::new()));
+                        any_stack
+                            .last_mut()
+                            .unwrap()
+                            .children
+                            .push(PolyValue::Object(obj));
+                        continue;
+                    }
                     let local_name = e.local_name();
                     let scope = namespace_scope(namespace_stack.last().unwrap(), e);
                     let is_nil = is_nil_element(e);
@@ -543,12 +654,65 @@ impl XmlDeserializer {
                                 .unwrap()
                                 .push_mixed_item(&branch.variant_name, value);
                         }
+                    } else if let Some(any_idx) = current_schema.any_element_field {
+                        let (ns, local) = resolve_element_qname(e, &scope);
+                        let any_field = &current_schema.fields[any_idx];
+                        let allowed = match any_field.namespace.as_deref() {
+                            Some("##other") => {
+                                match (ns.as_deref(), current_schema.namespace.as_deref()) {
+                                    (Some(elem_ns), Some(target_ns)) => elem_ns != target_ns,
+                                    (None, Some(_)) => true,
+                                    (Some(_), None) => true,
+                                    (None, None) => false,
+                                }
+                            }
+                            Some("##targetNamespace") => {
+                                ns.as_deref() == current_schema.namespace.as_deref()
+                            }
+                            Some("##local") => ns.is_none(),
+                            Some(allowed_ns) if allowed_ns != "##any" => {
+                                ns.as_deref() == Some(allowed_ns)
+                            }
+                            _ => true,
+                        };
+                        if allowed {
+                            let qname = if let Some(uri) = ns {
+                                format!("{{{}}}{}", uri, local)
+                            } else {
+                                local
+                            };
+                            let attributes = parse_any_element_attrs(e)?;
+                            let mut obj = HashMap::new();
+                            obj.insert("qname".to_string(), PolyValue::String(qname));
+                            obj.insert("attributes".to_string(), PolyValue::Object(attributes));
+                            obj.insert("text".to_string(), PolyValue::String(String::new()));
+                            obj.insert("children".to_string(), PolyValue::List(Vec::new()));
+                            let poly_obj = PolyValue::Object(obj);
+                            let parent_frame = stack.last_mut().unwrap();
+                            if matches!(any_field.val_type, ValueType::List(_)) {
+                                parent_frame.push_list_item(any_idx, poly_obj);
+                            } else {
+                                parent_frame.values[any_idx] = Some(poly_obj);
+                            }
+                        }
                     }
                 }
                 Ok(Event::Text(ref e)) => {
                     if unknown_depth > 0 {
                         continue;
                     }
+                    if !any_stack.is_empty() {
+                        let raw = e.as_ref();
+                        let raw_bytes = raw.as_bytes();
+                        if memchr::memchr(b'&', raw_bytes).is_none() {
+                            if let Ok(s) = std::str::from_utf8(raw_bytes) {
+                                any_stack.last_mut().unwrap().text.push_str(s);
+                            }
+                        } else if let Ok(unescaped) = quick_xml::escape::unescape(raw) {
+                            any_stack.last_mut().unwrap().text.push_str(&unescaped);
+                        }
+                        continue;
+                    }
                     let raw = e.as_ref();
                     let raw_bytes = raw.as_bytes();
                     if memchr::memchr(b'&', raw_bytes).is_none() {
@@ -578,6 +742,12 @@ impl XmlDeserializer {
                     if unknown_depth > 0 {
                         continue;
                     }
+                    if !any_stack.is_empty() {
+                        if let Ok(s) = std::str::from_utf8(e.as_ref().as_bytes()) {
+                            any_stack.last_mut().unwrap().text.push_str(s);
+                        }
+                        continue;
+                    }
                     if active_scalar_field.is_some() || active_mixed_scalar.is_some() {
                         text_buf.extend_from_slice(e.as_ref().as_bytes());
                     } else if let Some(frame) = stack.last_mut() {
@@ -592,6 +762,14 @@ impl XmlDeserializer {
                     if unknown_depth > 0 {
                         continue;
                     }
+                    if !any_stack.is_empty() {
+                        let mut resolved = Vec::new();
+                        append_general_ref(e, true, &mut resolved, None)?;
+                        if let Ok(s) = std::str::from_utf8(&resolved) {
+                            any_stack.last_mut().unwrap().text.push_str(s);
+                        }
+                        continue;
+                    }
                     let frame_tb = stack.last_mut().and_then(|f| f.frame_text_buf.as_mut());
                     if active_scalar_field.is_some()
                         || active_mixed_scalar.is_some()
@@ -617,6 +795,33 @@ impl XmlDeserializer {
                         unknown_depth -= 1;
                         continue;
                     }
+                    if !any_stack.is_empty() {
+                        let frame = any_stack.pop().unwrap();
+                        let mut obj = HashMap::new();
+                        obj.insert("qname".to_string(), PolyValue::String(frame.qname));
+                        obj.insert(
+                            "attributes".to_string(),
+                            PolyValue::Object(frame.attributes),
+                        );
+                        obj.insert("text".to_string(), PolyValue::String(frame.text));
+                        obj.insert("children".to_string(), PolyValue::List(frame.children));
+                        let poly_obj = PolyValue::Object(obj);
+
+                        if let Some(parent) = any_stack.last_mut() {
+                            parent.children.push(poly_obj);
+                        } else {
+                            let parent_frame = stack.last_mut().unwrap();
+                            if let Some(any_idx) = parent_frame.schema.any_element_field {
+                                let field = &parent_frame.schema.fields[any_idx];
+                                if matches!(field.val_type, ValueType::List(_)) {
+                                    parent_frame.push_list_item(any_idx, poly_obj);
+                                } else {
+                                    parent_frame.values[any_idx] = Some(poly_obj);
+                                }
+                            }
+                        }
+                        continue;
+                    }
                     if let Some((kind, scalar_type)) = active_mixed_scalar.take() {
                         let parsed = ValueConverter::parse_scalar(&scalar_type, &text_buf, &kind)?;
                         stack.last_mut().unwrap().push_mixed_item(&kind, parsed);

{polyxml-0.33.1 → polyxml-0.33.2}/crates/polyxml-core/src/schema.rs

@@ -7,6 +7,7 @@ pub enum FieldKind {
     Element,
     Text,
     AnyAttribute,
+    Any,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -108,6 +109,7 @@ pub struct ModelSchema {
     pub attribute_map: HashMap<Vec<u8>, usize>,
     pub text_field: Option<usize>,
     pub any_attribute_field: Option<usize>,
+    pub any_element_field: Option<usize>,
     pub mixed_content: Option<MixedContentSchema>,
     /// Declared `abstract="true"` in the source schema.
     pub is_abstract: bool,
@@ -338,7 +340,7 @@ impl ModelSchema {
                 crate::ir::FieldKind::Element => FieldKind::Element,
                 crate::ir::FieldKind::Text => FieldKind::Text,
                 crate::ir::FieldKind::AnyAttribute => FieldKind::AnyAttribute,
-                _ => FieldKind::Element,
+                crate::ir::FieldKind::Any => FieldKind::Any,
             };
 
             let mut val_type = build_type(&f.type_ref, ir, visited);
@@ -569,6 +571,7 @@ impl ModelSchemaBuilder {
         let mut attribute_map = HashMap::new();
         let mut text_field = None;
         let mut any_attribute_field = None;
+        let mut any_element_field = None;
 
         for (idx, field) in self.fields.iter().enumerate() {
             match field.kind {
@@ -591,6 +594,9 @@ impl ModelSchemaBuilder {
                 FieldKind::AnyAttribute => {
                     any_attribute_field = Some(idx);
                 }
+                FieldKind::Any => {
+                    any_element_field = Some(idx);
+                }
             }
         }
 
@@ -607,6 +613,7 @@ impl ModelSchemaBuilder {
             attribute_map,
             text_field,
             any_attribute_field,
+            any_element_field,
             mixed_content: None,
             is_abstract: self.is_abstract,
             variants: Arc::new(RwLock::new(Vec::new())),

{polyxml-0.33.1 → polyxml-0.33.2}/crates/polyxml-core/src/schema_parser/mod.rs

@@ -631,7 +631,26 @@ impl XsdParser {
                             }
                         }
                         "any" => {
-                            fields.push(parse_any_field(e));
+                            let in_unbounded = compositor_stack.iter().any(|c| c.is_unbounded);
+                            let in_choice = compositor_stack
+                                .last()
+                                .map(|c| c.kind == CompositorKind::Choice)
+                                .unwrap_or(false);
+                            let field = parse_any_field(e, in_choice, in_unbounded);
+                            if in_choice {
+                                if let Some(frame) = compositor_stack.last_mut() {
+                                    if frame.kind == CompositorKind::Choice {
+                                        frame.choice_branches.push(UnionBranch {
+                                            variant_name: field.name.clone(),
+                                            xml_name: field.xml_name.clone(),
+                                            namespace: field.namespace.clone(),
+                                            type_ref: field.type_ref.clone(),
+                                            documentation: field.documentation.clone(),
+                                        });
+                                    }
+                                }
+                            }
+                            fields.push(field);
                         }
                         "anyAttribute"
                             if !fields.iter().any(|f| f.kind == FieldKind::AnyAttribute) =>
@@ -696,7 +715,26 @@ impl XsdParser {
                             }
                         }
                         "any" => {
-                            fields.push(parse_any_field(e));
+                            let in_unbounded = compositor_stack.iter().any(|c| c.is_unbounded);
+                            let in_choice = compositor_stack
+                                .last()
+                                .map(|c| c.kind == CompositorKind::Choice)
+                                .unwrap_or(false);
+                            let field = parse_any_field(e, in_choice, in_unbounded);
+                            if in_choice {
+                                if let Some(frame) = compositor_stack.last_mut() {
+                                    if frame.kind == CompositorKind::Choice {
+                                        frame.choice_branches.push(UnionBranch {
+                                            variant_name: field.name.clone(),
+                                            xml_name: field.xml_name.clone(),
+                                            namespace: field.namespace.clone(),
+                                            type_ref: field.type_ref.clone(),
+                                            documentation: field.documentation.clone(),
+                                        });
+                                    }
+                                }
+                            }
+                            fields.push(field);
                         }
                         "anyAttribute"
                             if !fields.iter().any(|f| f.kind == FieldKind::AnyAttribute) =>
@@ -956,7 +994,10 @@ impl XsdParser {
                             skip_subtree(reader)?;
                             depth -= 1;
                         }
-                        "any" => def.fields.push(parse_any_field(e)),
+                        "any" => {
+                            let in_unbounded = compositor_stack.iter().any(|&b| b);
+                            def.fields.push(parse_any_field(e, in_choice, in_unbounded));
+                        }
                         _ => {}
                     }
                 }
@@ -979,7 +1020,10 @@ impl XsdParser {
                                 ));
                             }
                         }
-                        "any" => def.fields.push(parse_any_field(e)),
+                        "any" => {
+                            let in_unbounded = compositor_stack.iter().any(|&b| b);
+                            def.fields.push(parse_any_field(e, in_choice, in_unbounded));
+                        }
                         _ => {}
                     }
                 }
@@ -1863,14 +1907,34 @@ fn parse_attribute_field(
     })
 }
 
-fn parse_any_field(_e: &BytesStart) -> FieldDef {
+fn parse_any_field(e: &BytesStart, in_choice: bool, in_unbounded_compositor: bool) -> FieldDef {
+    let min_occurs = if in_choice {
+        0
+    } else {
+        get_attr_value(e, "minOccurs")
+            .and_then(|v| v.parse::<usize>().ok())
+            .unwrap_or(1)
+    };
+    let max_occurs = if in_unbounded_compositor {
+        OccursLimit::Unbounded
+    } else {
+        match get_attr_value(e, "maxOccurs").as_deref() {
+            Some("unbounded") => OccursLimit::Unbounded,
+            Some(v) => OccursLimit::Count(v.parse::<usize>().unwrap_or(1)),
+            None => OccursLimit::Count(1),
+        }
+    };
+    let namespace = get_attr_value(e, "namespace");
     FieldDef {
         name: "any".to_string(),
         xml_name: "*".to_string(),
-        namespace: None,
+        namespace,
         kind: FieldKind::Any,
         type_ref: TypeRef::Primitive(PrimitiveType::AnyType),
-        cardinality: Cardinality::unbounded(0),
+        cardinality: Cardinality {
+            min_occurs,
+            max_occurs,
+        },
         nillable: false,
         default_value: None,
         fixed_value: None,

{polyxml-0.33.1 → polyxml-0.33.2}/crates/polyxml-core/src/serializer.rs

@@ -633,6 +633,10 @@ impl XmlSerializer {
                             }
                         }
                     }
+                } else if field.kind == FieldKind::Any {
+                    if let Some(val) = get_field(idx, &field.name) {
+                        Self::write_any_wildcard_element(writer, val, ns_ctx)?;
+                    }
                 }
             }
         }
@@ -644,4 +648,105 @@ impl XmlSerializer {
 
         Ok(())
     }
+
+    fn write_any_wildcard_element<W: std::io::Write>(
+        writer: &mut quick_xml::Writer<W>,
+        val: &PolyValue,
+        ns_ctx: Option<&NamespaceContext>,
+    ) -> Result<()> {
+        match val {
+            PolyValue::List(items) => {
+                for item in items {
+                    Self::write_single_wildcard_element(writer, item, ns_ctx)?;
+                }
+            }
+            PolyValue::Object(_) => {
+                Self::write_single_wildcard_element(writer, val, ns_ctx)?;
+            }
+            _ => {}
+        }
+        Ok(())
+    }
+
+    fn write_single_wildcard_element<W: std::io::Write>(
+        writer: &mut quick_xml::Writer<W>,
+        val: &PolyValue,
+        ns_ctx: Option<&NamespaceContext>,
+    ) -> Result<()> {
+        let PolyValue::Object(map) = val else {
+            return Ok(());
+        };
+        let Some(PolyValue::String(qname)) = map.get("qname") else {
+            return Ok(());
+        };
+        let (ns_uri, local) = if qname.starts_with('{') {
+            if let Some(end) = qname.find('}') {
+                (Some(&qname[1..end]), &qname[end + 1..])
+            } else {
+                (None, qname.as_str())
+            }
+        } else {
+            (None, qname.as_str())
+        };
+
+        let (qualified, xmlns_attr) = if let Some(uri) = ns_uri {
+            if let Some(ctx) = ns_ctx {
+                if let Some(prefix) = ctx.uri_to_prefix.get(uri) {
+                    if !prefix.is_empty() {
+                        (Cow::Owned(format!("{}:{}", prefix, local)), None)
+                    } else {
+                        (Cow::Borrowed(local), None)
+                    }
+                } else {
+                    (Cow::Borrowed(local), Some(uri))
+                }
+            } else {
+                (Cow::Borrowed(local), Some(uri))
+            }
+        } else {
+            (Cow::Borrowed(local), None)
+        };
+
+        let mut start = BytesStart::new(qualified.as_ref());
+        if let Some(uri) = xmlns_attr {
+            start.push_attribute(("xmlns", uri));
+        }
+
+        if let Some(PolyValue::Object(attrs)) = map.get("attributes") {
+            let mut sorted_keys: Vec<_> = attrs.keys().collect();
+            sorted_keys.sort();
+            for k in sorted_keys {
+                if let Some(v) = attrs.get(k) {
+                    let mut buf = [0u8; lexical_core::BUFFER_SIZE];
+                    if let Some(s) = Self::format_scalar_to(v, &mut buf) {
+                        start.push_attribute((k.as_str(), s));
+                    }
+                }
+            }
+        }
+
+        writer
+            .write_event(Event::Start(start))
+            .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+
+        if let Some(PolyValue::String(text)) = map.get("text") {
+            if !text.is_empty() {
+                writer
+                    .write_event(Event::Text(BytesText::new(text)))
+                    .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+            }
+        }
+
+        if let Some(PolyValue::List(children)) = map.get("children") {
+            for child in children {
+                Self::write_single_wildcard_element(writer, child, ns_ctx)?;
+            }
+        }
+
+        writer
+            .write_event(Event::End(BytesEnd::new(qualified.as_ref())))
+            .map_err(|e| PolyXmlError::SerializationError(e.to_string()))?;
+
+        Ok(())
+    }
 }