@amazon/vinyl-xml 1.2.0 → 2.0.4

package/dist/index.cjs

@@ -72,8 +72,20 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/xml/xmlRules.ts
+// src/xlink/actuateValidator.ts
+var import_vinyl_validation = require("@amazon/vinyl-validation");
 var import_vinyl_util = require("@amazon/vinyl-util");
+var actuateValidator = /* @__PURE__ */ (0, import_vinyl_validation.isOneOf)("onLoad", "onRequest");
+function assertActuateEnum(str) {
+  actuateValidator.assert(str, import_vinyl_util.ErrorOrigin.PARSING);
+  return str;
+}
+
+// src/xml/mappedXmlRules.ts
+var import_vinyl_util3 = require("@amazon/vinyl-util");
+
+// src/xml/xmlRules.ts
+var import_vinyl_util2 = require("@amazon/vinyl-util");
 var XmlRuleType = /* @__PURE__ */ ((XmlRuleType2) => {
   XmlRuleType2["CHARACTERS"] = "characters";
   XmlRuleType2["ATTRIBUTE"] = "attribute";
@@ -106,7 +118,7 @@ function elements(rules, options) {
 function characters(parse, stringify2) {
   return { type: "characters" /* CHARACTERS */, parse, stringify: stringify2 };
 }
-var charactersString = /* @__PURE__ */ characters((i) => i, import_vinyl_util.stringify);
+var charactersString = /* @__PURE__ */ characters((i) => i, import_vinyl_util2.stringify);
 function attr(parse, stringify2, options) {
   return __spreadProps(__spreadValues({
     type: "attribute" /* ATTRIBUTE */,
@@ -120,268 +132,221 @@ function attr(parse, stringify2, options) {
   });
 }
 function attrString(options) {
-  return attr((i) => i, import_vinyl_util.stringify, options);
+  return attr((i) => i, import_vinyl_util2.stringify, options);
 }
 function attrInt(options) {
-  return attr(parseInt, import_vinyl_util.stringify, options);
+  return attr(parseInt, import_vinyl_util2.stringify, options);
 }
 function attrFloat(options) {
-  return attr(parseFloat, import_vinyl_util.stringify, options);
+  return attr(parseFloat, import_vinyl_util2.stringify, options);
 }
 function attrBoolean(options) {
-  return attr(import_vinyl_util.parseBoolean, import_vinyl_util.stringify, options);
+  return attr(import_vinyl_util2.parseBoolean, import_vinyl_util2.stringify, options);
 }
 function attrDateTime(options) {
-  return attr(import_vinyl_util.parseDate, import_vinyl_util.stringifyDate, options);
+  return attr(import_vinyl_util2.parseDate, import_vinyl_util2.stringifyDate, options);
 }
 
-// src/xml/stringifyXml.ts
-var import_vinyl_util3 = require("@amazon/vinyl-util");
-
-// src/xml/XmlSchemaError.ts
-var import_vinyl_util2 = require("@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 import_vinyl_util2.ReportableError {
-  get [Symbol.toStringTag]() {
-    return "XmlSchemaError";
-  }
-  constructor(message) {
-    super(message, import_vinyl_util2.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__ */ (0, import_vinyl_util3.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 = (0, import_vinyl_util3.getOrSet)(this.usedPrefixes, namespaceUri, () => {
-      if (prefixMap.has(namespaceUri)) {
-        return prefixMap.get(namespaceUri);
-      }
-      return (0, import_vinyl_util3.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 || !(0, import_vinyl_util3.equalDeep)(propertyValue, attributeRule.default)) {
-          str += ` ${this.qName(
-            attributeRule.localPart,
-            attributeRule.namespaceUri
-          )}="${(0, import_vinyl_util3.encodeEntities)(attributeValue)}"`;
-        }
-      } else {
-        if (attributeRule.required) {
-          throw new XmlSchemaError(
-            (0, import_vinyl_util3.substitute)(xmlSchemaErrorLocale.requiredAttribute, {
-              property: attributeRule.property
-            })
+    let key;
+    switch (handler.type) {
+      case "characters" /* CHARACTERS */:
+        if (charactersRule !== void 0)
+          throw new import_vinyl_util3.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 import_vinyl_util3.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(
-              (0, import_vinyl_util3.substitute)(xmlSchemaErrorLocale.atLeastElements, {
-                property: elementsRule.property,
-                expected: elementsRule.minOccurs,
-                actual: arr.length
-              })
-            );
-          }
-          if (elementsRule.maxOccurs != null && elementsRule.maxOccurs < arr.length) {
-            throw new XmlSchemaError(
-              (0, import_vinyl_util3.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: (0, import_vinyl_util3.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: (0, import_vinyl_util3.memoize)(() => mapXmlRules(rules2, namespaceUri)),
+            useEmptyArrays: handler.useEmptyArrays,
+            localPart,
+            namespaceUri
+          });
         }
-      } else {
-        if (elementsRule.minOccurs > 0) {
-          throw new XmlSchemaError(
-            (0, import_vinyl_util3.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 import_vinyl_util3.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: (0, import_vinyl_util3.invariant)(),
+    attributes: attributeRules,
+    elements: elementRules,
+    characters: charactersRule
+  };
+}
+function xmlRuleKey(localPart, namespaceUri = null) {
+  return `${namespaceUri != null ? namespaceUri : ""}:${localPart}`;
+}
+
+// src/xml/mergeXmlRules.ts
+var import_vinyl_util4 = require("@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 = import_vinyl_util4.plainObjectMergeRule.merge(
+      finalRule,
+      rules[i],
+      mergeXmlRule
+    );
   }
-  createChild(xmlns, indent) {
-    return new _StringifyState(this.depth + 1, xmlns, this.indent + indent);
+  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 import_vinyl_util4.ValidationError(
+      (0, import_vinyl_util4.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 import_vinyl_util4.ValidationError(
+          (0, import_vinyl_util4.substitute)(locale.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)
+      });
+    }
   }
-};
-function stringifyXml(object, rules, options) {
-  const writer = new XmlWriter(rules, options);
-  return writer.stringify(object);
 }
 
 // src/xml/parseXml.ts
-var import_vinyl_util4 = require("@amazon/vinyl-util");
+var import_vinyl_util5 = require("@amazon/vinyl-util");
 var XMLNS = "http://www.w3.org/2000/xmlns/";
-var LT = /* @__PURE__ */ (0, import_vinyl_util4.char)("<");
-var GT = /* @__PURE__ */ (0, import_vinyl_util4.char)(">");
-var EQ = /* @__PURE__ */ (0, import_vinyl_util4.char)("=");
-var SLASH = /* @__PURE__ */ (0, import_vinyl_util4.char)("/");
-var COLON = /* @__PURE__ */ (0, import_vinyl_util4.char)(":");
-var QMARK = /* @__PURE__ */ (0, import_vinyl_util4.char)("?");
-var EXCL = /* @__PURE__ */ (0, import_vinyl_util4.char)("!");
-var APOS = /* @__PURE__ */ (0, import_vinyl_util4.char)("'");
-var QUOT = /* @__PURE__ */ (0, import_vinyl_util4.char)('"');
+var LT = /* @__PURE__ */ (0, import_vinyl_util5.char)("<");
+var GT = /* @__PURE__ */ (0, import_vinyl_util5.char)(">");
+var EQ = /* @__PURE__ */ (0, import_vinyl_util5.char)("=");
+var SLASH = /* @__PURE__ */ (0, import_vinyl_util5.char)("/");
+var COLON = /* @__PURE__ */ (0, import_vinyl_util5.char)(":");
+var QMARK = /* @__PURE__ */ (0, import_vinyl_util5.char)("?");
+var EXCL = /* @__PURE__ */ (0, import_vinyl_util5.char)("!");
+var APOS = /* @__PURE__ */ (0, import_vinyl_util5.char)("'");
+var QUOT = /* @__PURE__ */ (0, import_vinyl_util5.char)('"');
 var QUOTES = /* @__PURE__ */ new Set([APOS, QUOT]);
 function parseXml(str, handler) {
-  const c = new import_vinyl_util4.StringReader(str);
+  const c = new import_vinyl_util5.StringReader(str);
   let current = {
     qName: "#document",
     namespaceMap: /* @__PURE__ */ new Map(),
@@ -419,7 +384,7 @@ function parseXml(str, handler) {
       if (name.qName !== current.qName)
         c.err(`Expected </${current.qName}> but was </${name.qName}>`);
       stack.pop();
-      current = (0, import_vinyl_util4.last)(stack);
+      current = (0, import_vinyl_util5.last)(stack);
       c.white();
       c.readChar(GT);
       try {
@@ -473,7 +438,7 @@ function parseXml(str, handler) {
       if (c.charIf(SLASH)) {
         c.readChar(GT);
         stack.pop();
-        current = (0, import_vinyl_util4.last)(stack);
+        current = (0, import_vinyl_util5.last)(stack);
         try {
           handler.endElement();
         } catch (e) {
@@ -495,7 +460,7 @@ function readAttributeValue(c) {
   if (!QUOTES.has(quote)) c.err(`Expected ' or "`);
   const value = c.substringUntil((charCode) => charCode === quote);
   c.readChar(quote);
-  return (0, import_vinyl_util4.decodeEntities)(value);
+  return (0, import_vinyl_util5.decodeEntities)(value);
 }
 function untilTagClose(c) {
   while (true) {
@@ -581,211 +546,35 @@ function xmlAttributes(reader, stackElement) {
       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
-var import_vinyl_util5 = require("@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 = import_vinyl_util5.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 import_vinyl_util5.ValidationError(
-      (0, import_vinyl_util5.substitute)(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 import_vinyl_util5.ValidationError(
-          (0, import_vinyl_util5.substitute)(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
-var import_vinyl_util6 = require("@amazon/vinyl-util");
-var EmptyRules = {
-  __type: /* @__PURE__ */ (0, import_vinyl_util6.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 import_vinyl_util6.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 import_vinyl_util6.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: (0, import_vinyl_util6.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: (0, import_vinyl_util6.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 import_vinyl_util6.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;
-      }
-    }
+    if (attributes[name.qName] != null)
+      reader.err(`Attribute '${name.qName}' is already specified.`);
+    attributes[name.qName] = { name, value };
   }
-  return {
-    __type: (0, import_vinyl_util6.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
-  };
+  return attributes;
 }
 
 // src/xml/ParseXmlHandlerImpl.ts
 var import_vinyl_util7 = require("@amazon/vinyl-util");
+
+// src/xml/XmlSchemaError.ts
+var import_vinyl_util6 = require("@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 import_vinyl_util6.ReportableError {
+  get [Symbol.toStringTag]() {
+    return "XmlSchemaError";
+  }
+  constructor(message) {
+    super(message, import_vinyl_util6.ErrorOrigin.PARSING);
+    Object.setPrototypeOf(this, _XmlSchemaError.prototype);
+  }
+};
+
+// src/xml/ParseXmlHandlerImpl.ts
 function getRule(name, rules) {
   return rules.get(xmlRuleKey(name.localPart, name.namespaceUri));
 }
@@ -965,12 +754,225 @@ var _XmlElementImpl = class _XmlElementImpl {
 };
 var XmlElementImpl = _XmlElementImpl;
 
-// src/xlink/actuateValidator.ts
-var import_vinyl_validation = require("@amazon/vinyl-validation");
+// src/xml/QName.ts
+function qName(localPart, prefix = null, namespaceUri = null) {
+  return {
+    localPart,
+    prefix,
+    namespaceUri,
+    qName: prefix ? `${prefix}:${localPart}` : localPart
+  };
+}
+
+// src/xml/stringifyXml.ts
 var import_vinyl_util8 = require("@amazon/vinyl-util");
-var actuateValidator = /* @__PURE__ */ (0, import_vinyl_validation.isOneOf)("onLoad", "onRequest");
-function assertActuateEnum(str) {
-  actuateValidator.assert(str, import_vinyl_util8.ErrorOrigin.PARSING);
-  return str;
+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 = (0, import_vinyl_util8.getOrSet)(this.usedPrefixes, namespaceUri, () => {
+      if (prefixMap.has(namespaceUri)) {
+        return prefixMap.get(namespaceUri);
+      }
+      return (0, import_vinyl_util8.substitute)(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 || !(0, import_vinyl_util8.equalDeep)(propertyValue, attributeRule.default)) {
+          str += ` ${this.qName(
+            attributeRule.localPart,
+            attributeRule.namespaceUri
+          )}="${(0, import_vinyl_util8.encodeEntities)(attributeValue)}"`;
+        }
+      } else {
+        if (attributeRule.required) {
+          throw new XmlSchemaError(
+            (0, import_vinyl_util8.substitute)(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(
+              (0, import_vinyl_util8.substitute)(xmlSchemaErrorLocale.atLeastElements, {
+                property: elementsRule.property,
+                expected: elementsRule.minOccurs,
+                actual: arr.length
+              })
+            );
+          }
+          if (elementsRule.maxOccurs != null && elementsRule.maxOccurs < arr.length) {
+            throw new XmlSchemaError(
+              (0, import_vinyl_util8.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
+            );
+          }
+        } else {
+          if (str) str += this.options.newline;
+          str += this.stringifyElement(child, elementsRule, state);
+        }
+      } else {
+        if (elementsRule.minOccurs > 0) {
+          throw new XmlSchemaError(
+            (0, import_vinyl_util8.substitute)(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);
 }
 //# sourceMappingURL=index.cjs.map