uss-xsd-engine 0.2.0 → 0.2.1

package/dist/uss-xsd-engine.esm.js

@@ -1,5 +1,5 @@
 /*!
- * uss-xsd-engine v0.2.0
+ * uss-xsd-engine v0.2.1
  * (c) 2026 Bernard Mumble
  * MIT License
  */
@@ -69,6 +69,8 @@ var ISSUE_CODES = {
   XML_KEY_NULL_VIOLATION: "XML_KEY_NULL_VIOLATION",
   XML_KEYREF_VIOLATION: "XML_KEYREF_VIOLATION",
   XML_UNIQUE_VIOLATION: "XML_UNIQUE_VIOLATION",
+  XML_ANY_STRICT_VALIDATION_FAILED: "XML_ANY_STRICT_VALIDATION_FAILED",
+  XML_ANYATTRIBUTE_STRICT_VALIDATION_FAILED: "XML_ANYATTRIBUTE_STRICT_VALIDATION_FAILED",
   XML_PATTERN_MISMATCH: "XML_PATTERN_MISMATCH",
   XML_LENGTH_MISMATCH: "XML_LENGTH_MISMATCH",
   XML_MIN_LENGTH_VIOLATION: "XML_MIN_LENGTH_VIOLATION",
@@ -95,6 +97,9 @@ var ISSUE_CODES = {
   XSD_RESTRICTION_NOT_SUBSET: "XSD_RESTRICTION_NOT_SUBSET",
   XSD_RESTRICTION_OCCURS_WIDENED: "XSD_RESTRICTION_OCCURS_WIDENED",
   XSD_RESTRICTION_ATTRIBUTE_WIDENED: "XSD_RESTRICTION_ATTRIBUTE_WIDENED",
+  XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE: "XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE",
+  XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE: "XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE",
+  XSD_RESTRICTION_WILDCARD_INCOMPATIBLE: "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
   XSD_INCLUDE_NOT_PROVIDED: "XSD_INCLUDE_NOT_PROVIDED",
   XSD_IMPORT_NOT_PROVIDED: "XSD_IMPORT_NOT_PROVIDED",
   XSD_INCLUDE_NAMESPACE_MISMATCH: "XSD_INCLUDE_NAMESPACE_MISMATCH",
@@ -480,9 +485,11 @@ function createGroupRefNode({
 }
 function createAnyNode({
   namespace = null,
-  processContents = null,
+  processContents = "strict",
   minOccurs = 1,
   maxOccurs = 1,
+  notNamespace = [],
+  notQName = [],
   line = null,
   column = null,
   path = null
@@ -490,9 +497,31 @@ function createAnyNode({
   return {
     kind: "any",
     namespace,
-    processContents,
+    processContents: processContents || "strict",
     minOccurs,
     maxOccurs,
+    notNamespace,
+    notQName,
+    line,
+    column,
+    path
+  };
+}
+function createAnyAttributeNode({
+  namespace = null,
+  processContents = "strict",
+  notNamespace = [],
+  notQName = [],
+  line = null,
+  column = null,
+  path = null
+} = {}) {
+  return {
+    kind: "anyAttribute",
+    namespace,
+    processContents: processContents || "strict",
+    notNamespace,
+    notQName,
     line,
     column,
     path
@@ -817,8 +846,6 @@ function getEffectiveContent(schema, complexTypeDecl) {
 
 // src/parser/buildSchemaModel.js
 var UNSUPPORTED_NODE_FEATURES = /* @__PURE__ */ new Set([
-  "any",
-  "anyAttribute",
   "redefine",
   "notation"
 ]);
@@ -1253,6 +1280,10 @@ function parseAttributesContainer(nodes, xsdText, lineStarts, parentPath, schema
           issues
         )
       );
+    } else if (child.localName === "anyAttribute") {
+      attributes.push(
+        parseAnyAttribute(child, xsdText, lineStarts, parentPath, schema, issues)
+      );
     }
   }
   return attributes;
@@ -1336,15 +1367,58 @@ function parseGroupRef(node, xsdText, lineStarts, parentPath, schema, issues) {
     path
   });
 }
+function parseWildcardNamespace(namespaceStr) {
+  if (!namespaceStr) return null;
+  const trimmed = namespaceStr.trim();
+  if (!trimmed) return null;
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((ns) => ns);
+  }
+  return trimmed;
+}
+function parseNotNamespace(notNamespaceStr) {
+  if (!notNamespaceStr) return [];
+  const trimmed = notNamespaceStr.trim();
+  if (!trimmed) return [];
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((ns) => ns);
+  }
+  return [trimmed];
+}
+function parseNotQName(notQNameStr) {
+  if (!notQNameStr) return [];
+  const trimmed = notQNameStr.trim();
+  if (!trimmed) return [];
+  if (trimmed.includes(" ")) {
+    return trimmed.split(/\s+/).filter((qn) => qn);
+  }
+  return [trimmed];
+}
 function parseAny(node, xsdText, lineStarts, parentPath, schema, issues) {
   const path = buildPath(parentPath, node);
   const loc = locateNodeInSource(xsdText, lineStarts, node);
   collectNodeDiagnostics(schema, issues, node, path, loc);
   return createAnyNode({
-    namespace: node.getAttribute("namespace"),
+    namespace: parseWildcardNamespace(node.getAttribute("namespace")),
     processContents: node.getAttribute("processContents"),
     minOccurs: normalizeOccurs(node.getAttribute("minOccurs"), 1),
     maxOccurs: normalizeOccurs(node.getAttribute("maxOccurs"), 1),
+    notNamespace: parseNotNamespace(node.getAttribute("notNamespace")),
+    notQName: parseNotQName(node.getAttribute("notQName")),
+    line: loc.line,
+    column: loc.column,
+    path
+  });
+}
+function parseAnyAttribute(node, xsdText, lineStarts, parentPath, schema, issues) {
+  const path = buildPath(parentPath, node);
+  const loc = locateNodeInSource(xsdText, lineStarts, node);
+  collectNodeDiagnostics(schema, issues, node, path, loc);
+  return createAnyAttributeNode({
+    namespace: parseWildcardNamespace(node.getAttribute("namespace")),
+    processContents: node.getAttribute("processContents"),
+    notNamespace: parseNotNamespace(node.getAttribute("notNamespace")),
+    notQName: parseNotQName(node.getAttribute("notQName")),
     line: loc.line,
     column: loc.column,
     path
@@ -1767,24 +1841,24 @@ function resolveExternalDocument(ref, externalDocuments) {
     }
   }
   if (ref?.kind === "import" && ref.namespace) {
-    const namespaceMatches = entries.filter((entry) => {
+    const namespaceMatches2 = entries.filter((entry) => {
       const declaredTargetNamespace = getDeclaredTargetNamespaceFromText(
         entry.text
       );
       return (declaredTargetNamespace || null) === (ref.namespace || null);
     });
-    if (namespaceMatches.length === 1) {
+    if (namespaceMatches2.length === 1) {
       return {
         kind: "namespace",
-        entry: namespaceMatches[0],
-        matches: namespaceMatches
+        entry: namespaceMatches2[0],
+        matches: namespaceMatches2
       };
     }
-    if (namespaceMatches.length > 1) {
+    if (namespaceMatches2.length > 1) {
       return {
         kind: "ambiguous-namespace",
         entry: null,
-        matches: namespaceMatches
+        matches: namespaceMatches2
       };
     }
   }
@@ -2401,6 +2475,115 @@ function checkRestrictedAttributes(schema, derivedType, baseType, issues) {
     }
   }
 }
+function checkWildcardRestriction(schema, derivedType, baseType, issues) {
+  const derivedContent = getEffectiveContent(schema, derivedType);
+  const baseContent = getEffectiveContent(schema, baseType);
+  const derivedWildcards = [];
+  const baseWildcards = [];
+  function collectWildcards(node, arr) {
+    if (!node) return;
+    if (node.kind === "any") {
+      arr.push(node);
+      return;
+    }
+    if (node.children) {
+      for (const child of asArray(node.children)) {
+        collectWildcards(child, arr);
+      }
+    }
+  }
+  collectWildcards(derivedContent, derivedWildcards);
+  collectWildcards(baseContent, baseWildcards);
+  if (derivedWildcards.length > 0 && baseWildcards.length === 0) {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
+        `Restricted type introduces wildcard elements that base type does not have.`,
+        derivedType
+      )
+    );
+  }
+  const derivedAttrs = asArray(getEffectiveAttributes(schema, derivedType));
+  const baseAttrs = asArray(getEffectiveAttributes(schema, baseType));
+  const derivedHasAnyAttribute = derivedAttrs.some((a) => a?.kind === "anyAttribute");
+  const baseHasAnyAttribute = baseAttrs.some((a) => a?.kind === "anyAttribute");
+  if (derivedHasAnyAttribute && !baseHasAnyAttribute) {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_WILDCARD_INCOMPATIBLE",
+        `Restricted type introduces anyAttribute that base type does not have.`,
+        derivedType
+      )
+    );
+  }
+}
+function checkOccurrenceCompatibility(derived, base, name) {
+  const dMin = typeof derived.minOccurs === "number" ? derived.minOccurs : 1;
+  const bMin = typeof base.minOccurs === "number" ? base.minOccurs : 1;
+  const dMax = maxToNumber(derived.maxOccurs ?? 1);
+  const bMax = maxToNumber(base.maxOccurs ?? 1);
+  return dMin >= bMin && dMax <= bMax;
+}
+function checkComplexContentRestriction(schema, derivedType, baseType, issues) {
+  const derivedContent = getEffectiveContent(schema, derivedType);
+  const baseContent = getEffectiveContent(schema, baseType);
+  if (!derivedContent || !baseContent) return;
+  const derivedFlat = flattenContent(derivedContent, []);
+  const baseFlat = flattenContent(baseContent, []);
+  const baseMap = new Map(baseFlat.map((item) => [item.name, item]));
+  for (const item of derivedFlat) {
+    const baseItem = baseMap.get(item.name);
+    if (!baseItem) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_NOT_SUBSET",
+          `Restricted type contains element '${item.name}' not in base type.`,
+          item
+        )
+      );
+      continue;
+    }
+    if (!checkOccurrenceCompatibility(item, baseItem, item.name)) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_OCCURRENCE_INCOMPATIBLE",
+          `Restricted type has incompatible occurrence constraints for '${item.name}'.`,
+          item
+        )
+      );
+    }
+  }
+}
+function checkSimpleContentRestriction(schema, derivedType, baseType, issues) {
+  if (baseType.contentModel !== "simple") {
+    issues.push(
+      buildRestrictionIssue(
+        "XSD_RESTRICTION_NOT_SUBSET",
+        `SimpleContent restriction requires base type to have simple content.`,
+        derivedType
+      )
+    );
+  }
+  const derivedAttrs = asArray(getEffectiveAttributes(schema, derivedType));
+  const baseAttrs = asArray(getEffectiveAttributes(schema, baseType));
+  const baseAttrMap = new Map(
+    baseAttrs.filter((attr) => attr?.kind === "attribute").map((attr) => [localDeclName(attr), attr])
+  );
+  for (const attr of derivedAttrs) {
+    if (attr?.kind !== "attribute") continue;
+    const name = localDeclName(attr);
+    const baseAttr = baseAttrMap.get(name);
+    if (!baseAttr && !baseAttrs.some((a) => a?.kind === "anyAttribute")) {
+      issues.push(
+        buildRestrictionIssue(
+          "XSD_RESTRICTION_ATTRIBUTE_INCOMPATIBLE",
+          `SimpleContent restricted type adds attribute '${name}' not in base type.`,
+          attr
+        )
+      );
+    }
+  }
+}
 function runRestrictionDiagnostics(schema) {
   const issues = [];
   for (const complexType of Object.values(schema.globals.complexTypes || {})) {
@@ -2410,6 +2593,12 @@ function runRestrictionDiagnostics(schema) {
     if (!baseType) continue;
     checkRestrictedContentSubset(schema, complexType, baseType, issues);
     checkRestrictedAttributes(schema, complexType, baseType, issues);
+    checkWildcardRestriction(schema, complexType, baseType, issues);
+    if (complexType.contentModel === "complex" && baseType.contentModel === "complex") {
+      checkComplexContentRestriction(schema, complexType, baseType, issues);
+    } else if (complexType.contentModel === "simple" && baseType.contentModel === "simple") {
+      checkSimpleContentRestriction(schema, complexType, baseType, issues);
+    }
   }
   return issues;
 }
@@ -2736,6 +2925,130 @@ function runImportDiagnostics(schema, options = {}) {
   return issues;
 }
 
+// src/diagnostics/schemaWildcardDiagnostics.js
+function validateWildcardNamespace(namespace, path) {
+  if (!namespace) return null;
+  const trimmed = namespace.trim();
+  if (!trimmed) return null;
+  const parts = trimmed.split(/\s+/);
+  for (const part of parts) {
+    if (part === "##any" || part === "##other" || part === "##targetNamespace") {
+      continue;
+    }
+    if (!part.includes(":") && part !== "") {
+      return createIssue({
+        code: "INVALID_WILDCARD_NAMESPACE",
+        severity: "warning",
+        message: `Invalid namespace in wildcard constraint: '${part}'. Expected ##any, ##other, ##targetNamespace, or a valid namespace URI.`,
+        path
+      });
+    }
+  }
+  return null;
+}
+function validateProcessContents(processContents, path) {
+  if (!processContents) return null;
+  const trimmed = processContents.trim();
+  if (trimmed === "strict" || trimmed === "lax" || trimmed === "skip") {
+    return null;
+  }
+  return createIssue({
+    code: "INVALID_PROCESS_CONTENTS",
+    severity: "error",
+    message: `Invalid processContents value: '${processContents}'. Must be 'strict', 'lax', or 'skip'.`,
+    path
+  });
+}
+function validateSingleWildcard(wildcardNode, nodeName) {
+  const issues = [];
+  const nsIssue = validateWildcardNamespace(wildcardNode.namespace, wildcardNode.path);
+  if (nsIssue) {
+    issues.push(nsIssue);
+  }
+  const pcIssue = validateProcessContents(wildcardNode.processContents, wildcardNode.path);
+  if (pcIssue) {
+    issues.push(pcIssue);
+  }
+  if (wildcardNode.notNamespace && wildcardNode.notNamespace.length > 0) {
+    if (wildcardNode.namespace !== "##other" && wildcardNode.namespace !== "##targetNamespace") {
+      issues.push(
+        createIssue({
+          code: "INVALID_NOT_NAMESPACE_USAGE",
+          severity: "warning",
+          message: `notNamespace is only meaningful with ##other or ##targetNamespace namespace constraint.`,
+          path: wildcardNode.path
+        })
+      );
+    }
+  }
+  if (wildcardNode.notQName && wildcardNode.notQName.length > 0) {
+    for (const qname of wildcardNode.notQName) {
+      if (!qname || qname.trim() === "") {
+        issues.push(
+          createIssue({
+            code: "INVALID_NOT_QNAME",
+            severity: "warning",
+            message: `Empty QName in notQName constraint.`,
+            path: wildcardNode.path
+          })
+        );
+        break;
+      }
+    }
+  }
+  return issues;
+}
+function findWildcardsInContent(node, wildcards) {
+  if (!node) return;
+  if (node.kind === "any" || node.kind === "anyAttribute") {
+    wildcards.push(node);
+    return;
+  }
+  if (node.children && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      findWildcardsInContent(child, wildcards);
+    }
+  }
+}
+function findWildcardsInAttributes(attributes, wildcards) {
+  if (!attributes || !Array.isArray(attributes)) return;
+  for (const attr of attributes) {
+    if (attr.kind === "anyAttribute") {
+      wildcards.push(attr);
+    }
+  }
+}
+function runWildcardDiagnostics(schema) {
+  const issues = [];
+  const wildcards = [];
+  for (const elem of Object.values(schema.globals.elements || {})) {
+    if (elem.inlineType?.content) {
+      findWildcardsInContent(elem.inlineType.content, wildcards);
+    }
+    if (elem.inlineType?.attributes) {
+      findWildcardsInAttributes(elem.inlineType.attributes, wildcards);
+    }
+  }
+  for (const complexType of Object.values(schema.globals.complexTypes || {})) {
+    if (complexType.content) {
+      findWildcardsInContent(complexType.content, wildcards);
+    }
+    if (complexType.attributes) {
+      findWildcardsInAttributes(complexType.attributes, wildcards);
+    }
+  }
+  for (const group of Object.values(schema.globals.groups || {})) {
+    if (group.content) {
+      findWildcardsInContent(group.content, wildcards);
+    }
+  }
+  for (const wildcard of wildcards) {
+    const wildcardIssues = validateSingleWildcard(wildcard, wildcard.kind);
+    issues.push(...wildcardIssues);
+  }
+  return issues;
+}
+
 // src/diagnostics/schemaDiagnostics.js
 function buildStats(schema) {
   return {
@@ -2910,6 +3223,8 @@ function runSchemaDiagnostics(schema, options = {}) {
   const identityIssues = runIdentityConstraintDiagnostics(schema);
   issues.push(...identityIssues);
   emitUnsupportedFeatureWarnings(schema, issues, options);
+  const wildcardIssues = runWildcardDiagnostics(schema);
+  issues.push(...wildcardIssues);
   const facetIssues = runFacetDiagnostics(schema, options);
   issues.push(...facetIssues);
   const restrictionIssues = runRestrictionDiagnostics(schema);
@@ -2930,7 +3245,7 @@ function runSchemaDiagnostics(schema, options = {}) {
 }
 
 // src/version.js
-var ENGINE_VERSION = "v0.2.0";
+var ENGINE_VERSION = "v0.2.1";
 
 // src/utils/result.js
 function summarizeIssues(issues = []) {
@@ -3818,6 +4133,24 @@ function buildNodesFromContent(schema, contentNode, options, state) {
 function buildComplexTypeContent(schema, complexTypeDecl, options, state) {
   const content = getEffectiveContent(schema, complexTypeDecl);
   const attributes = getEffectiveAttributes(schema, complexTypeDecl);
+  if (state.currentDepth >= options.maxDepth) {
+    return {
+      attributes: buildAttributesObject(schema, attributes, options, state),
+      children: []
+    };
+  }
+  const typeKey = complexTypeDecl.name || complexTypeDecl.qName;
+  if (typeKey && state.visitedTypes.has(typeKey)) {
+    return {
+      attributes: buildAttributesObject(schema, attributes, options, state),
+      children: []
+    };
+  }
+  if (typeKey) {
+    state.visitedTypes.add(typeKey);
+  }
+  const previousDepth = state.currentDepth;
+  state.currentDepth += 1;
   let children = content ? buildNodesFromContent(schema, content, options, state) : [];
   if (options.mode === "minimal" && children.length === 0 && content) {
     children = buildRepresentativeNodesFromContent(
@@ -3827,6 +4160,10 @@ function buildComplexTypeContent(schema, complexTypeDecl, options, state) {
       state
     );
   }
+  state.currentDepth = previousDepth;
+  if (typeKey) {
+    state.visitedTypes.delete(typeKey);
+  }
   return {
     attributes: buildAttributesObject(schema, attributes, options, state),
     children
@@ -3905,7 +4242,10 @@ function selectRoot(schema, options = {}) {
 function generateXmlFromSchema(schema, options = {}, helpers = {}) {
   const normalizedOptions = {
     mode: options.mode === "full" ? "full" : "minimal",
-    includeOptionalAttributes: options.includeOptionalAttributes === true
+    includeOptionalAttributes: options.includeOptionalAttributes === true,
+    maxDepth: options.maxDepth ?? 3,
+    maxChoiceBranches: options.maxChoiceBranches ?? 1,
+    expandRepeatingElements: options.expandRepeatingElements ?? 2
   };
   const root = selectRoot(schema, options);
   if (!root) {
@@ -3918,7 +4258,9 @@ function generateXmlFromSchema(schema, options = {}, helpers = {}) {
   const state = {
     resolveAttributeGroup: helpers.resolveAttributeGroup,
     targetPrefix: options.targetPrefix || "tns",
-    nsContext
+    nsContext,
+    visitedTypes: /* @__PURE__ */ new Set(),
+    currentDepth: 0
   };
   const [rootNode] = buildElementInstances(
     schema,
@@ -4021,6 +4363,80 @@ function generateSampleXml({ xsdText, options = {} } = {}) {
   });
 }
 
+// src/validation/wildcardValidator.js
+function namespaceMatches(elementNamespace, wildcardNamespace, targetNamespace) {
+  if (!wildcardNamespace) return true;
+  if (wildcardNamespace === "##any") return true;
+  if (wildcardNamespace === "##targetNamespace") {
+    return elementNamespace === targetNamespace;
+  }
+  if (wildcardNamespace === "##other") {
+    return elementNamespace !== targetNamespace;
+  }
+  if (Array.isArray(wildcardNamespace)) {
+    return wildcardNamespace.includes(elementNamespace);
+  }
+  return elementNamespace === wildcardNamespace;
+}
+function isExcludedByNotNamespace(elementNamespace, notNamespace) {
+  if (!notNamespace || notNamespace.length === 0) return false;
+  return notNamespace.includes(elementNamespace);
+}
+function isExcludedByNotQName(qName, notQName) {
+  if (!notQName || notQName.length === 0) return false;
+  return notQName.includes(qName);
+}
+function buildQName(localName4, namespaceUri4) {
+  if (!namespaceUri4 || namespaceUri4 === "") {
+    return localName4;
+  }
+  return `{${namespaceUri4}}${localName4}`;
+}
+function elementMatchesWildcard(elementLocalName, elementNamespace, wildcardNode, targetNamespace) {
+  if (!wildcardNode || wildcardNode.kind !== "any") {
+    return false;
+  }
+  if (!namespaceMatches(elementNamespace, wildcardNode.namespace, targetNamespace)) {
+    return false;
+  }
+  if (isExcludedByNotNamespace(elementNamespace, wildcardNode.notNamespace)) {
+    return false;
+  }
+  const qName = buildQName(elementLocalName, elementNamespace);
+  if (isExcludedByNotQName(qName, wildcardNode.notQName)) {
+    return false;
+  }
+  return true;
+}
+function attributeMatchesWildcard(attrLocalName, attrNamespace, wildcardNode, targetNamespace) {
+  if (!wildcardNode || wildcardNode.kind !== "anyAttribute") {
+    return false;
+  }
+  if (!namespaceMatches(attrNamespace, wildcardNode.namespace, targetNamespace)) {
+    return false;
+  }
+  if (isExcludedByNotNamespace(attrNamespace, wildcardNode.notNamespace)) {
+    return false;
+  }
+  const qName = buildQName(attrLocalName, attrNamespace);
+  if (isExcludedByNotQName(qName, wildcardNode.notQName)) {
+    return false;
+  }
+  return true;
+}
+function normalizeProcessContents(processContents) {
+  if (processContents === "lax" || processContents === "skip") {
+    return processContents;
+  }
+  return "strict";
+}
+function isStrictWildcardValidation(processContents) {
+  return normalizeProcessContents(processContents) === "strict";
+}
+function shouldSkipWildcardValidation(processContents) {
+  return normalizeProcessContents(processContents) === "skip";
+}
+
 // src/validation/structureValidator.js
 function elementChildren2(xmlNode) {
   return Array.from(xmlNode?.children || []).filter((child) => child.nodeType === 1);
@@ -4090,6 +4506,7 @@ function isSimpleContentComplexType(complexTypeDecl) {
 function validateAttributes(xmlNode, attributes, context) {
   const { schema, createIssue: createIssue2, ISSUE_CODES: ISSUE_CODES2, issues, pathParts, validateAttributeValue: validateAttributeValue2 } = context;
   const allowed = /* @__PURE__ */ new Map();
+  let anyAttributeWildcard = null;
   for (const attr of attributes || []) {
     if (!attr) continue;
     if (attr.kind === "attribute") {
@@ -4101,6 +4518,8 @@ function validateAttributes(xmlNode, attributes, context) {
       const group = context.resolveAttributeGroup?.(attr.refName);
       if (!group) continue;
       validateAttributes(xmlNode, group.attributes || [], context);
+    } else if (attr.kind === "anyAttribute") {
+      anyAttributeWildcard = attr;
     }
   }
   for (const attrDecl of allowed.values()) {
@@ -4146,6 +4565,15 @@ function validateAttributes(xmlNode, attributes, context) {
       continue;
     }
     if (!allowed.has(attr.name)) {
+      if (anyAttributeWildcard) {
+        const attrLocalName = attr.localName || attr.name.split(":")[1] || attr.name;
+        const attrNamespace = attr.namespaceURI || null;
+        if (attributeMatchesWildcard(attrLocalName, attrNamespace, anyAttributeWildcard, schema.targetNamespace)) {
+          if (!shouldSkipWildcardValidation(anyAttributeWildcard.processContents)) {
+          }
+          continue;
+        }
+      }
       issues.push(
         createIssue2({
           code: ISSUE_CODES2.XML_UNEXPECTED_ATTRIBUTE,
@@ -4563,7 +4991,16 @@ function validateContentModel(children, modelNode, context, pathParts, startInde
       return validateAll(children, startIndex, modelNode, context, pathParts, silent);
     case "any":
       if (startIndex < children.length) {
-        return { nextIndex: startIndex + 1, matched: true, matchedAny: true };
+        const childNode = children[startIndex];
+        const childLocalName = localName(childNode);
+        const childNamespace = namespaceUri(childNode);
+        if (elementMatchesWildcard(childLocalName, childNamespace, modelNode, context.schema.targetNamespace)) {
+          if (isStrictWildcardValidation(modelNode.processContents)) {
+            validateElementDecl(childNode, { name: childLocalName, typeName: null }, context, [...pathParts, childLocalName]);
+          } else if (!shouldSkipWildcardValidation(modelNode.processContents)) {
+          }
+          return { nextIndex: startIndex + 1, matched: true, matchedAny: true };
+        }
       }
       return { nextIndex: startIndex, matched: true, matchedAny: false };
     default: