@amazon/vinyl-xml 1.0.0

package/dist/index.js

@@ -0,0 +1,986 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/xml/xmlRules.ts
+import {
+  parseDate,
+  stringifyDate,
+  parseBoolean,
+  stringify
+} from "@amazon/vinyl-util";
+var XmlRuleType = /* @__PURE__ */ ((XmlRuleType2) => {
+  XmlRuleType2["CHARACTERS"] = "characters";
+  XmlRuleType2["ATTRIBUTE"] = "attribute";
+  XmlRuleType2["ELEMENT"] = "element";
+  XmlRuleType2["ELEMENTS"] = "elements";
+  return XmlRuleType2;
+})(XmlRuleType || {});
+function element(rules, options) {
+  return __spreadProps(__spreadValues({
+    type: "element" /* ELEMENT */,
+    localPart: void 0,
+    namespaceUri: void 0,
+    required: false
+  }, options), {
+    rules
+  });
+}
+function elements(rules, options) {
+  return __spreadProps(__spreadValues({
+    type: "elements" /* ELEMENTS */,
+    localPart: void 0,
+    namespaceUri: void 0,
+    minOccurs: 0,
+    maxOccurs: null,
+    useEmptyArrays: false
+  }, options), {
+    rules
+  });
+}
+function characters(parse, stringify2) {
+  return { type: "characters" /* CHARACTERS */, parse, stringify: stringify2 };
+}
+var charactersString = /* @__PURE__ */ characters((i) => i, stringify);
+function attr(parse, stringify2, options) {
+  return __spreadProps(__spreadValues({
+    type: "attribute" /* ATTRIBUTE */,
+    localPart: void 0,
+    namespaceUri: null,
+    required: false,
+    default: void 0
+  }, options), {
+    parse,
+    stringify: stringify2
+  });
+}
+function attrString(options) {
+  return attr((i) => i, stringify, options);
+}
+function attrInt(options) {
+  return attr(parseInt, stringify, options);
+}
+function attrFloat(options) {
+  return attr(parseFloat, stringify, options);
+}
+function attrBoolean(options) {
+  return attr(parseBoolean, stringify, options);
+}
+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
+};
+var XmlWriter = class {
+  constructor(rules, options) {
+    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}>`;
+    } 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(
+            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(
+              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
+            );
+          }
+        } else {
+          if (str) str += this.options.newline;
+          str += this.stringifyElement(child, elementsRule, state);
+        }
+      } else {
+        if (elementsRule.minOccurs > 0) {
+          throw new XmlSchemaError(
+            substitute(xmlSchemaErrorLocale.atLeastElements, {
+              property: elementsRule.property,
+              expected: elementsRule.minOccurs,
+              actual: 0
+            })
+          );
+        }
+      }
+    });
+    return str;
+  }
+};
+var StringifyState = class _StringifyState {
+  constructor(depth = 0, xmlns = null, indent = "") {
+    this.depth = depth;
+    this.xmlns = xmlns;
+    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);
+}
+
+// src/xml/parseXml.ts
+import {
+  char,
+  decodeEntities,
+  last,
+  StringReader
+} from "@amazon/vinyl-util";
+var XMLNS = "http://www.w3.org/2000/xmlns/";
+var LT = /* @__PURE__ */ char("<");
+var GT = /* @__PURE__ */ char(">");
+var EQ = /* @__PURE__ */ char("=");
+var SLASH = /* @__PURE__ */ char("/");
+var COLON = /* @__PURE__ */ char(":");
+var QMARK = /* @__PURE__ */ char("?");
+var EXCL = /* @__PURE__ */ char("!");
+var APOS = /* @__PURE__ */ char("'");
+var QUOT = /* @__PURE__ */ char('"');
+var QUOTES = /* @__PURE__ */ new Set([APOS, QUOT]);
+function parseXml(str, handler) {
+  const c = new StringReader(str);
+  let current = {
+    qName: "#document",
+    namespaceMap: /* @__PURE__ */ new Map(),
+    defaultNamespaceUri: null
+  };
+  const stack = [current];
+  const namespaceLookup = (prefix) => {
+    if (!prefix) return current.defaultNamespaceUri;
+    for (let i = stack.length - 1; i >= 0; i--) {
+      const map = stack[i].namespaceMap;
+      if (map.has(prefix)) return stack[i].namespaceMap.get(prefix);
+    }
+    return null;
+  };
+  try {
+    handler.startDocument();
+  } catch (e) {
+    c.err(e.message);
+  }
+  while (c.hasNext()) {
+    const charsStart = c.untilChar(LT);
+    if (charsStart < c.position) {
+      const chars = str.substring(charsStart, c.position);
+      try {
+        handler.textNode(chars);
+      } catch (e) {
+        c.err(e.message);
+      }
+    }
+    if (!c.hasNext()) break;
+    c.next();
+    if (c.charIf(SLASH)) {
+      c.white();
+      const name = readQName(c);
+      if (name.qName !== current.qName)
+        c.err(`Expected </${current.qName}> but was </${name.qName}>`);
+      stack.pop();
+      current = last(stack);
+      c.white();
+      c.readChar(GT);
+      try {
+        handler.endElement();
+      } catch (e) {
+        c.err(e.message);
+      }
+    } else if (c.charIf(QMARK)) {
+      untilTagClose(c);
+    } else if (c.charIf(EXCL)) {
+      if (c.charIf(
+        45
+        /* - */
+      )) {
+        c.readChar(45);
+        c.untilString("-->");
+        c.read("-->");
+      } else if (c.stringIf("[CDATA[")) {
+        const charsStart2 = c.untilString("]]>");
+        try {
+          handler.cDataNode(str.substring(charsStart2, c.position));
+        } catch (e) {
+          c.err(e.message);
+        }
+        c.read("]]>");
+      } else {
+        untilTagClose(c);
+      }
+    } else {
+      const name = readQName(c);
+      current = {
+        qName: name.qName,
+        namespaceMap: /* @__PURE__ */ new Map(),
+        defaultNamespaceUri: current.defaultNamespaceUri
+      };
+      stack.push(current);
+      const attributes = xmlAttributes(c, current);
+      name.namespaceUri = namespaceLookup(name.prefix);
+      for (const attributesKey in attributes) {
+        const value = attributes[attributesKey];
+        const name2 = value.name;
+        if (name2.prefix && !name2.namespaceUri) {
+          name2.namespaceUri = namespaceLookup(name2.prefix);
+        }
+      }
+      try {
+        handler.startElement(name, attributes);
+      } catch (e) {
+        c.err(e.message);
+      }
+      if (c.charIf(SLASH)) {
+        c.readChar(GT);
+        stack.pop();
+        current = last(stack);
+        try {
+          handler.endElement();
+        } catch (e) {
+          c.err(e.message);
+        }
+      } else {
+        c.readChar(GT);
+      }
+    }
+  }
+  try {
+    return handler.endDocument();
+  } catch (e) {
+    return c.err(e.message);
+  }
+}
+function readAttributeValue(c) {
+  const quote = c.next();
+  if (!QUOTES.has(quote)) c.err(`Expected ' or "`);
+  const value = c.substringUntil((charCode) => charCode === quote);
+  c.readChar(quote);
+  return decodeEntities(value);
+}
+function untilTagClose(c) {
+  while (true) {
+    c.until((c2) => c2 === APOS || c2 === QUOT || c2 === GT);
+    const char2 = c.next();
+    if (QUOTES.has(char2)) {
+      c.untilChar(char2);
+      c.next();
+    } else {
+      break;
+    }
+  }
+}
+function isNameChar(charCode) {
+  if (charCode >= 97) {
+    if (charCode >= 183) {
+      if (charCode >= 768) {
+        if (charCode >= 8255) {
+          return charCode <= 8256;
+        } else {
+          return charCode <= 879;
+        }
+      } else {
+        return charCode === 183;
+      }
+    } else {
+      return charCode <= 122;
+    }
+  } else {
+    if (charCode >= 95) {
+      return charCode === 95;
+    } else {
+      if (charCode >= 65) {
+        return charCode <= 90;
+      } else {
+        if (charCode >= 45) {
+          if (charCode >= 48) {
+            return charCode <= 57;
+          } else {
+            return charCode <= 46;
+          }
+        } else {
+          return false;
+        }
+      }
+    }
+  }
+}
+function readQName(reader) {
+  const prefixOrLocalName = reader.substringWhile(isNameChar);
+  let prefix, localPart, name;
+  if (reader.charIf(COLON)) {
+    prefix = prefixOrLocalName;
+    localPart = reader.substringWhile(isNameChar);
+    name = `${prefix}:${localPart}`;
+  } else {
+    prefix = null;
+    localPart = prefixOrLocalName;
+    name = localPart;
+  }
+  return { prefix, localPart, qName: name, namespaceUri: null };
+}
+function xmlAttributes(reader, stackElement) {
+  const attributes = {};
+  while (true) {
+    reader.white();
+    if (!isNameChar(reader.peek)) break;
+    const name = readQName(reader);
+    reader.white();
+    let value = "";
+    if (reader.charIf(EQ)) {
+      reader.white();
+      value = readAttributeValue(reader);
+    } else {
+    }
+    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
+  };
+}
+
+// src/xml/ParseXmlHandlerImpl.ts
+import {
+  clone,
+  decodeEntities as decodeEntities2,
+  IllegalStateError,
+  last as last2,
+  substitute as substitute3,
+  toJson
+} from "@amazon/vinyl-util";
+function getRule(name, rules) {
+  return rules.get(xmlRuleKey(name.localPart, name.namespaceUri));
+}
+var ParseXmlHandlerImpl = class {
+  constructor(rules, options) {
+    this.rules = rules;
+    __publicField(this, "stack", []);
+    __publicField(this, "options");
+    __publicField(this, "busy", false);
+    this.options = __spreadValues({ validateRules: true }, options);
+  }
+  startDocument() {
+    if (this.busy)
+      throw new IllegalStateError("XML content handler is busy");
+    this.busy = true;
+    const rules = this.rules;
+    this.stack.push({
+      element: new XmlElementImpl(),
+      rules,
+      characters: ""
+    });
+  }
+  startElement(name, attributes) {
+    var _a2;
+    const parent = last2(this.stack);
+    let element2 = null;
+    const elementRule = getRule(name, parent.rules.elements);
+    const rules = (_a2 = elementRule == null ? void 0 : elementRule.rules()) != null ? _a2 : EmptyRules;
+    if (elementRule) {
+      const prop = elementRule.property;
+      element2 = new XmlElementImpl(parent.element);
+      if (elementRule.array) {
+        const arr = parent.element[prop];
+        if (Array.isArray(arr)) {
+          arr.push(element2);
+        } else {
+          parent.element[prop] = [element2];
+        }
+      } else {
+        if (parent.element[prop]) {
+          throw new XmlSchemaError(
+            `Expected single element with name ${name.qName}`
+          );
+        } else {
+          parent.element[prop] = element2;
+        }
+      }
+      const attributeRules = rules.attributes;
+      for (const k in attributes) {
+        const attribute = attributes[k];
+        const name2 = attribute.name;
+        const attributeRule = getRule(name2, attributeRules);
+        if (attributeRule) {
+          element2[attributeRule.property] = attributeRule.parse(
+            attribute.value
+          );
+        }
+      }
+      attributeRules.forEach((_value, key) => {
+        const rule = attributeRules.get(key);
+        if (!(rule.property in element2)) {
+          if (rule.default != null) {
+            element2[rule.property] = rule.default;
+          } else if (this.options.validateRules && rule.required) {
+            throw new XmlSchemaError(
+              substitute3(xmlSchemaErrorLocale.requiredAttribute, {
+                property: rule.property
+              })
+            );
+          }
+        }
+      });
+    }
+    this.stack.push({
+      element: element2,
+      rules,
+      characters: ""
+    });
+  }
+  textNode(str) {
+    const current = last2(this.stack);
+    if (!current.rules.characters) return;
+    current.characters += decodeEntities2(str.trim());
+  }
+  cDataNode(str) {
+    const current = last2(this.stack);
+    if (!current.rules.characters) return;
+    current.characters += str;
+  }
+  endElement() {
+    const lastEl = this.stack.pop();
+    const charactersRule = lastEl.rules.characters;
+    if (charactersRule)
+      lastEl.element[charactersRule.property] = charactersRule.parse(
+        lastEl.characters
+      );
+    lastEl.rules.elements.forEach((rule) => {
+      if (rule.array && !(rule.property in lastEl.element)) {
+        if (rule.useEmptyArrays) {
+          lastEl.element[rule.property] = [];
+        }
+      }
+    });
+    this.validate(lastEl);
+  }
+  endDocument() {
+    this.busy = false;
+    const last3 = this.stack.pop();
+    this.validate(last3);
+    return last3.element;
+  }
+  validate(current) {
+    if (!this.options.validateRules) return;
+    current.rules.elements.forEach((rule) => {
+      var _a2, _b;
+      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, {
+            property: rule.property,
+            expected: rule.minOccurs,
+            actual: length
+          })
+        );
+      }
+      if (rule.maxOccurs != null && length > rule.maxOccurs) {
+        throw new XmlSchemaError(
+          substitute3(xmlSchemaErrorLocale.atMostElements, {
+            property: rule.property,
+            expected: rule.maxOccurs,
+            actual: length
+          })
+        );
+      }
+    });
+  }
+};
+function parseXmlHandler(rules, options) {
+  return new ParseXmlHandlerImpl(mapXmlRules(rules), options);
+}
+var parentSymbol = /* @__PURE__ */ Symbol("parent");
+var _a;
+_a = parentSymbol;
+var _XmlElementImpl = class _XmlElementImpl {
+  constructor(parent = null) {
+    __publicField(this, _a);
+    this[parentSymbol] = parent;
+  }
+  get parent() {
+    return this[parentSymbol];
+  }
+  set parent(value) {
+    this[parentSymbol] = value;
+  }
+  clone() {
+    const out = new _XmlElementImpl(this.parent);
+    for (const key in this) {
+      const child = clone(this[key]);
+      if (Array.isArray(child)) {
+        for (const e of child) {
+          if (typeof e === "object" && "parent" in e) e.parent = out;
+        }
+      } else if (typeof child === "object" && "parent" in child) {
+        child.parent = out;
+      }
+      out[key] = child;
+    }
+    return out;
+  }
+  toJSON() {
+    const out = {};
+    for (const key in this) {
+      out[key] = toJson(this[key]);
+    }
+    return out;
+  }
+};
+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;
+}
+export {
+  EmptyRules,
+  ParseXmlHandlerImpl,
+  XMLNS,
+  XmlElementImpl,
+  XmlRuleType,
+  XmlSchemaError,
+  XmlWriter,
+  assertActuateEnum,
+  attr,
+  attrBoolean,
+  attrDateTime,
+  attrFloat,
+  attrInt,
+  attrString,
+  characters,
+  charactersString,
+  element,
+  elements,
+  isNameChar,
+  mapXmlRules,
+  mergeXmlRules,
+  parseXml,
+  parseXmlHandler,
+  qName,
+  readAttributeValue,
+  readQName,
+  stringifyXml,
+  untilTagClose,
+  xmlAttributes,
+  xmlRuleKey,
+  xmlSchemaErrorLocale
+};
+//# sourceMappingURL=index.js.map