@abapify/ts-xsd 0.4.34 → 0.4.36

package/dist/index.mjs

@@ -1,6 +1,6 @@
-import { _ as getLocalName, a as loadAndLinkSchema, c as getSubstitutes, d as SchemaTraverser, f as resolveSchemaTypes, g as getChildElements, h as getAttributeValue, i as linkSchema, l as resolveSchema, m as getAllChildElements, n as createSchemaLoader, o as loadSchema, p as parseXsd, r as defaultLoader, s as parseSchemaContent, t as runCodegen, u as SchemaResolver, v as getTextContent } from "./runner-BGNA8Sl-.mjs";
-import { n as generateSchemaLiteral, t as generateSchemaFile } from "./generate-DQJ38rjv.mjs";
-import { n as deriveRootTypeName, r as generateInterfaces, t as defineConfig } from "./types-CySWjUcM.mjs";
+import { _ as getLocalName, a as loadAndLinkSchema, c as getSubstitutes, d as SchemaTraverser, f as resolveSchemaTypes, g as getChildElements, h as getAttributeValue, i as linkSchema, l as resolveSchema, m as getAllChildElements, n as createSchemaLoader, o as loadSchema, p as parseXsd, r as defaultLoader, s as parseSchemaContent, t as runCodegen, u as SchemaResolver, v as getTextContent } from "./runner-BZNOc_YZ.mjs";
+import { n as generateSchemaLiteral, t as generateSchemaFile } from "./generate-BWLnwHUW.mjs";
+import { n as deriveRootTypeName, r as generateInterfaces, t as defineConfig } from "./types-BAx8yQfm.mjs";
 import { DOMImplementation, DOMParser, XMLSerializer } from "@xmldom/xmldom";
 
 // src/xsd/build.ts
@@ -17,14 +17,12 @@ function buildXsd(schema, options = {}) {
 		level: 0
 	};
 	const lines = [];
-	lines.push("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
-	lines.push(buildSchema(schema, ctx));
+	lines.push("<?xml version=\"1.0\" encoding=\"UTF-8\"?>", buildSchema(schema, ctx));
 	return lines.join(pretty ? "\n" : "");
 }
 function buildSchema(schema, ctx) {
 	const attrs = [];
-	if (schema.$xmlns) for (const [prefix, uri] of Object.entries(schema.$xmlns)) if (prefix === "") attrs.push(`xmlns="${uri}"`);
-	else attrs.push(`xmlns:${prefix}="${uri}"`);
+	addXmlnsAttrs(attrs, schema.$xmlns);
 	addAttr(attrs, "id", schema.id);
 	addAttr(attrs, "targetNamespace", schema.targetNamespace);
 	addAttr(attrs, "version", schema.version);
@@ -40,19 +38,19 @@ function buildSchema(schema, ctx) {
 		...ctx,
 		level: ctx.level + 1
 	};
-	if (schema.annotation) for (const ann of schema.annotation) children.push(buildAnnotation(ann, childCtx));
-	if (schema.include) for (const inc of schema.include) children.push(buildInclude(inc, childCtx));
-	if (schema.import) for (const imp of schema.import) children.push(buildImport(imp, childCtx));
-	if (schema.redefine) for (const red of schema.redefine) children.push(buildRedefine(red, childCtx));
-	if (schema.override) for (const ovr of schema.override) children.push(buildOverride(ovr, childCtx));
-	if (schema.defaultOpenContent) children.push(buildDefaultOpenContent(schema.defaultOpenContent, childCtx));
-	if (schema.simpleType && Array.isArray(schema.simpleType)) for (const st of schema.simpleType) children.push(buildTopLevelSimpleType(st, childCtx));
-	if (schema.complexType && Array.isArray(schema.complexType)) for (const ct of schema.complexType) children.push(buildTopLevelComplexType(ct, childCtx));
-	if (schema.group) for (const grp of schema.group) children.push(buildNamedGroup(grp, childCtx));
-	if (schema.attributeGroup) for (const ag of schema.attributeGroup) children.push(buildNamedAttributeGroup(ag, childCtx));
-	if (schema.element) for (const el of schema.element) children.push(buildTopLevelElement(el, childCtx));
-	if (schema.attribute) for (const attr of schema.attribute) children.push(buildTopLevelAttribute(attr, childCtx));
-	if (schema.notation) for (const not of schema.notation) children.push(buildNotation(not, childCtx));
+	appendBuilt(children, schema.annotation, (ann) => buildAnnotation(ann, childCtx));
+	appendBuilt(children, schema.include, (inc) => buildInclude(inc, childCtx));
+	appendBuilt(children, schema.import, (imp) => buildImport(imp, childCtx));
+	appendBuilt(children, schema.redefine, (red) => buildRedefine(red, childCtx));
+	appendBuilt(children, schema.override, (ovr) => buildOverride(ovr, childCtx));
+	appendBuiltOne(children, schema.defaultOpenContent, (doc) => buildDefaultOpenContent(doc, childCtx));
+	appendBuilt(children, Array.isArray(schema.simpleType) ? schema.simpleType : [], (st) => buildTopLevelSimpleType(st, childCtx));
+	appendBuilt(children, Array.isArray(schema.complexType) ? schema.complexType : [], (ct) => buildTopLevelComplexType(ct, childCtx));
+	appendBuilt(children, schema.group, (grp) => buildNamedGroup(grp, childCtx));
+	appendBuilt(children, schema.attributeGroup, (ag) => buildNamedAttributeGroup(ag, childCtx));
+	appendBuilt(children, schema.element, (el) => buildTopLevelElement(el, childCtx));
+	appendBuilt(children, schema.attribute, (attr) => buildTopLevelAttribute(attr, childCtx));
+	appendBuilt(children, schema.notation, (not) => buildNotation(not, childCtx));
 	return buildElement$1(`${ctx.prefix}:schema`, attrs, children, ctx);
 }
 function buildAnnotation(ann, ctx) {
@@ -128,14 +126,14 @@ function buildOverride(ovr, ctx) {
 		...ctx,
 		level: ctx.level + 1
 	};
-	if (ovr.annotation) for (const ann of ovr.annotation) children.push(buildAnnotation(ann, childCtx));
-	if (ovr.simpleType) for (const st of ovr.simpleType) children.push(buildTopLevelSimpleType(st, childCtx));
-	if (ovr.complexType) for (const ct of ovr.complexType) children.push(buildTopLevelComplexType(ct, childCtx));
-	if (ovr.group) for (const grp of ovr.group) children.push(buildNamedGroup(grp, childCtx));
-	if (ovr.attributeGroup) for (const ag of ovr.attributeGroup) children.push(buildNamedAttributeGroup(ag, childCtx));
-	if (ovr.element) for (const el of ovr.element) children.push(buildTopLevelElement(el, childCtx));
-	if (ovr.attribute) for (const attr of ovr.attribute) children.push(buildTopLevelAttribute(attr, childCtx));
-	if (ovr.notation) for (const not of ovr.notation) children.push(buildNotation(not, childCtx));
+	appendBuilt(children, ovr.annotation, (ann) => buildAnnotation(ann, childCtx));
+	appendBuilt(children, ovr.simpleType, (st) => buildTopLevelSimpleType(st, childCtx));
+	appendBuilt(children, ovr.complexType, (ct) => buildTopLevelComplexType(ct, childCtx));
+	appendBuilt(children, ovr.group, (grp) => buildNamedGroup(grp, childCtx));
+	appendBuilt(children, ovr.attributeGroup, (ag) => buildNamedAttributeGroup(ag, childCtx));
+	appendBuilt(children, ovr.element, (el) => buildTopLevelElement(el, childCtx));
+	appendBuilt(children, ovr.attribute, (attr) => buildTopLevelAttribute(attr, childCtx));
+	appendBuilt(children, ovr.notation, (not) => buildNotation(not, childCtx));
 	return buildElement$1(`${ctx.prefix}:override`, attrs, children, ctx);
 }
 function buildTopLevelElement(el, ctx) {
@@ -253,22 +251,24 @@ function buildComplexTypeContent(ct, attrs, ctx) {
 		...ctx,
 		level: ctx.level + 1
 	};
-	if (ct.annotation) children.push(buildAnnotation(ct.annotation, childCtx));
+	appendBuiltOne(children, ct.annotation, (ann) => buildAnnotation(ann, childCtx));
 	if (ct.simpleContent) children.push(buildSimpleContent(ct.simpleContent, childCtx));
 	else if (ct.complexContent) children.push(buildComplexContent(ct.complexContent, childCtx));
-	else {
-		if (ct.openContent) children.push(buildOpenContent(ct.openContent, childCtx));
-		if (ct.group) children.push(buildGroupRef(ct.group, childCtx));
-		if (ct.all) children.push(buildAll(ct.all, childCtx));
-		if (ct.choice) children.push(buildExplicitGroup(ct.choice, "choice", childCtx));
-		if (ct.sequence) children.push(buildExplicitGroup(ct.sequence, "sequence", childCtx));
-		if (ct.attribute) for (const attr of ct.attribute) children.push(buildLocalAttribute(attr, childCtx));
-		if (ct.attributeGroup) for (const ag of ct.attributeGroup) children.push(buildAttributeGroupRef(ag, childCtx));
-		if (ct.anyAttribute) children.push(buildAnyAttribute(ct.anyAttribute, childCtx));
-		if (ct.assert) for (const a of ct.assert) children.push(buildAssertion(a, childCtx));
-	}
+	else buildComplexTypeShortForm(ct, children, childCtx);
 	return buildElement$1(`${ctx.prefix}:complexType`, attrs, children, ctx);
 }
