@amazon/vinyl-xml 1.2.0 → 2.0.0

package/dist/index.js

@@ -19,6 +19,22 @@ var __spreadValues = (a, b) => {
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/xlink/actuateValidator.ts
+import { isOneOf } from "@amazon/vinyl-validation";
+import { ErrorOrigin } from "@amazon/vinyl-util";
+var actuateValidator = /* @__PURE__ */ isOneOf("onLoad", "onRequest");
+function assertActuateEnum(str) {
+  actuateValidator.assert(str, ErrorOrigin.PARSING);
+  return str;
+}
+
+// src/xml/mappedXmlRules.ts
+import {
+  IllegalArgumentError,
+  invariant,
+  memoize
+} from "@amazon/vinyl-util";
+
 // src/xml/xmlRules.ts
 import {
   parseDate,
@@ -87,241 +103,193 @@ function attrDateTime(options) {
   return attr(parseDate, stringifyDate, options);
 }
 
-// src/xml/stringifyXml.ts
-import {
-  encodeEntities,
-  equalDeep,
-  getOrSet,
-  substitute
-} from "@amazon/vinyl-util";
-
-// src/xml/XmlSchemaError.ts
-import { ErrorOrigin, ReportableError } from "@amazon/vinyl-util";
-var xmlSchemaErrorLocale = {
-  atLeastElements: "Expected at least {expected} occurrences of {property} but was {actual}",
-  atMostElements: "Expected at most {expected} occurrences of {property} but was {actual}",
-  cyclicReferences: "Cyclic reference detected",
-  requiredAttribute: `Attribute '{property}' is required`
-};
-var XmlSchemaError = class _XmlSchemaError extends ReportableError {
-  get [Symbol.toStringTag]() {
-    return "XmlSchemaError";
-  }
-  constructor(message) {
-    super(message, ErrorOrigin.PARSING);
-    Object.setPrototypeOf(this, _XmlSchemaError.prototype);
-  }
-};
-
-// src/xml/stringifyXml.ts
-var locale = {
-  /**
-   * When a namespace binding is generated, if the prefix was not provided in the stringifier
-   * options, it will be generated from this template.
-   */
-  prefixTemplate: "ns_{value}"
-};
-var defaultStringifyOptions = {
-  indent: "    ",
-  newline: "\n",
-  prefixMap: /* @__PURE__ */ new Map(),
-  includeXmlDeclaration: true
+// src/xml/mappedXmlRules.ts
+var EmptyRules = {
+  __type: /* @__PURE__ */ invariant(),
+  attributes: /* @__PURE__ */ new Map(),
+  elements: /* @__PURE__ */ new Map(),
+  characters: void 0
 };
-var XmlWriter = class {
-  constructor(rules, options) {
-    __publicField(this, "rules", rules);
-    __publicField(this, "options");
-    __publicField(this, "usedPrefixes", /* @__PURE__ */ new Map());
-    __publicField(this, "traversed", /* @__PURE__ */ new Set());
-    this.options = __spreadValues(__spreadValues({}, defaultStringifyOptions), options);
-  }
-  stringify(object) {
-    let str = this.options.includeXmlDeclaration ? '<?xml version="1.0"?>' + this.options.newline : "";
-    const state = new StringifyState();
-    str += this.stringifyChildren(object, this.rules.elements, state);
-    this.usedPrefixes.clear();
-    this.traversed.clear();
-    return str;
-  }
-  qName(localPart, namespaceUri) {
-    if (!namespaceUri) return localPart;
-    const prefixMap = this.options.prefixMap;
-    const prefix = getOrSet(this.usedPrefixes, namespaceUri, () => {
-      if (prefixMap.has(namespaceUri)) {
-        return prefixMap.get(namespaceUri);
-      }
-      return substitute(locale.prefixTemplate, {
-        value: (this.usedPrefixes.size + 1).toString(36)
-      });
-    });
-    return `${prefix}:${localPart}`;
-  }
-  /**
-   * Stringifies an element.
-   *
-   * @param object
-   * @param rule
-   * @param state
-   */
-  stringifyElement(object, rule, state) {
-    var _a2;
-    if (this.traversed.has(object))
-      throw new XmlSchemaError(xmlSchemaErrorLocale.cyclicReferences);
-    this.traversed.add(object);
-    const nl = this.options.newline;
-    const isDocument = state.depth === 0;
-    let namespaces = "";
-    let xmlns = state.xmlns;
-    if (xmlns !== rule.namespaceUri && (xmlns == null || !rule.namespaceUri)) {
-      xmlns = rule.namespaceUri;
-      namespaces += ` xmlns="${(_a2 = rule.namespaceUri) != null ? _a2 : ""}"`;
-    }
-    const childState = state.createChild(xmlns, this.options.indent);
-    const rules = rule.rules();
-    const attributes = this.stringifyAttributes(object, rules.attributes);
-    const children = this.stringifyChildren(
-      object,
-      rules.elements,
-      childState
-    );
-    const text = this.stringifyCharacters(object, rules.characters);
-    if (isDocument) {
-      this.usedPrefixes.forEach((prefix, uri) => {
-        namespaces += ` xmlns:${prefix}="${uri}"`;
-      });
-    }
-    const indent = state.indent;
-    const childIndent = childState.indent;
-    const qName2 = rule.namespaceUri === xmlns ? rule.localPart : this.qName(rule.localPart, rule.namespaceUri);
-    let str = `${indent}<${qName2}${namespaces}${attributes}`;
-    if (children) {
-      str += `>`;
-      if (text) str += `${nl}${childIndent}${text}`;
-      str += nl + children;
-      str += `${nl}${indent}</${qName2}>`;
-    } else if (text) {
-      str += `>${text}</${qName2}>`;
+function mapXmlRules(rules, parentNamespaceUri = null) {
+  var _a2, _b, _c;
+  const attributeRules = /* @__PURE__ */ new Map();
+  const elementRules = /* @__PURE__ */ new Map();
+  let charactersRule = void 0;
+  for (const property in rules) {
+    const handlerOrFunction = rules[property];
+    let handler;
+    if (typeof handlerOrFunction === "function") {
+      handler = handlerOrFunction();
     } else {
-      str += "/>";
+      handler = handlerOrFunction;
     }
-    return str;
-  }
-  /**
-   * Stringifies an element's attributes.
-   *
-   * @param object
-   * @param attributes
-   * @return Returns the attributes string. This will include a leading space if there are any
-   * found attributes.
-   */
-  stringifyAttributes(object, attributes) {
-    let str = "";
-    attributes.forEach((attributeRule) => {
-      const propertyValue = object[attributeRule.property];
-      if (propertyValue !== void 0) {
-        const attributeValue = attributeRule.stringify(propertyValue);
-        if (attributeRule.default === void 0 || !equalDeep(propertyValue, attributeRule.default)) {
-          str += ` ${this.qName(
-            attributeRule.localPart,
-            attributeRule.namespaceUri
-          )}="${encodeEntities(attributeValue)}"`;
-        }
-      } else {
-        if (attributeRule.required) {
-          throw new XmlSchemaError(
-            substitute(xmlSchemaErrorLocale.requiredAttribute, {
-              property: attributeRule.property
-            })
+    let key;
+    switch (handler.type) {
+      case "characters" /* CHARACTERS */:
+        if (charactersRule !== void 0)
+          throw new IllegalArgumentError(
+            "characters handler already defined"
+          );
+        charactersRule = {
+          property,
+          parse: handler.parse,
+          stringify: handler.stringify
+        };
+        break;
+      case "element" /* ELEMENT */:
+      case "elements" /* ELEMENTS */: {
+        const localPart = (_a2 = handler.localPart) != null ? _a2 : property;
+        const namespaceUri = handler.namespaceUri === void 0 ? parentNamespaceUri : handler.namespaceUri;
+        key = xmlRuleKey(localPart, namespaceUri);
+        if (elementRules.has(key)) {
+          throw new IllegalArgumentError(
+            `Multiple element rules for ${key}`
           );
         }
-      }
-    });
-    return str;
-  }
-  /**
-   * Stringifies a property as a CDATA node.
-   *
-   * @param object
-   * @param charactersRule
-   */
-  stringifyCharacters(object, charactersRule) {
-    if (!charactersRule) return null;
-    const str = charactersRule.stringify(object[charactersRule.property]);
-    if (!str) return "";
-    return `<![CDATA[${str}]]>`;
-  }
-  /**
-   * Stringifies an element's child elements.
-   *
-   * @param object
-   * @param elements
-   * @param state
-   */
-  stringifyChildren(object, elements2, state) {
-    let str = "";
-    elements2.forEach((elementsRule) => {
-      const child = object[elementsRule.property];
-      if (child) {
-        if (elementsRule.array) {
-          const arr = child;
-          if (elementsRule.minOccurs > arr.length) {
-            throw new XmlSchemaError(
-              substitute(xmlSchemaErrorLocale.atLeastElements, {
-                property: elementsRule.property,
-                expected: elementsRule.minOccurs,
-                actual: arr.length
-              })
-            );
-          }
-          if (elementsRule.maxOccurs != null && elementsRule.maxOccurs < arr.length) {
-            throw new XmlSchemaError(
-              substitute(xmlSchemaErrorLocale.atMostElements, {
-                property: elementsRule.property,
-                expected: elementsRule.maxOccurs,
-                actual: arr.length
-              })
-            );
-          }
-          for (const element2 of arr) {
-            if (str) str += this.options.newline;
-            str += this.stringifyElement(
-              element2,
-              elementsRule,
-              state
-            );
-          }
+        if (handler.type === "element" /* ELEMENT */) {
+          const rules2 = handler.rules;
+          elementRules.set(key, {
+            array: false,
+            property,
+            minOccurs: handler.required ? 1 : 0,
+            maxOccurs: 1,
+            rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
+            useEmptyArrays: false,
+            localPart,
+            namespaceUri
+          });
         } else {
-          if (str) str += this.options.newline;
-          str += this.stringifyElement(child, elementsRule, state);
+          const rules2 = handler.rules;
+          elementRules.set(key, {
+            array: true,
+            property,
+            maxOccurs: handler.maxOccurs,
+            minOccurs: handler.minOccurs,
+            rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
+            useEmptyArrays: handler.useEmptyArrays,
+            localPart,
+            namespaceUri
+          });
         }
-      } else {
-        if (elementsRule.minOccurs > 0) {
-          throw new XmlSchemaError(
-            substitute(xmlSchemaErrorLocale.atLeastElements, {
-              property: elementsRule.property,
-              expected: elementsRule.minOccurs,
-              actual: 0
-            })
+        break;
+      }
+      case "attribute" /* ATTRIBUTE */: {
+        const namespaceUri = handler.namespaceUri;
+        const localPart = (_b = handler.localPart) != null ? _b : property;
+        key = xmlRuleKey(localPart, namespaceUri);
+        if (attributeRules.has(key)) {
+          throw new IllegalArgumentError(
+            `Multiple attribute rules for ${key}`
           );
         }
+        attributeRules.set(key, {
+          property,
+          default: handler.default,
+          parse: handler.parse,
+          stringify: handler.stringify,
+          required: handler.required,
+          localPart,
+          namespaceUri: (_c = handler.namespaceUri) != null ? _c : null
+        });
+        break;
       }
-    });
-    return str;
+    }
   }
+  return {
+    __type: invariant(),
+    attributes: attributeRules,
+    elements: elementRules,
+    characters: charactersRule
+  };
+}
+function xmlRuleKey(localPart, namespaceUri = null) {
+  return `${namespaceUri != null ? namespaceUri : ""}:${localPart}`;
+}
+
+// src/xml/mergeXmlRules.ts
+import {
+  plainObjectMergeRule,
+  substitute,
+  ValidationError
+} from "@amazon/vinyl-util";
+var locale = {
+  illegalRuleOverrideTypeError: "Cannot override the rule {property} of type {sourceType} with a rule of type {overrideType}",
+  illegalQNameOverrideError: "Cannot override the rule {property} with a different localPart or namespace"
 };
-var StringifyState = class _StringifyState {
-  constructor(depth = 0, xmlns = null, indent = "") {
-    __publicField(this, "depth", depth);
-    __publicField(this, "xmlns", xmlns);
-    __publicField(this, "indent", indent);
+function mergeXmlRules(...rules) {
+  let finalRule = rules[0];
+  for (let i = 1; i < rules.length; i++) {
+    finalRule = plainObjectMergeRule.merge(
+      finalRule,
+      rules[i],
+      mergeXmlRule
+    );
+  }
+  return finalRule;
+}
+function mergeXmlRule(sourceA, sourceB, prop) {
+  var _a2, _b, _c, _d;
+  if (sourceA == null) return sourceB;
+  const sourceAIsLazy = typeof sourceA === "function";
+  const sourceBIsLazy = typeof sourceB === "function";
+  if (sourceAIsLazy || sourceBIsLazy) {
+    return () => {
+      const a = sourceAIsLazy ? sourceA() : sourceA;
+      const b = sourceBIsLazy ? sourceB() : sourceB;
+      return mergeXmlRule(a, b, prop);
+    };
+  }
+  if (sourceA.type !== sourceB.type) {
+    throw new ValidationError(
+      substitute(locale.illegalRuleOverrideTypeError, {
+        property: prop,
+        sourceType: sourceA.type,
+        overrideType: sourceB.type
+      })
+    );
+  }
+  switch (sourceA.type) {
+    case "attribute" /* ATTRIBUTE */:
+    case "element" /* ELEMENT */:
+    case "elements" /* ELEMENTS */: {
+      const b = sourceB;
+      if (sourceA.namespaceUri !== b.namespaceUri || ((_a2 = sourceA.localPart) != null ? _a2 : prop) !== ((_b = b.localPart) != null ? _b : prop)) {
+        throw new ValidationError(
+          substitute(locale.illegalQNameOverrideError, {
+            property: prop
+          })
+        );
+      }
+      break;
+    }
   }
-  createChild(xmlns, indent) {
-    return new _StringifyState(this.depth + 1, xmlns, this.indent + indent);
+  switch (sourceA.type) {
+    case "attribute" /* ATTRIBUTE */: {
+      const b = sourceB;
+      return __spreadProps(__spreadValues({}, b), {
+        default: (_c = b.default) != null ? _c : sourceA.default
+      });
+    }
+    case "characters" /* CHARACTERS */:
+      return sourceB;
+    case "element" /* ELEMENT */: {
+      const b = sourceB;
+      return __spreadProps(__spreadValues({}, b), {
+        required: sourceA.required || b.required,
+        rules: mergeXmlRules(sourceA.rules, b.rules)
+      });
+    }
+    case "elements" /* ELEMENTS */: {
+      const b = sourceB;
+      const maxOccurs = sourceA.maxOccurs != null && b.maxOccurs != null ? Math.min(sourceA.maxOccurs, b.maxOccurs) : (_d = sourceA.maxOccurs) != null ? _d : b.maxOccurs;
+      return __spreadProps(__spreadValues({}, b), {
+        minOccurs: Math.max(sourceA.minOccurs, b.minOccurs),
+        maxOccurs,
+        useEmptyArrays: sourceA.useEmptyArrays || b.useEmptyArrays,
+        rules: mergeXmlRules(sourceA.rules, b.rules)
+      });
+    }
   }
-};
-function stringifyXml(object, rules, options) {
-  const writer = new XmlWriter(rules, options);
-  return writer.stringify(object);
 }
 
 // src/xml/parseXml.ts
@@ -535,223 +503,19 @@ function xmlAttributes(reader, stackElement) {
     }
     if (name.prefix === "xmlns") {
       name.namespaceUri = XMLNS;
-      stackElement.namespaceMap.set(
-        name.localPart,
-        value === "" ? null : value
-      );
-    } else if (!name.prefix && name.localPart === "xmlns") {
-      name.namespaceUri = XMLNS;
-      stackElement.defaultNamespaceUri = !value ? null : value;
-    }
-    if (attributes[name.qName] != null)
-      reader.err(`Attribute '${name.qName}' is already specified.`);
-    attributes[name.qName] = { name, value };
-  }
-  return attributes;
-}
-
-// src/xml/mergeXmlRules.ts
-import {
-  plainObjectMergeRule,
-  substitute as substitute2,
-  ValidationError
-} from "@amazon/vinyl-util";
-var locale2 = {
-  illegalRuleOverrideTypeError: "Cannot override the rule {property} of type {sourceType} with a rule of type {overrideType}",
-  illegalQNameOverrideError: "Cannot override the rule {property} with a different localPart or namespace"
-};
-function mergeXmlRules(...rules) {
-  let finalRule = rules[0];
-  for (let i = 1; i < rules.length; i++) {
-    finalRule = plainObjectMergeRule.merge(
-      finalRule,
-      rules[i],
-      mergeXmlRule
-    );
-  }
-  return finalRule;
-}
-function mergeXmlRule(sourceA, sourceB, prop) {
-  var _a2, _b, _c, _d;
-  if (sourceA == null) return sourceB;
-  const sourceAIsLazy = typeof sourceA === "function";
-  const sourceBIsLazy = typeof sourceB === "function";
-  if (sourceAIsLazy || sourceBIsLazy) {
-    return () => {
-      const a = sourceAIsLazy ? sourceA() : sourceA;
-      const b = sourceBIsLazy ? sourceB() : sourceB;
-      return mergeXmlRule(a, b, prop);
-    };
-  }
-  if (sourceA.type !== sourceB.type) {
-    throw new ValidationError(
-      substitute2(locale2.illegalRuleOverrideTypeError, {
-        property: prop,
-        sourceType: sourceA.type,
-        overrideType: sourceB.type
-      })
-    );
-  }
-  switch (sourceA.type) {
-    case "attribute" /* ATTRIBUTE */:
-    case "element" /* ELEMENT */:
-    case "elements" /* ELEMENTS */: {
-      const b = sourceB;
-      if (sourceA.namespaceUri !== b.namespaceUri || ((_a2 = sourceA.localPart) != null ? _a2 : prop) !== ((_b = b.localPart) != null ? _b : prop)) {
-        throw new ValidationError(
-          substitute2(locale2.illegalQNameOverrideError, {
-            property: prop
-          })
-        );
-      }
-      break;
-    }
-  }
-  switch (sourceA.type) {
-    case "attribute" /* ATTRIBUTE */: {
-      const b = sourceB;
-      return __spreadProps(__spreadValues({}, b), {
-        default: (_c = b.default) != null ? _c : sourceA.default
-      });
-    }
-    case "characters" /* CHARACTERS */:
-      return sourceB;
-    case "element" /* ELEMENT */: {
-      const b = sourceB;
-      return __spreadProps(__spreadValues({}, b), {
-        required: sourceA.required || b.required,
-        rules: mergeXmlRules(sourceA.rules, b.rules)
-      });
-    }
-    case "elements" /* ELEMENTS */: {
-      const b = sourceB;
-      const maxOccurs = sourceA.maxOccurs != null && b.maxOccurs != null ? Math.min(sourceA.maxOccurs, b.maxOccurs) : (_d = sourceA.maxOccurs) != null ? _d : b.maxOccurs;
-      return __spreadProps(__spreadValues({}, b), {
-        minOccurs: Math.max(sourceA.minOccurs, b.minOccurs),
-        maxOccurs,
-        useEmptyArrays: sourceA.useEmptyArrays || b.useEmptyArrays,
-        rules: mergeXmlRules(sourceA.rules, b.rules)
-      });
-    }
-  }
-}
-
-// src/xml/mappedXmlRules.ts
-import {
-  IllegalArgumentError,
-  invariant,
-  memoize
-} from "@amazon/vinyl-util";
-var EmptyRules = {
-  __type: /* @__PURE__ */ invariant(),
-  attributes: /* @__PURE__ */ new Map(),
-  elements: /* @__PURE__ */ new Map(),
-  characters: void 0
-};
-function mapXmlRules(rules, parentNamespaceUri = null) {
-  var _a2, _b, _c;
-  const attributeRules = /* @__PURE__ */ new Map();
-  const elementRules = /* @__PURE__ */ new Map();
-  let charactersRule = void 0;
-  for (const property in rules) {
-    const handlerOrFunction = rules[property];
-    let handler;
-    if (typeof handlerOrFunction === "function") {
-      handler = handlerOrFunction();
-    } else {
-      handler = handlerOrFunction;
-    }
-    let key;
-    switch (handler.type) {
-      case "characters" /* CHARACTERS */:
-        if (charactersRule !== void 0)
-          throw new IllegalArgumentError(
-            "characters handler already defined"
-          );
-        charactersRule = {
-          property,
-          parse: handler.parse,
-          stringify: handler.stringify
-        };
-        break;
-      case "element" /* ELEMENT */:
-      case "elements" /* ELEMENTS */: {
-        const localPart = (_a2 = handler.localPart) != null ? _a2 : property;
-        const namespaceUri = handler.namespaceUri === void 0 ? parentNamespaceUri : handler.namespaceUri;
-        key = xmlRuleKey(localPart, namespaceUri);
-        if (elementRules.has(key)) {
-          throw new IllegalArgumentError(
-            `Multiple element rules for ${key}`
-          );
-        }
-        if (handler.type === "element" /* ELEMENT */) {
-          const rules2 = handler.rules;
-          elementRules.set(key, {
-            array: false,
-            property,
-            minOccurs: handler.required ? 1 : 0,
-            maxOccurs: 1,
-            rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
-            useEmptyArrays: false,
-            localPart,
-            namespaceUri
-          });
-        } else {
-          const rules2 = handler.rules;
-          elementRules.set(key, {
-            array: true,
-            property,
-            maxOccurs: handler.maxOccurs,
-            minOccurs: handler.minOccurs,
-            rules: memoize(() => mapXmlRules(rules2, namespaceUri)),
-            useEmptyArrays: handler.useEmptyArrays,
-            localPart,
-            namespaceUri
-          });
-        }
-        break;
-      }
-      case "attribute" /* ATTRIBUTE */: {
-        const namespaceUri = handler.namespaceUri;
-        const localPart = (_b = handler.localPart) != null ? _b : property;
-        key = xmlRuleKey(localPart, namespaceUri);
-        if (attributeRules.has(key)) {
-          throw new IllegalArgumentError(
-            `Multiple attribute rules for ${key}`
-          );
-        }
-        attributeRules.set(key, {
-          property,
-          default: handler.default,
-          parse: handler.parse,
-          stringify: handler.stringify,
-          required: handler.required,
-          localPart,
-          namespaceUri: (_c = handler.namespaceUri) != null ? _c : null
-        });
-        break;
-      }
-    }
-  }
-  return {
-    __type: invariant(),
-    attributes: attributeRules,
-    elements: elementRules,
-    characters: charactersRule
-  };
-}
-function xmlRuleKey(localPart, namespaceUri = null) {
-  return `${namespaceUri != null ? namespaceUri : ""}:${localPart}`;
-}
-
-// src/xml/QName.ts
-function qName(localPart, prefix = null, namespaceUri = null) {
-  return {
-    localPart,
-    prefix,
-    namespaceUri,
-    qName: prefix ? `${prefix}:${localPart}` : localPart
-  };
+      stackElement.namespaceMap.set(
+        name.localPart,
+        value === "" ? null : value
+      );
+    } else if (!name.prefix && name.localPart === "xmlns") {
+      name.namespaceUri = XMLNS;
+      stackElement.defaultNamespaceUri = !value ? null : value;
+    }
+    if (attributes[name.qName] != null)
+      reader.err(`Attribute '${name.qName}' is already specified.`);
+    attributes[name.qName] = { name, value };
+  }
+  return attributes;
 }
 
 // src/xml/ParseXmlHandlerImpl.ts
@@ -760,9 +524,29 @@ import {
   decodeEntities as decodeEntities2,
   IllegalStateError,
   last as last2,
-  substitute as substitute3,
+  substitute as substitute2,
   toJson
 } from "@amazon/vinyl-util";
+
+// src/xml/XmlSchemaError.ts
+import { ErrorOrigin as ErrorOrigin2, ReportableError } from "@amazon/vinyl-util";
+var xmlSchemaErrorLocale = {
+  atLeastElements: "Expected at least {expected} occurrences of {property} but was {actual}",
+  atMostElements: "Expected at most {expected} occurrences of {property} but was {actual}",
+  cyclicReferences: "Cyclic reference detected",
+  requiredAttribute: `Attribute '{property}' is required`
+};
+var XmlSchemaError = class _XmlSchemaError extends ReportableError {
+  get [Symbol.toStringTag]() {
+    return "XmlSchemaError";
+  }
+  constructor(message) {
+    super(message, ErrorOrigin2.PARSING);
+    Object.setPrototypeOf(this, _XmlSchemaError.prototype);
+  }
+};
+
+// src/xml/ParseXmlHandlerImpl.ts
 function getRule(name, rules) {
   return rules.get(xmlRuleKey(name.localPart, name.namespaceUri));
 }
@@ -828,7 +612,7 @@ var ParseXmlHandlerImpl = class {
             element2[rule.property] = rule.default;
           } else if (this.options.validateRules && rule.required) {
             throw new XmlSchemaError(
-              substitute3(xmlSchemaErrorLocale.requiredAttribute, {
+              substitute2(xmlSchemaErrorLocale.requiredAttribute, {
                 property: rule.property
               })
             );
@@ -881,7 +665,7 @@ var ParseXmlHandlerImpl = class {
       const length = rule.array ? (_b = (_a2 = current.element[rule.property]) == null ? void 0 : _a2.length) != null ? _b : 0 : current.element[rule.property] ? 1 : 0;
       if (length < rule.minOccurs) {
         throw new XmlSchemaError(
-          substitute3(xmlSchemaErrorLocale.atLeastElements, {
+          substitute2(xmlSchemaErrorLocale.atLeastElements, {
             property: rule.property,
             expected: rule.minOccurs,
             actual: length
@@ -890,7 +674,7 @@ var ParseXmlHandlerImpl = class {
       }
       if (rule.maxOccurs != null && length > rule.maxOccurs) {
         throw new XmlSchemaError(
-          substitute3(xmlSchemaErrorLocale.atMostElements, {
+          substitute2(xmlSchemaErrorLocale.atMostElements, {
             property: rule.property,
             expected: rule.maxOccurs,
             actual: length
@@ -942,13 +726,231 @@ var _XmlElementImpl = class _XmlElementImpl {
 };
 var XmlElementImpl = _XmlElementImpl;
 
-// src/xlink/actuateValidator.ts
-import { isOneOf } from "@amazon/vinyl-validation";
-import { ErrorOrigin as ErrorOrigin2 } from "@amazon/vinyl-util";
-var actuateValidator = /* @__PURE__ */ isOneOf("onLoad", "onRequest");
-function assertActuateEnum(str) {
-  actuateValidator.assert(str, ErrorOrigin2.PARSING);
-  return str;
+// src/xml/QName.ts
+function qName(localPart, prefix = null, namespaceUri = null) {
+  return {
+    localPart,
+    prefix,
+    namespaceUri,
+    qName: prefix ? `${prefix}:${localPart}` : localPart
+  };
+}
+
+// src/xml/stringifyXml.ts
+import {
+  encodeEntities,
+  equalDeep,
+  getOrSet,
+  substitute as substitute3
+} from "@amazon/vinyl-util";
+var locale2 = {
+  /**
+   * When a namespace binding is generated, if the prefix was not provided in the stringifier
+   * options, it will be generated from this template.
+   */
+  prefixTemplate: "ns_{value}"
+};
+var defaultStringifyOptions = {
+  indent: "    ",
+  newline: "\n",
+  prefixMap: /* @__PURE__ */ new Map(),
+  includeXmlDeclaration: true
+};
+var XmlWriter = class {
+  constructor(rules, options) {
+    __publicField(this, "rules", rules);
+    __publicField(this, "options");
+    __publicField(this, "usedPrefixes", /* @__PURE__ */ new Map());
+    __publicField(this, "traversed", /* @__PURE__ */ new Set());
+    this.options = __spreadValues(__spreadValues({}, defaultStringifyOptions), options);
+  }
+  stringify(object) {
+    let str = this.options.includeXmlDeclaration ? '<?xml version="1.0"?>' + this.options.newline : "";
+    const state = new StringifyState();
+    str += this.stringifyChildren(object, this.rules.elements, state);
+    this.usedPrefixes.clear();
+    this.traversed.clear();
+    return str;
+  }
+  qName(localPart, namespaceUri) {
+    if (!namespaceUri) return localPart;
+    const prefixMap = this.options.prefixMap;
+    const prefix = getOrSet(this.usedPrefixes, namespaceUri, () => {
+      if (prefixMap.has(namespaceUri)) {
+        return prefixMap.get(namespaceUri);
+      }
+      return substitute3(locale2.prefixTemplate, {
+        value: (this.usedPrefixes.size + 1).toString(36)
+      });
+    });
+    return `${prefix}:${localPart}`;
+  }
+  /**
+   * Stringifies an element.
+   *
+   * @param object
+   * @param rule
+   * @param state
+   */
+  stringifyElement(object, rule, state) {
+    var _a2;
+    if (this.traversed.has(object))
+      throw new XmlSchemaError(xmlSchemaErrorLocale.cyclicReferences);
+    this.traversed.add(object);
+    const nl = this.options.newline;
+    const isDocument = state.depth === 0;
+    let namespaces = "";
+    let xmlns = state.xmlns;
+    if (xmlns !== rule.namespaceUri && (xmlns == null || !rule.namespaceUri)) {
+      xmlns = rule.namespaceUri;
+      namespaces += ` xmlns="${(_a2 = rule.namespaceUri) != null ? _a2 : ""}"`;
+    }
+    const childState = state.createChild(xmlns, this.options.indent);
+    const rules = rule.rules();
+    const attributes = this.stringifyAttributes(object, rules.attributes);
+    const children = this.stringifyChildren(
+      object,
+      rules.elements,
+      childState
+    );
+    const text = this.stringifyCharacters(object, rules.characters);
+    if (isDocument) {
+      this.usedPrefixes.forEach((prefix, uri) => {
+        namespaces += ` xmlns:${prefix}="${uri}"`;
+      });
+    }
+    const indent = state.indent;
+    const childIndent = childState.indent;
+    const qName2 = rule.namespaceUri === xmlns ? rule.localPart : this.qName(rule.localPart, rule.namespaceUri);
+    let str = `${indent}<${qName2}${namespaces}${attributes}`;
+    if (children) {
+      str += `>`;
+      if (text) str += `${nl}${childIndent}${text}`;
+      str += nl + children;
+      str += `${nl}${indent}</${qName2}>`;
+    } else if (text) {
+      str += `>${text}</${qName2}>`;
+    } else {
+      str += "/>";
+    }
+    return str;
+  }
+  /**
+   * Stringifies an element's attributes.
+   *
+   * @param object
+   * @param attributes
+   * @return Returns the attributes string. This will include a leading space if there are any
+   * found attributes.
+   */
+  stringifyAttributes(object, attributes) {
+    let str = "";
+    attributes.forEach((attributeRule) => {
+      const propertyValue = object[attributeRule.property];
+      if (propertyValue !== void 0) {
+        const attributeValue = attributeRule.stringify(propertyValue);
+        if (attributeRule.default === void 0 || !equalDeep(propertyValue, attributeRule.default)) {
+          str += ` ${this.qName(
+            attributeRule.localPart,
+            attributeRule.namespaceUri
+          )}="${encodeEntities(attributeValue)}"`;
+        }
+      } else {
+        if (attributeRule.required) {
+          throw new XmlSchemaError(
+            substitute3(xmlSchemaErrorLocale.requiredAttribute, {
+              property: attributeRule.property
+            })
+          );
+        }
+      }
+    });
+    return str;
+  }
+  /**
+   * Stringifies a property as a CDATA node.
+   *
+   * @param object
+   * @param charactersRule
+   */
+  stringifyCharacters(object, charactersRule) {
+    if (!charactersRule) return null;
+    const str = charactersRule.stringify(object[charactersRule.property]);
+    if (!str) return "";
+    return `<![CDATA[${str}]]>`;
+  }
+  /**
+   * Stringifies an element's child elements.
+   *
+   * @param object
+   * @param elements
+   * @param state
+   */
+  stringifyChildren(object, elements2, state) {
+    let str = "";
+    elements2.forEach((elementsRule) => {
+      const child = object[elementsRule.property];
+      if (child) {
+        if (elementsRule.array) {
+          const arr = child;
+          if (elementsRule.minOccurs > arr.length) {
+            throw new XmlSchemaError(
+              substitute3(xmlSchemaErrorLocale.atLeastElements, {
+                property: elementsRule.property,
+                expected: elementsRule.minOccurs,
+                actual: arr.length
+              })
+            );
+          }
+          if (elementsRule.maxOccurs != null && elementsRule.maxOccurs < arr.length) {
+            throw new XmlSchemaError(
+              substitute3(xmlSchemaErrorLocale.atMostElements, {
+                property: elementsRule.property,
+                expected: elementsRule.maxOccurs,
+                actual: arr.length
+              })
+            );
+          }
+          for (const element2 of arr) {
+            if (str) str += this.options.newline;
+            str += this.stringifyElement(
+              element2,
+              elementsRule,
+              state
+            );
+          }
+        } else {
+          if (str) str += this.options.newline;
+          str += this.stringifyElement(child, elementsRule, state);
+        }
+      } else {
+        if (elementsRule.minOccurs > 0) {
+          throw new XmlSchemaError(
+            substitute3(xmlSchemaErrorLocale.atLeastElements, {
+              property: elementsRule.property,
+              expected: elementsRule.minOccurs,
+              actual: 0
+            })
+          );
+        }
+      }
+    });
+    return str;
+  }
+};
+var StringifyState = class _StringifyState {
+  constructor(depth = 0, xmlns = null, indent = "") {
+    __publicField(this, "depth", depth);
+    __publicField(this, "xmlns", xmlns);
+    __publicField(this, "indent", indent);
+  }
+  createChild(xmlns, indent) {
+    return new _StringifyState(this.depth + 1, xmlns, this.indent + indent);
+  }
+};
+function stringifyXml(object, rules, options) {
+  const writer = new XmlWriter(rules, options);
+  return writer.stringify(object);
 }
 export {
   EmptyRules,