+/** Short form: content model and attributes directly on the complexType. */
+function buildComplexTypeShortForm(ct, children, childCtx) {
+	appendBuiltOne(children, ct.openContent, (oc) => buildOpenContent(oc, childCtx));
+	appendBuiltOne(children, ct.group, (grp) => buildGroupRef(grp, childCtx));
+	appendBuiltOne(children, ct.all, (all) => buildAll(all, childCtx));
+	appendBuiltOne(children, ct.choice, (c) => buildExplicitGroup(c, "choice", childCtx));
+	appendBuiltOne(children, ct.sequence, (s) => buildExplicitGroup(s, "sequence", childCtx));
+	appendBuilt(children, ct.attribute, (attr) => buildLocalAttribute(attr, childCtx));
+	appendBuilt(children, ct.attributeGroup, (ag) => buildAttributeGroupRef(ag, childCtx));
+	appendBuiltOne(children, ct.anyAttribute, (aa) => buildAnyAttribute(aa, childCtx));
+	appendBuilt(children, ct.assert, (a) => buildAssertion(a, childCtx));
+}
 function buildTopLevelSimpleType(st, ctx) {
 	const attrs = [];
 	addAttr(attrs, "id", st.id);
@@ -308,20 +308,20 @@ function buildSimpleTypeRestriction(r, ctx) {
 	return buildElement$1(`${ctx.prefix}:restriction`, attrs, children, ctx);
 }
 function buildFacets(r, children, ctx) {
-	if (r.minExclusive) for (const f of r.minExclusive) children.push(buildFacet(f, "minExclusive", ctx));
-	if (r.minInclusive) for (const f of r.minInclusive) children.push(buildFacet(f, "minInclusive", ctx));
-	if (r.maxExclusive) for (const f of r.maxExclusive) children.push(buildFacet(f, "maxExclusive", ctx));
-	if (r.maxInclusive) for (const f of r.maxInclusive) children.push(buildFacet(f, "maxInclusive", ctx));
-	if (r.totalDigits) for (const f of r.totalDigits) children.push(buildFacet(f, "totalDigits", ctx));
-	if (r.fractionDigits) for (const f of r.fractionDigits) children.push(buildFacet(f, "fractionDigits", ctx));
-	if (r.length) for (const f of r.length) children.push(buildFacet(f, "length", ctx));
-	if (r.minLength) for (const f of r.minLength) children.push(buildFacet(f, "minLength", ctx));
-	if (r.maxLength) for (const f of r.maxLength) children.push(buildFacet(f, "maxLength", ctx));
-	if (r.enumeration) for (const f of r.enumeration) children.push(buildFacet(f, "enumeration", ctx));
-	if (r.whiteSpace) for (const f of r.whiteSpace) children.push(buildFacet(f, "whiteSpace", ctx));
-	if (r.pattern) for (const p of r.pattern) children.push(buildPattern(p, ctx));
-	if (r.assertion) for (const a of r.assertion) children.push(buildAssertion(a, ctx));
-	if (r.explicitTimezone) for (const f of r.explicitTimezone) children.push(buildFacet(f, "explicitTimezone", ctx));
+	appendBuilt(children, r.minExclusive, (f) => buildFacet(f, "minExclusive", ctx));
+	appendBuilt(children, r.minInclusive, (f) => buildFacet(f, "minInclusive", ctx));
+	appendBuilt(children, r.maxExclusive, (f) => buildFacet(f, "maxExclusive", ctx));
+	appendBuilt(children, r.maxInclusive, (f) => buildFacet(f, "maxInclusive", ctx));
+	appendBuilt(children, r.totalDigits, (f) => buildFacet(f, "totalDigits", ctx));
+	appendBuilt(children, r.fractionDigits, (f) => buildFacet(f, "fractionDigits", ctx));
+	appendBuilt(children, r.length, (f) => buildFacet(f, "length", ctx));
+	appendBuilt(children, r.minLength, (f) => buildFacet(f, "minLength", ctx));
+	appendBuilt(children, r.maxLength, (f) => buildFacet(f, "maxLength", ctx));
+	appendBuilt(children, r.enumeration, (f) => buildFacet(f, "enumeration", ctx));
+	appendBuilt(children, r.whiteSpace, (f) => buildFacet(f, "whiteSpace", ctx));
+	appendBuilt(children, r.pattern, (p) => buildPattern(p, ctx));
+	appendBuilt(children, r.assertion, (a) => buildAssertion(a, ctx));
+	appendBuilt(children, r.explicitTimezone, (f) => buildFacet(f, "explicitTimezone", ctx));
 }
 function buildFacet(f, name, ctx) {
 	const attrs = [];
@@ -408,16 +408,16 @@ function buildComplexContentRestriction(r, ctx) {
 		...ctx,
 		level: ctx.level + 1
 	};
-	if (r.annotation) children.push(buildAnnotation(r.annotation, childCtx));
-	if (r.openContent) children.push(buildOpenContent(r.openContent, childCtx));
-	if (r.group) children.push(buildGroupRef(r.group, childCtx));
-	if (r.all) children.push(buildAll(r.all, childCtx));
-	if (r.choice) children.push(buildExplicitGroup(r.choice, "choice", childCtx));
-	if (r.sequence) children.push(buildExplicitGroup(r.sequence, "sequence", childCtx));
-	if (r.attribute) for (const attr of r.attribute) children.push(buildLocalAttribute(attr, childCtx));
-	if (r.attributeGroup) for (const ag of r.attributeGroup) children.push(buildAttributeGroupRef(ag, childCtx));
-	if (r.anyAttribute) children.push(buildAnyAttribute(r.anyAttribute, childCtx));
-	if (r.assert) for (const a of r.assert) children.push(buildAssertion(a, childCtx));
+	appendBuiltOne(children, r.annotation, (ann) => buildAnnotation(ann, childCtx));
+	appendBuiltOne(children, r.openContent, (oc) => buildOpenContent(oc, childCtx));
+	appendBuiltOne(children, r.group, (grp) => buildGroupRef(grp, childCtx));
+	appendBuiltOne(children, r.all, (all) => buildAll(all, childCtx));
+	appendBuiltOne(children, r.choice, (c) => buildExplicitGroup(c, "choice", childCtx));
+	appendBuiltOne(children, r.sequence, (s) => buildExplicitGroup(s, "sequence", childCtx));
+	appendBuilt(children, r.attribute, (attr) => buildLocalAttribute(attr, childCtx));
+	appendBuilt(children, r.attributeGroup, (ag) => buildAttributeGroupRef(ag, childCtx));
+	appendBuiltOne(children, r.anyAttribute, (aa) => buildAnyAttribute(aa, childCtx));
+	appendBuilt(children, r.assert, (a) => buildAssertion(a, childCtx));
 	return buildElement$1(`${ctx.prefix}:restriction`, attrs, children, ctx);
 }
 function buildComplexContentExtension(e, ctx) {
@@ -429,16 +429,16 @@ function buildComplexContentExtension(e, ctx) {
 		...ctx,
 		level: ctx.level + 1
 	};
-	if (e.annotation) children.push(buildAnnotation(e.annotation, childCtx));
-	if (e.openContent) children.push(buildOpenContent(e.openContent, childCtx));
-	if (e.group) children.push(buildGroupRef(e.group, childCtx));
-	if (e.all) children.push(buildAll(e.all, childCtx));
-	if (e.choice) children.push(buildExplicitGroup(e.choice, "choice", childCtx));
-	if (e.sequence) children.push(buildExplicitGroup(e.sequence, "sequence", childCtx));
-	if (e.attribute) for (const attr of e.attribute) children.push(buildLocalAttribute(attr, childCtx));
-	if (e.attributeGroup) for (const ag of e.attributeGroup) children.push(buildAttributeGroupRef(ag, childCtx));
-	if (e.anyAttribute) children.push(buildAnyAttribute(e.anyAttribute, childCtx));
-	if (e.assert) for (const a of e.assert) children.push(buildAssertion(a, childCtx));
+	appendBuiltOne(children, e.annotation, (ann) => buildAnnotation(ann, childCtx));
+	appendBuiltOne(children, e.openContent, (oc) => buildOpenContent(oc, childCtx));
+	appendBuiltOne(children, e.group, (grp) => buildGroupRef(grp, childCtx));
+	appendBuiltOne(children, e.all, (all) => buildAll(all, childCtx));
+	appendBuiltOne(children, e.choice, (c) => buildExplicitGroup(c, "choice", childCtx));
+	appendBuiltOne(children, e.sequence, (s) => buildExplicitGroup(s, "sequence", childCtx));
+	appendBuilt(children, e.attribute, (attr) => buildLocalAttribute(attr, childCtx));
+	appendBuilt(children, e.attributeGroup, (ag) => buildAttributeGroupRef(ag, childCtx));
+	appendBuiltOne(children, e.anyAttribute, (aa) => buildAnyAttribute(aa, childCtx));
+	appendBuilt(children, e.assert, (a) => buildAssertion(a, childCtx));
 	return buildElement$1(`${ctx.prefix}:extension`, attrs, children, ctx);
 }
 function buildSimpleContentRestriction(r, ctx) {
@@ -485,12 +485,12 @@ function buildExplicitGroup(g, name, ctx) {
 		...ctx,
 		level: ctx.level + 1
 	};
-	if (g.annotation) children.push(buildAnnotation(g.annotation, childCtx));
-	if (g.element) for (const el of g.element) children.push(buildLocalElement(el, childCtx));
-	if (g.group) for (const grp of g.group) children.push(buildGroupRef(grp, childCtx));
-	if (g.choice) for (const c of g.choice) children.push(buildExplicitGroup(c, "choice", childCtx));
-	if (g.sequence) for (const s of g.sequence) children.push(buildExplicitGroup(s, "sequence", childCtx));
-	if (g.any) for (const a of g.any) children.push(buildAny(a, childCtx));
+	appendBuiltOne(children, g.annotation, (ann) => buildAnnotation(ann, childCtx));
+	appendBuilt(children, g.element, (el) => buildLocalElement(el, childCtx));
+	appendBuilt(children, g.group, (grp) => buildGroupRef(grp, childCtx));
+	appendBuilt(children, g.choice, (c) => buildExplicitGroup(c, "choice", childCtx));
+	appendBuilt(children, g.sequence, (s) => buildExplicitGroup(s, "sequence", childCtx));
+	appendBuilt(children, g.any, (a) => buildAny(a, childCtx));
 	return buildElement$1(`${ctx.prefix}:${name}`, attrs, children, ctx);
 }
 function buildAll(a, ctx) {
@@ -731,17 +731,34 @@ function buildNotation(n, ctx) {
 	}));
 	return buildElement$1(`${ctx.prefix}:notation`, attrs, children, ctx);
 }
+/** Add xmlns:* namespace declaration attributes. */
+function addXmlnsAttrs(attrs, xmlns) {
+	if (!xmlns) return;
+	for (const [prefix, uri] of Object.entries(xmlns)) if (prefix === "") attrs.push(`xmlns="${uri}"`);
+	else attrs.push(`xmlns:${prefix}="${uri}"`);
+}
+/** Append one built child element per item, skipped when `items` is absent. */
+function appendBuilt(children, items, build) {
+	if (items) for (const item of items) children.push(build(item));
+}
+/** Append a single built child element when `item` is present. */
+function appendBuiltOne(children, item, build) {
+	if (item) children.push(build(item));
+}
 function addAttr(attrs, name, value) {
 	if (value !== void 0) attrs.push(`${name}="${escapeXml(value)}"`);
 }
-function addBoolAttr(attrs, name, value) {
+function addPlainAttr(attrs, name, value) {
 	if (value !== void 0) attrs.push(`${name}="${value}"`);
 }
+function addBoolAttr(attrs, name, value) {
+	addPlainAttr(attrs, name, value);
+}
 function addOccursAttr(attrs, name, value) {
-	if (value !== void 0) attrs.push(`${name}="${value}"`);
+	addPlainAttr(attrs, name, value);
 }
 function escapeXml(str) {
-	return str.replaceAll(/&/g, "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+	return str.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
 }
 function buildElement$1(tag, attrs, children, ctx) {
 	const indent = ctx.pretty ? ctx.indent.repeat(ctx.level) : "";
@@ -823,67 +840,86 @@ function linkSchemas(schemas) {
 * ```
 */
 function* walkComplexTypes(schema, options = {}) {
+	yield* ownComplexTypes(schema);
+	yield* redefineComplexTypes(schema);
+	yield* overrideComplexTypes(schema);
+	yield* walkNestedSchemas(schema, options, walkComplexTypes);
+}
+/** Yield complexTypes declared directly in the schema. */
+function* ownComplexTypes(schema) {
 	const complexTypes = schema.complexType;
-	if (complexTypes) {
-		if (Array.isArray(complexTypes)) for (const ct of complexTypes) yield {
-			ct,
-			schema
-		};
-		else for (const [name, ct] of Object.entries(complexTypes)) yield {
-			ct: {
-				...ct,
-				name
-			},
-			schema
-		};
-	}
-	if (schema.redefine) {
-		for (const redef of schema.redefine) if (redef.complexType) for (const ct of redef.complexType) yield {
-			ct,
-			schema
-		};
-	}
-	if (schema.override) {
-		for (const ovr of schema.override) if (ovr.complexType) for (const ct of ovr.complexType) yield {
-			ct,
-			schema
-		};
-	}
-	if (schema.$includes) for (const included of schema.$includes) yield* walkComplexTypes(included, options);
-	if (!options.includesOnly && schema.$imports) for (const imported of schema.$imports) yield* walkComplexTypes(imported, options);
+	if (!complexTypes) return;
+	if (Array.isArray(complexTypes)) for (const ct of complexTypes) yield {
+		ct,
+		schema
+	};
+	else for (const [name, ct] of Object.entries(complexTypes)) yield {
+		ct: {
+			...ct,
+			name
+		},
+		schema
+	};
+}
+/** Yield complexTypes from redefine blocks. */
+function* redefineComplexTypes(schema) {
+	for (const redef of schema.redefine ?? []) for (const ct of redef.complexType ?? []) yield {
+		ct,
+		schema
+	};
+}
+/** Yield complexTypes from override blocks (XSD 1.1). */
+function* overrideComplexTypes(schema) {
+	for (const ovr of schema.override ?? []) for (const ct of ovr.complexType ?? []) yield {
+		ct,
+		schema
+	};
+}
+/**
+* Recurse into $includes (same namespace), then $imports (different namespace).
+*/
+function* walkNestedSchemas(schema, options, walker) {
+	if (schema.$includes) for (const included of schema.$includes) yield* walker(included, options);
+	if (!options.includesOnly && schema.$imports) for (const imported of schema.$imports) yield* walker(imported, options);
 }
 /**
 * Walk all simpleTypes in a schema and its $imports/$includes.
 */
 function* walkSimpleTypes(schema, options = {}) {
+	yield* ownSimpleTypes(schema);
+	yield* redefineSimpleTypes(schema);
+	yield* overrideSimpleTypes(schema);
+	yield* walkNestedSchemas(schema, options, walkSimpleTypes);
+}
+/** Yield simpleTypes declared directly in the schema. */
+function* ownSimpleTypes(schema) {
 	const simpleTypes = schema.simpleType;
-	if (simpleTypes) {
-		if (Array.isArray(simpleTypes)) for (const st of simpleTypes) yield {
-			st,
-			schema
-		};
-		else for (const [name, st] of Object.entries(simpleTypes)) yield {
-			st: {
-				...st,
-				name
-			},
-			schema
-		};
-	}
-	if (schema.redefine) {
-		for (const redef of schema.redefine) if (redef.simpleType) for (const st of redef.simpleType) yield {
-			st,
-			schema
-		};
-	}
-	if (schema.override) {
-		for (const ovr of schema.override) if (ovr.simpleType) for (const st of ovr.simpleType) yield {
-			st,
-			schema
-		};
-	}
-	if (schema.$includes) for (const included of schema.$includes) yield* walkSimpleTypes(included, options);
-	if (!options.includesOnly && schema.$imports) for (const imported of schema.$imports) yield* walkSimpleTypes(imported, options);
+	if (!simpleTypes) return;
+	if (Array.isArray(simpleTypes)) for (const st of simpleTypes) yield {
+		st,
+		schema
+	};
+	else for (const [name, st] of Object.entries(simpleTypes)) yield {
+		st: {
+			...st,
+			name
+		},
+		schema
+	};
+}
+/** Yield simpleTypes from redefine blocks. */
+function* redefineSimpleTypes(schema) {
+	for (const redef of schema.redefine ?? []) for (const st of redef.simpleType ?? []) yield {
+		st,
+		schema
+	};
+}
+/** Yield simpleTypes from override blocks (XSD 1.1). */
+function* overrideSimpleTypes(schema) {
+	for (const ovr of schema.override ?? []) for (const st of ovr.simpleType ?? []) yield {
+		st,
+		schema
+	};
 }
 /**
 * Walk all top-level elements in a schema and its $imports/$includes.
@@ -960,46 +996,52 @@ function* walkGroup(group, source, schema, parentOptional = false, parentArray =
 	const groupOptional = parentOptional || group.minOccurs === 0 || group.minOccurs === "0";
 	const groupArray = parentArray || isArray(group);
 	const choiceOptional = source === "choice";
-	if (group.element) for (const element of group.element) {
-		const optional = choiceOptional || groupOptional || element.minOccurs === 0 || element.minOccurs === "0";
-		const array = groupArray || isArray(element);
-		if (element.ref) {
-			const refName = stripNsPrefix(element.ref);
-			const refEntry = findElement(refName, schema);
-			if (refEntry && isAbstractElement(refEntry.element)) {
-				const substitutes = findSubstitutes(refName, schema);
-				if (substitutes.length > 0) {
-					for (const sub of substitutes) yield {
-						element: sub,
-						optional,
-						array,
-						source,
-						schema
-					};
-					continue;
-				}
-			}
-		}
-		yield {
-			element,
+	for (const element of group.element ?? []) yield* elementEntries(element, choiceOptional || groupOptional || element.minOccurs === 0 || element.minOccurs === "0", groupArray || isArray(element), source, schema);
+	for (const nested of asGroupArray(group.sequence)) yield* walkGroup(nested, "sequence", schema, groupOptional, groupArray);
+	for (const nested of asGroupArray(group.choice)) yield* walkGroup(nested, "choice", schema, true, groupArray || isArray(nested));
+	for (const ref of asGroupArray(group.group)) if (ref.ref) yield* walkGroupRef(ref.ref, schema, groupOptional || choiceOptional, groupArray || isArray(ref));
+}
+/** Normalize a possibly single group value to an array. */
+function asGroupArray(value) {
+	if (value == null) return [];
+	return Array.isArray(value) ? value : [value];
+}
+/**
+* Yield the entries for one direct group element: substitutes of an abstract
+* element ref when present, otherwise the element itself.
+*/
+function* elementEntries(element, optional, array, source, schema) {
+	const substitutes = abstractSubstitutes(element, schema);
+	if (substitutes) {
+		for (const sub of substitutes) yield {
+			element: sub,
 			optional,
 			array,
 			source,
 			schema
 		};
+		return;
 	}
-	if (group.sequence) {
-		const sequences = Array.isArray(group.sequence) ? group.sequence : [group.sequence];
-		for (const nested of sequences) yield* walkGroup(nested, "sequence", schema, groupOptional, groupArray);
-	}
-	if (group.choice) {
-		const choices = Array.isArray(group.choice) ? group.choice : [group.choice];
-		for (const nested of choices) yield* walkGroup(nested, "choice", schema, true, groupArray || isArray(nested));
-	}
-	if (group.group) {
-		const refs = Array.isArray(group.group) ? group.group : [group.group];
-		for (const ref of refs) if (ref.ref) yield* walkGroupRef(ref.ref, schema, groupOptional || choiceOptional, groupArray || isArray(ref));
-	}
+	yield {
+		element,
+		optional,
+		array,
+		source,
+		schema
+	};
+}
+/**
+* Substitutes for an element ref to an abstract element, or undefined when
+* the element needs no substitution handling. No substitutes in this schema
+* yields undefined so the parser can handle substitution via the root schema.
+*/
+function abstractSubstitutes(element, schema) {
+	if (!element.ref) return void 0;
+	const refName = stripNsPrefix(element.ref);
+	const refEntry = findElement(refName, schema);
+	if (!refEntry || !isAbstractElement(refEntry.element)) return void 0;
+	const substitutes = findSubstitutes(refName, schema);
+	return substitutes.length > 0 ? substitutes : void 0;
 }
 /**
 * Walk elements from a group reference (xs:group ref="...").
@@ -1023,35 +1065,29 @@ function* walkGroupRef(ref, schema, parentOptional = false, parentArray = false)
 function* walkAttributes(ct, schema) {
 	if (ct.complexContent?.extension) {
 		const ext = ct.complexContent.extension;
-		if (ext.base) {
-			const baseEntry = findComplexType(stripNsPrefix(ext.base), schema);
-			if (baseEntry) yield* walkAttributes(baseEntry.ct, baseEntry.schema);
-		}
-		if (ext.attribute) for (const attr of ext.attribute) {
-			const resolved = resolveAttribute(attr, schema);
-			if (resolved) yield {
-				attribute: resolved,
-				required: resolved.use === "required",
-				schema
-			};
-		}
+		yield* walkBaseAttributes(ext.base, schema);
+		yield* resolvedAttributes(ext.attribute, schema);
 		yield* walkAttributeGroupRefs(ext.attributeGroup, schema);
 		return;
 	}
 	if (ct.simpleContent?.extension) {
 		const ext = ct.simpleContent.extension;
-		if (ext.attribute) for (const attr of ext.attribute) {
-			const resolved = resolveAttribute(attr, schema);
-			if (resolved) yield {
-				attribute: resolved,
-				required: resolved.use === "required",
-				schema
-			};
-		}
+		yield* resolvedAttributes(ext.attribute, schema);
 		yield* walkAttributeGroupRefs(ext.attributeGroup, schema);
 		return;
 	}
-	if (ct.attribute) for (const attr of ct.attribute) {
+	yield* resolvedAttributes(ct.attribute, schema);
+	yield* walkAttributeGroupRefs(ct.attributeGroup, schema);
+}
+/** Yield attributes inherited from the base type of an extension. */
+function* walkBaseAttributes(base, schema) {
+	if (!base) return;
+	const baseEntry = findComplexType(stripNsPrefix(base), schema);
+	if (baseEntry) yield* walkAttributes(baseEntry.ct, baseEntry.schema);
+}
+/** Yield declared attributes with attribute refs resolved. */
+function* resolvedAttributes(attributes, schema) {
+	for (const attr of attributes ?? []) {
 		const resolved = resolveAttribute(attr, schema);
 		if (resolved) yield {
 			attribute: resolved,
@@ -1059,7 +1095,6 @@ function* walkAttributes(ct, schema) {
 			schema
 		};
 	}
-	yield* walkAttributeGroupRefs(ct.attributeGroup, schema);
 }
 /**
 * Walk attributes from attributeGroup references.
@@ -1079,38 +1114,41 @@ function* walkAttributeGroupRefs(refs, schema) {
 	}
 }
 /**
+* Search a name in the current schema's declarations, then in $includes
+* (same namespace) and $imports (different namespace), depth-first.
+*/
+function findInSchemas(name, schema, searchOwn) {
+	const found = searchOwn(name, schema);
+	if (found) return found;
+	const linkedSchemas = [];
+	if (schema.$includes) linkedSchemas.push(...schema.$includes);
+	if (schema.$imports) linkedSchemas.push(...schema.$imports);
+	for (const linked of linkedSchemas) {
+		const result = findInSchemas(name, linked, searchOwn);
+		if (result) return result;
+	}
+}
+/**
 * Find a named group (xs:group) by name.
 */
 function findGroup(name, schema) {
-	if (schema.group) {
-		for (const g of schema.group) if (g.name === name) return g;
-	}
-	if (schema.$includes) for (const included of schema.$includes) {
-		const found = findGroup(name, included);
-		if (found) return found;
-	}
-	if (schema.$imports) for (const imported of schema.$imports) {
-		const found = findGroup(name, imported);
-		if (found) return found;
-	}
+	return findInSchemas(name, schema, findGroupInSchema);
+}
+/** Search a named group in a single schema's declarations. */
+function findGroupInSchema(name, schema) {
+	for (const g of schema.group ?? []) if (g.name === name) return g;
 }
 /**
 * Find a top-level attribute by name.
 * Searches current schema and $imports.
 */
 function findAttribute(name, schema) {
+	return findInSchemas(name, schema, findAttributeInSchema);
+}
+/** Search a top-level attribute in a single schema's declarations. */
+function findAttributeInSchema(name, schema) {
 	const schemaWithAttrs = schema;
-	if (schemaWithAttrs.attribute) {
-		for (const attr of schemaWithAttrs.attribute) if (attr.name === name) return attr;
-	}
-	if (schema.$includes) for (const included of schema.$includes) {
-		const found = findAttribute(name, included);
-		if (found) return found;
-	}
-	if (schema.$imports) for (const imported of schema.$imports) {
-		const found = findAttribute(name, imported);
-		if (found) return found;
-	}
+	for (const attr of schemaWithAttrs.attribute ?? []) if (attr.name === name) return attr;
 }
 /**
 * Resolve an attribute - handles both direct attributes and refs.
@@ -1136,17 +1174,11 @@ function resolveAttribute(attribute, schema) {
 * Find an attributeGroup by name.
 */
 function findAttributeGroup(name, schema) {
-	if (schema.attributeGroup) {
-		for (const g of schema.attributeGroup) if (g.name === name) return g;
-	}
-	if (schema.$includes) for (const included of schema.$includes) {
-		const found = findAttributeGroup(name, included);
-		if (found) return found;
-	}
-	if (schema.$imports) for (const imported of schema.$imports) {
-		const found = findAttributeGroup(name, imported);
-		if (found) return found;
-	}
+	return findInSchemas(name, schema, findAttributeGroupInSchema);
+}
+/** Search an attributeGroup in a single schema's declarations. */
+function findAttributeGroupInSchema(name, schema) {
+	for (const g of schema.attributeGroup ?? []) if (g.name === name) return g;
 }
 /**
 * Strip namespace prefix from a QName (e.g., "tns:PersonType" -> "PersonType")
@@ -1323,26 +1355,51 @@ function findElementByName(schema, name) {
 function parseElement(node, typeDef, schema, rootSchema) {
 	const result = {};
 	if (typeDef.simpleContent?.extension) return parseSimpleContent(node, typeDef, schema, rootSchema);
+	parseAttributes(node, typeDef, schema, result);
+	parseChildElements(node, typeDef, schema, rootSchema, result);
+	if (hasWildcard(typeDef, schema)) parseWildcardChildren(node, result);
+	return result;
+}
+/**
+* Parse declared attributes of an element into the result object.
+*/
+function parseAttributes(node, typeDef, schema, result) {
 	for (const { attribute } of walkAttributes(typeDef, schema)) {
 		if (!attribute.name) continue;
+		const type = attribute.type || "string";
 		const value = getAttributeValue(node, attribute.name);
-		if (value !== null) result[attribute.name] = convertValue(value, attribute.type || "string");
-		else if (attribute.default !== void 0) result[attribute.name] = convertValue(String(attribute.default), attribute.type || "string");
+		if (value !== null) {
+			result[attribute.name] = convertValue(value, type);
+			continue;
+		}
+		if (attribute.default !== void 0) result[attribute.name] = convertValue(String(attribute.default), type);
 	}
+}
+/**
+* Parse declared child elements of an element into the result object.
+*/
+function parseChildElements(node, typeDef, schema, rootSchema, result) {
 	for (const { element, array } of walkElements(typeDef, schema)) {
 		const resolved = resolveElementInfo$1(element, schema);
 		if (!resolved) continue;
-		if (isAbstractElement$1(resolved.name, rootSchema)) parseSubstitutionChildren(node, resolved.name, rootSchema, result);
-		else {
-			const children = getChildElements(node, resolved.name);
-			if (array || children.length > 1) {
-				const values = children.map((child) => parseChildValue(child, resolved.typeName, schema, rootSchema));
-				if (values.length > 0) result[resolved.name] = values;
-			} else if (children.length === 1) result[resolved.name] = parseChildValue(children[0], resolved.typeName, schema, rootSchema);
+		if (isAbstractElement$1(resolved.name, rootSchema)) {
+			parseSubstitutionChildren(node, resolved.name, rootSchema, result);
+			continue;
 		}
+		parseRegularChildren(node, resolved, array, schema, rootSchema, result);
 	}
-	if (hasWildcard(typeDef, schema)) parseWildcardChildren(node, result);
-	return result;
+}
+/**
+* Parse non-abstract declared children: arrays and single elements.
+*/
+function parseRegularChildren(node, resolved, array, schema, rootSchema, result) {
+	const children = getChildElements(node, resolved.name);
+	if (array || children.length > 1) {
+		const values = children.map((child) => parseChildValue(child, resolved.typeName, schema, rootSchema));
+		if (values.length > 0) result[resolved.name] = values;
+		return;
+	}
+	if (children.length === 1) result[resolved.name] = parseChildValue(children[0], resolved.typeName, schema, rootSchema);
 }
 /**
 * Parse children that substitute for an abstract element — substitutes can
@@ -1353,7 +1410,7 @@ function parseSubstitutionChildren(node, headName, rootSchema, result) {
 	for (const child of getAllChildElements(node)) {
 		const childName = getLocalName(child);
 		const substitute = substitutes.find((s) => s.element.name === childName);
-		if (substitute && substitute.element.name) {
+		if (substitute?.element.name) {
 			const subTypeName = substitute.element.type ? stripNsPrefix(substitute.element.type) : void 0;
 			result[substitute.element.name] = parseChildValue(child, subTypeName, substitute.schema, rootSchema);
 		}
@@ -1383,10 +1440,7 @@ function parseWildcardChildren(node, result) {
 */
 function parseAnyValue(node) {
 	const result = {};
-	for (let i = 0; i < node.attributes.length; i++) {
-		const attr = node.attributes[i];
-		result[`@${attr.name}`] = attr.value;
-	}
+	for (const attr of node.attributes) result[`@${attr.name}`] = attr.value;
 	const children = getAllChildElements(node);
 	if (children.length === 0) {
 		if (Object.keys(result).length === 0) return getTextContent(node);
@@ -1607,11 +1661,15 @@ function formatValue(value, type) {
 * Only adds newlines for nested elements
 */
 function formatXml(xml) {
-	let formatted = "";
-	let indent = 0;
+	return renderXmlParts(tokenizeXml(xml)).trim();
+}
+/**
+* Tokenize XML into tags and text using linear scan (avoids regex backtracking).
+*/
+function tokenizeXml(xml) {
 	const parts = [];
 	let pos = 0;
-	while (pos < xml.length) if (xml.charCodeAt(pos) === 60) {
+	while (pos < xml.length) if (xml.codePointAt(pos) === 60) {
 		const end = xml.indexOf(">", pos + 1);
 		if (end === -1) {
 			parts.push(xml.slice(pos));
@@ -1628,6 +1686,14 @@ function formatXml(xml) {
 		if (next > pos) parts.push(xml.slice(pos, next));
 		pos = next;
 	}
+	return parts;
+}
+/**
+* Render tokenized XML parts with indentation.
+*/
+function renderXmlParts(parts) {
+	let formatted = "";
+	let indent = 0;
 	let lastWasText = false;
 	for (let i = 0; i < parts.length; i++) {
 		const part = parts[i];
@@ -1637,16 +1703,14 @@ function formatXml(xml) {
 			lastWasText = false;
 		} else if (part.startsWith("</")) {
 			indent = Math.max(0, indent - 1);
-			if (lastWasText) formatted += part + "\n";
-			else formatted += "  ".repeat(indent) + part + "\n";
+			formatted += renderClosingTag(part, indent, lastWasText);
 			lastWasText = false;
 		} else if (part.startsWith("<") && part.endsWith("/>")) {
 			formatted += "  ".repeat(indent) + part + "\n";
 			lastWasText = false;
 		} else if (part.startsWith("<")) {
-			formatted += "  ".repeat(indent) + part;
+			formatted += renderOpeningTag(part, nextPart, indent);
 			if (!part.includes("</")) indent++;
-			if (nextPart && !nextPart.startsWith("<")) {} else formatted += "\n";
 			lastWasText = false;
 		} else {
 			const trimmed = part.trim();
@@ -1656,7 +1720,16 @@ function formatXml(xml) {
 			}
 		}
 	}
-	return formatted.trim();
+	return formatted;
+}
+/** Render a closing tag, kept inline when text content precedes it. */
+function renderClosingTag(part, indent, lastWasText) {
+	return (lastWasText ? "" : "  ".repeat(indent)) + part + "\n";
+}
+/** Render an opening tag; no newline when text content follows. */
+function renderOpeningTag(part, nextPart, indent) {
+	const text = "  ".repeat(indent) + part;
+	return nextPart && !nextPart.startsWith("<") ? text : text + "\n";
 }
 
 // src/xml/build.ts
@@ -1666,6 +1739,8 @@ function formatXml(xml) {
 * Build XML string from typed JavaScript object using W3C-compliant Schema definition.
 * Uses the walker module for schema traversal.
 */
+/** Explicit `String()` coercion for untyped values. */
+const asText = String;
 /**
 * Collect all namespace prefixes from a schema and its $imports chain
 */
@@ -1696,41 +1771,8 @@ function build(schema, data, options = {}) {
 	const { xmlDecl = true, encoding = "utf-8", pretty = false } = options;
 	const prefix = options.prefix ?? getSchemaPrefix(schema);
 	const doc = createXmlDocument(schema);
-	let elementDecl;
-	let elementSchema = schema;
-	let elementData = data;
-	if (options.rootElement) {
-		const found = findElement(options.rootElement, schema);
-		if (!found) throw new Error(`Element '${options.rootElement}' not found in schema`);
-		elementDecl = found.element;
-		elementSchema = found.schema;
-		if (elementData[options.rootElement] !== void 0) elementData = elementData[options.rootElement];
-	} else {
-		const dataKeys = Object.keys(elementData);
-		if (dataKeys.length === 1) {
-			const potentialElementName = dataKeys[0];
-			const found = findElement(potentialElementName, schema);
-			if (found) {
-				elementDecl = found.element;
-				elementSchema = found.schema;
-				elementData = elementData[potentialElementName];
-			}
-		}
-		if (!elementDecl) {
-			elementDecl = findMatchingElement(elementData, schema);
-			if (!elementDecl) throw new Error("Schema has no element declarations");
-		}
-	}
-	let rootType;
-	let rootSchema = elementSchema;
-	if (elementDecl.complexType) rootType = elementDecl.complexType;
-	else if (elementDecl.type) {
-		const typeName = stripNsPrefix(elementDecl.type);
-		const rootTypeEntry = findComplexType(typeName, elementSchema);
-		if (!rootTypeEntry) throw new Error(`Schema missing complexType for: ${typeName}`);
-		rootType = rootTypeEntry.ct;
-		rootSchema = rootTypeEntry.schema;
-	} else throw new Error(`Element ${elementDecl.name} has no type or inline complexType`);
+	const { elementDecl, elementSchema, elementData } = resolveRootElement(schema, data, options.rootElement);
+	const { rootType, rootSchema } = resolveRootType(elementDecl, elementSchema);
 	const elementName = elementDecl.name ?? elementDecl.ref;
 	if (!elementName) throw new Error("Element declaration has no name or ref");
 	const root = createRootElement(doc, elementName, schema, prefix);
@@ -1744,6 +1786,63 @@ function build(schema, data, options = {}) {
 	return xml;
 }
 /**
+* Find the element declaration for the root - either by name or by matching data.
+*/
+function resolveRootElement(schema, data, rootElement) {
+	if (rootElement) return resolveNamedRootElement(schema, data, rootElement);
+	return resolveInferredRootElement(schema, data);
+}
+/** Resolve the root element by its explicit name. */
+function resolveNamedRootElement(schema, data, rootElement) {
+	const found = findElement(rootElement, schema);
+	if (!found) throw new Error(`Element '${rootElement}' not found in schema`);
+	const elementData = data[rootElement] !== void 0 ? data[rootElement] : data;
+	return {
+		elementDecl: found.element,
+		elementSchema: found.schema,
+		elementData
+	};
+}
+/** Infer the root element from the wrapped data key or the data structure. */
+function resolveInferredRootElement(schema, data) {
+	const dataKeys = Object.keys(data);
+	if (dataKeys.length === 1) {
+		const potentialElementName = dataKeys[0];
+		const found = findElement(potentialElementName, schema);
+		if (found) return {
+			elementDecl: found.element,
+			elementSchema: found.schema,
+			elementData: data[potentialElementName]
+		};
+	}
+	const elementDecl = findMatchingElement(data, schema);
+	if (!elementDecl) throw new Error("Schema has no element declarations");
+	return {
+		elementDecl,
+		elementSchema: schema,
+		elementData: data
+	};
+}
+/**
+* Get the complexType of the root element - either inline or by reference.
+*/
+function resolveRootType(elementDecl, elementSchema) {
+	if (elementDecl.complexType) return {
+		rootType: elementDecl.complexType,
+		rootSchema: elementSchema
+	};
+	if (elementDecl.type) {
+		const typeName = stripNsPrefix(elementDecl.type);
+		const rootTypeEntry = findComplexType(typeName, elementSchema);
+		if (!rootTypeEntry) throw new Error(`Schema missing complexType for: ${typeName}`);
+		return {
+			rootType: rootTypeEntry.ct,
+			rootSchema: rootTypeEntry.schema
+		};
+	}
+	throw new Error(`Element ${elementDecl.name} has no type or inline complexType`);
+}
+/**
 * Find the element declaration that best matches the data structure.
 * Searches in the main schema first, then in $imports.
 */
@@ -1751,50 +1850,62 @@ function findMatchingElement(data, schema) {
 	const dataKeys = new Set(Object.keys(data));
 	let bestMatch;
 	let bestScore = -1;
-	const scoreElement = (element, searchSchema) => {
-		let ct;
-		let ctSchema = searchSchema;
-		if (element.complexType) ct = element.complexType;
-		else if (element.type) {
-			const typeName = stripNsPrefix(element.type);
-			const typeEntry = findComplexType(typeName, searchSchema);
-			if (typeEntry) {
-				ct = typeEntry.ct;
-				ctSchema = typeEntry.schema;
-			}
-		}
-		if (!ct) return 0;
-		const typeFields = /* @__PURE__ */ new Set();
-		for (const { element: el } of walkElements(ct, ctSchema)) if (el.name) typeFields.add(el.name);
-		for (const { attribute } of walkAttributes(ct, ctSchema)) if (attribute.name) typeFields.add(attribute.name);
-		let score = 0;
-		dataKeys.forEach((key) => {
-			if (typeFields.has(key)) score++;
-		});
-		return score;
-	};
-	const elements = schema.element;
-	if (elements && elements.length > 0) for (const element of elements) {
-		const score = scoreElement(element, schema);
+	for (const { element, schema: candidateSchema } of collectCandidateElements(schema)) {
+		const score = scoreElement(element, candidateSchema, dataKeys);
 		if (score > bestScore) {
 			bestScore = score;
 			bestMatch = element;
 		}
 	}
+	const elements = schema.element;
+	if (!bestMatch && elements && elements.length > 0) return elements[0];
+	return bestMatch;
+}
+/**
+* Collect candidate element declarations: main schema first, then $imports.
+*/
+function collectCandidateElements(schema) {
+	const candidates = [];
+	const elements = schema.element;
+	if (elements && elements.length > 0) for (const element of elements) candidates.push({
+		element,
+		schema
+	});
 	const imports = schema.$imports;
 	if (imports) for (const importedSchema of imports) {
 		const importedElements = importedSchema.element;
 		if (!importedElements) continue;
-		for (const element of importedElements) {
-			const score = scoreElement(element, importedSchema);
-			if (score > bestScore) {
-				bestScore = score;
-				bestMatch = element;
-			}
+		for (const element of importedElements) candidates.push({
+			element,
+			schema: importedSchema
+		});
+	}
+	return candidates;
+}
+/**
+* Score an element against the data keys: how many keys its type covers.
+*/
+function scoreElement(element, searchSchema, dataKeys) {
+	let ct;
+	let ctSchema = searchSchema;
+	if (element.complexType) ct = element.complexType;
+	else if (element.type) {
+		const typeName = stripNsPrefix(element.type);
+		const typeEntry = findComplexType(typeName, searchSchema);
+		if (typeEntry) {
+			ct = typeEntry.ct;
+			ctSchema = typeEntry.schema;
 		}
 	}
-	if (!bestMatch && elements && elements.length > 0) return elements[0];
-	return bestMatch;
+	if (!ct) return 0;
+	const typeFields = /* @__PURE__ */ new Set();
+	for (const { element: el } of walkElements(ct, ctSchema)) if (el.name) typeFields.add(el.name);
+	for (const { attribute } of walkAttributes(ct, ctSchema)) if (attribute.name) typeFields.add(attribute.name);
+	let score = 0;
+	dataKeys.forEach((key) => {
+		if (typeFields.has(key)) score++;
+	});
+	return score;
 }
 /**
 * Build element content using its complexType definition
@@ -1805,7 +1916,11 @@ function buildElement(doc, node, data, typeDef, schema, rootSchema, prefix) {
 	const wildcard = hasWildcard(typeDef, schema);
 	const consumed = /* @__PURE__ */ new Set();
 	buildAttributes(node, data, typeDef, schema, rootSchema, consumed);
-	buildDeclaredElements(doc, node, data, typeDef, schema, rootSchema, prefix, consumed);
+	buildDeclaredElements({
+		doc,
+		rootSchema,
+		prefix
+	}, node, data, typeDef, schema, consumed);
 	if (wildcard) for (const key of Object.keys(data)) {
 		if (consumed.has(key)) continue;
 		buildAnyField(doc, node, key, data[key]);
@@ -1836,12 +1951,12 @@ function buildAttributes(node, data, typeDef, schema, rootSchema, consumed) {
 * Build declared child elements via the walker (handles inheritance,
 * groups, refs, substitution). Adds each declared key to `consumed`.
 */
-function buildDeclaredElements(doc, node, data, typeDef, schema, rootSchema, prefix, consumed) {
+function buildDeclaredElements(env, node, data, typeDef, schema, consumed) {
+	const { doc, rootSchema, prefix } = env;
 	for (const { element, schema: elementDefSchema } of walkElements(typeDef, schema)) {
 		if (element.ref) {
 			const refName = stripNsPrefix(element.ref);
-			const refElement = findElement(refName, elementDefSchema);
-			if (refElement && refElement.element.abstract) {
+			if (findElement(refName, elementDefSchema)?.element.abstract) {
 				buildSubstituteElements(doc, node, data, refName, rootSchema, prefix, consumed);
 				continue;
 			}
@@ -1850,7 +1965,14 @@ function buildDeclaredElements(doc, node, data, typeDef, schema, rootSchema, pre
 		if (!resolved) continue;
 		consumed.add(resolved.dataKey);
 		const value = data[resolved.dataKey];
-		if (value != null) buildFieldWithTagName(doc, node, value, resolved.tagName, resolved.typeName, resolved.inlineComplexType, resolved.elementSchema, rootSchema, prefix, resolved.form);
+		if (value != null) buildFieldWithTagName(env, node, {
+			value,
+			tagName: resolved.tagName,
+			typeName: resolved.typeName,
+			inlineComplexType: resolved.inlineComplexType,
+			elementSchema: resolved.elementSchema,
+			elementForm: resolved.form
+		});
 	}
 }
 /**
@@ -1865,7 +1987,14 @@ function buildSubstituteElements(doc, node, data, refName, rootSchema, prefix, c
 		if (!subName) continue;
 		consumed.add(subName);
 		const value = data[subName];
-		if (value != null) buildField(doc, node, value, subName, substitute.element.type ? stripNsPrefix(substitute.element.type) : void 0, substitute.schema, rootSchema, prefix);
+		if (value != null) {
+			const typeName = substitute.element.type ? stripNsPrefix(substitute.element.type) : void 0;
+			buildField({
+				doc,
+				rootSchema,
+				prefix
+			}, node, value, subName, typeName, substitute.schema);
+		}
 	}
 }
 /**
@@ -1880,13 +2009,17 @@ function buildAnyField(doc, parent, tagName, value) {
 		return;
 	}
 	const el = doc.createElement(tagName);
-	if (typeof value === "object") for (const [key, nested] of Object.entries(value)) if (key.startsWith("@")) {
-		if (nested !== void 0 && nested !== null) el.setAttribute(key.slice(1), String(nested));
-	} else if (key === "_text") el.textContent = String(nested ?? "");
-	else buildAnyField(doc, el, key, nested);
-	else el.textContent = String(value);
+	if (typeof value === "object") buildAnyEntries(doc, el, value);
+	else el.textContent = asText(value);
 	parent.appendChild(el);
 }
+/** Build the nested entries of a wildcard object element. */
+function buildAnyEntries(doc, el, value) {
+	for (const [key, nested] of Object.entries(value)) if (key.startsWith("@")) {
+		if (nested !== void 0 && nested !== null) el.setAttribute(key.slice(1), asText(nested));
+	} else if (key === "_text") el.textContent = asText(nested ?? "");
+	else buildAnyField(doc, el, key, nested);
+}
 /**
 * Resolve element info (name and type), handling ref
 *
@@ -1935,11 +2068,19 @@ function resolveElementInfo(element, schema) {
 * - "qualified": local elements get namespace prefix
 * - "unqualified" (default): local elements do NOT get namespace prefix
 */
-function buildField(doc, parent, value, elementName, typeName, schema, rootSchema, prefix) {
+function buildField(env, parent, value, elementName, typeName, schema) {
+	const { rootSchema, prefix } = env;
 	const nestedType = typeName ? findComplexType(typeName, schema) : void 0;
 	const usePrefix = rootSchema.elementFormDefault === "qualified" ? prefix : void 0;
-	const tagName = usePrefix ? `${usePrefix}:${elementName}` : elementName;
-	if (Array.isArray(value)) for (const item of value) {
+	emitFieldChildren(env, parent, value, usePrefix ? `${usePrefix}:${elementName}` : elementName, typeName, nestedType);
+}
+/**
+* Emit the child element(s) of a field value: arrays become repeated siblings.
+*/
+function emitFieldChildren(env, parent, value, tagName, typeName, nestedType) {
+	const { doc, rootSchema, prefix } = env;
+	const items = Array.isArray(value) ? value : [value];
+	for (const item of items) {
 		const child = doc.createElement(tagName);
 		if (nestedType) buildElement(doc, child, item, nestedType.ct, nestedType.schema, rootSchema, prefix);
 		else {
@@ -1948,15 +2089,6 @@ function buildField(doc, parent, value, elementName, typeName, schema, rootSchem
 		}
 		parent.appendChild(child);
 	}
-	else {
-		const child = doc.createElement(tagName);
-		if (nestedType) buildElement(doc, child, value, nestedType.ct, nestedType.schema, rootSchema, prefix);
-		else {
-			const text = formatValue(value, typeName || "string");
-			if (text) child.appendChild(doc.createTextNode(text));
-		}
-		parent.appendChild(child);
-	}
 }
 /**
 * Build a field with an explicit tag name (used for element refs with prefix)
@@ -1966,39 +2098,34 @@ function buildField(doc, parent, value, elementName, typeName, schema, rootSchem
 * 2. Elements with form="unqualified" - never use prefix
 * 3. Direct elements - apply elementFormDefault logic
 */
-function buildFieldWithTagName(doc, parent, value, tagName, typeName, inlineComplexType, elementSchema, rootSchema, prefix, elementForm) {
+function buildFieldWithTagName(env, parent, spec) {
+	const { rootSchema, prefix } = env;
+	const { value, tagName, typeName, inlineComplexType, elementSchema, elementForm } = spec;
 	let nestedType;
 	if (inlineComplexType) nestedType = {
 		ct: inlineComplexType,
 		schema: elementSchema
 	};
 	else if (typeName) nestedType = findComplexType(typeName, elementSchema);
-	let actualTagName = tagName;
-	if (!tagName.includes(":")) {
-		let usePrefix;
-		if (elementForm === "unqualified") usePrefix = void 0;
-		else if (elementForm === "qualified") usePrefix = getPrefixForSchema(elementSchema, rootSchema) ?? prefix;
-		else usePrefix = (elementSchema.elementFormDefault ?? rootSchema.elementFormDefault) === "qualified" ? getPrefixForSchema(elementSchema, rootSchema) ?? prefix : void 0;
-		actualTagName = usePrefix ? `${usePrefix}:${tagName}` : tagName;
-	}
-	if (Array.isArray(value)) for (const item of value) {
-		const child = doc.createElement(actualTagName);
-		if (nestedType) buildElement(doc, child, item, nestedType.ct, nestedType.schema, rootSchema, prefix);
-		else {
-			const text = formatValue(item, typeName || "string");
-			if (text) child.appendChild(doc.createTextNode(text));
-		}
-		parent.appendChild(child);
-	}
-	else {
-		const child = doc.createElement(actualTagName);
-		if (nestedType) buildElement(doc, child, value, nestedType.ct, nestedType.schema, rootSchema, prefix);
-		else {
-			const text = formatValue(value, typeName || "string");
-			if (text) child.appendChild(doc.createTextNode(text));
-		}
-		parent.appendChild(child);
-	}
+	emitFieldChildren(env, parent, value, resolveTagName(tagName, elementSchema, rootSchema, prefix, elementForm), typeName, nestedType);
+}
+/**
+* Determine the actual tag name to use.
+* Priority: 1. Per-element form attribute, 2. Schema elementFormDefault
+* If tagName already has a prefix (e.g., "asx:abap"), use it directly
+*/
+function resolveTagName(tagName, elementSchema, rootSchema, prefix, elementForm) {
+	if (tagName.includes(":")) return tagName;
+	const usePrefix = resolveElementPrefix(elementSchema, rootSchema, prefix, elementForm);
+	return usePrefix ? `${usePrefix}:${tagName}` : tagName;
+}
+/**
+* Determine the namespace prefix for a local tag name.
+*/
+function resolveElementPrefix(elementSchema, rootSchema, prefix, elementForm) {
+	if (elementForm === "unqualified") return;
+	if (elementForm === "qualified") return getPrefixForSchema(elementSchema, rootSchema) ?? prefix;
+	return (elementSchema.elementFormDefault ?? rootSchema.elementFormDefault) === "qualified" ? getPrefixForSchema(elementSchema, rootSchema) ?? prefix : void 0;
 }
 /**
 * Find all elements that substitute for a given abstract element name.