@coana-tech/cli 14.8.6 → 14.8.7

package/cli.mjs

@@ -147941,6 +147941,4449 @@ var require_boolbase = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/defaults.js
+var require_defaults2 = __commonJS({
+  "../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/defaults.js"(exports2) {
+    (function() {
+      exports2.defaults = {
+        "0.1": {
+          explicitCharkey: false,
+          trim: true,
+          normalize: true,
+          normalizeTags: false,
+          attrkey: "@",
+          charkey: "#",
+          explicitArray: false,
+          ignoreAttrs: false,
+          mergeAttrs: false,
+          explicitRoot: false,
+          validator: null,
+          xmlns: false,
+          explicitChildren: false,
+          childkey: "@@",
+          charsAsChildren: false,
+          includeWhiteChars: false,
+          async: false,
+          strict: true,
+          attrNameProcessors: null,
+          attrValueProcessors: null,
+          tagNameProcessors: null,
+          valueProcessors: null,
+          emptyTag: ""
+        },
+        "0.2": {
+          explicitCharkey: false,
+          trim: false,
+          normalize: false,
+          normalizeTags: false,
+          attrkey: "$",
+          charkey: "_",
+          explicitArray: true,
+          ignoreAttrs: false,
+          mergeAttrs: false,
+          explicitRoot: true,
+          validator: null,
+          xmlns: false,
+          explicitChildren: false,
+          preserveChildrenOrder: false,
+          childkey: "$$",
+          charsAsChildren: false,
+          includeWhiteChars: false,
+          async: false,
+          strict: true,
+          attrNameProcessors: null,
+          attrValueProcessors: null,
+          tagNameProcessors: null,
+          valueProcessors: null,
+          rootName: "root",
+          xmldec: {
+            "version": "1.0",
+            "encoding": "UTF-8",
+            "standalone": true
+          },
+          doctype: null,
+          renderOpts: {
+            "pretty": true,
+            "indent": "  ",
+            "newline": "\n"
+          },
+          headless: false,
+          chunkSize: 1e4,
+          emptyTag: "",
+          cdata: false
+        }
+      };
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/Utility.js
+var require_Utility = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/Utility.js"(exports2, module2) {
+    (function() {
+      var assign, getValue, isArray2, isEmpty, isFunction2, isObject2, isPlainObject2, slice2 = [].slice, hasProp = {}.hasOwnProperty;
+      assign = function() {
+        var i7, key, len, source, sources, target;
+        target = arguments[0], sources = 2 <= arguments.length ? slice2.call(arguments, 1) : [];
+        if (isFunction2(Object.assign)) {
+          Object.assign.apply(null, arguments);
+        } else {
+          for (i7 = 0, len = sources.length; i7 < len; i7++) {
+            source = sources[i7];
+            if (source != null) {
+              for (key in source) {
+                if (!hasProp.call(source, key)) continue;
+                target[key] = source[key];
+              }
+            }
+          }
+        }
+        return target;
+      };
+      isFunction2 = function(val3) {
+        return !!val3 && Object.prototype.toString.call(val3) === "[object Function]";
+      };
+      isObject2 = function(val3) {
+        var ref;
+        return !!val3 && ((ref = typeof val3) === "function" || ref === "object");
+      };
+      isArray2 = function(val3) {
+        if (isFunction2(Array.isArray)) {
+          return Array.isArray(val3);
+        } else {
+          return Object.prototype.toString.call(val3) === "[object Array]";
+        }
+      };
+      isEmpty = function(val3) {
+        var key;
+        if (isArray2(val3)) {
+          return !val3.length;
+        } else {
+          for (key in val3) {
+            if (!hasProp.call(val3, key)) continue;
+            return false;
+          }
+          return true;
+        }
+      };
+      isPlainObject2 = function(val3) {
+        var ctor, proto;
+        return isObject2(val3) && (proto = Object.getPrototypeOf(val3)) && (ctor = proto.constructor) && typeof ctor === "function" && ctor instanceof ctor && Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object);
+      };
+      getValue = function(obj) {
+        if (isFunction2(obj.valueOf)) {
+          return obj.valueOf();
+        } else {
+          return obj;
+        }
+      };
+      module2.exports.assign = assign;
+      module2.exports.isFunction = isFunction2;
+      module2.exports.isObject = isObject2;
+      module2.exports.isArray = isArray2;
+      module2.exports.isEmpty = isEmpty;
+      module2.exports.isPlainObject = isPlainObject2;
+      module2.exports.getValue = getValue;
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDOMImplementation.js
+var require_XMLDOMImplementation = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDOMImplementation.js"(exports2, module2) {
+    (function() {
+      var XMLDOMImplementation;
+      module2.exports = XMLDOMImplementation = function() {
+        function XMLDOMImplementation2() {
+        }
+        XMLDOMImplementation2.prototype.hasFeature = function(feature, version3) {
+          return true;
+        };
+        XMLDOMImplementation2.prototype.createDocumentType = function(qualifiedName, publicId, systemId) {
+          throw new Error("This DOM method is not implemented.");
+        };
+        XMLDOMImplementation2.prototype.createDocument = function(namespaceURI, qualifiedName, doctype) {
+          throw new Error("This DOM method is not implemented.");
+        };
+        XMLDOMImplementation2.prototype.createHTMLDocument = function(title) {
+          throw new Error("This DOM method is not implemented.");
+        };
+        XMLDOMImplementation2.prototype.getFeature = function(feature, version3) {
+          throw new Error("This DOM method is not implemented.");
+        };
+        return XMLDOMImplementation2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDOMErrorHandler.js
+var require_XMLDOMErrorHandler = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDOMErrorHandler.js"(exports2, module2) {
+    (function() {
+      var XMLDOMErrorHandler;
+      module2.exports = XMLDOMErrorHandler = function() {
+        function XMLDOMErrorHandler2() {
+        }
+        XMLDOMErrorHandler2.prototype.handleError = function(error) {
+          throw new Error(error);
+        };
+        return XMLDOMErrorHandler2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDOMStringList.js
+var require_XMLDOMStringList = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDOMStringList.js"(exports2, module2) {
+    (function() {
+      var XMLDOMStringList;
+      module2.exports = XMLDOMStringList = function() {
+        function XMLDOMStringList2(arr) {
+          this.arr = arr || [];
+        }
+        Object.defineProperty(XMLDOMStringList2.prototype, "length", {
+          get: function() {
+            return this.arr.length;
+          }
+        });
+        XMLDOMStringList2.prototype.item = function(index2) {
+          return this.arr[index2] || null;
+        };
+        XMLDOMStringList2.prototype.contains = function(str) {
+          return this.arr.indexOf(str) !== -1;
+        };
+        return XMLDOMStringList2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDOMConfiguration.js
+var require_XMLDOMConfiguration = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDOMConfiguration.js"(exports2, module2) {
+    (function() {
+      var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList;
+      XMLDOMErrorHandler = require_XMLDOMErrorHandler();
+      XMLDOMStringList = require_XMLDOMStringList();
+      module2.exports = XMLDOMConfiguration = function() {
+        function XMLDOMConfiguration2() {
+          var clonedSelf;
+          this.defaultParams = {
+            "canonical-form": false,
+            "cdata-sections": false,
+            "comments": false,
+            "datatype-normalization": false,
+            "element-content-whitespace": true,
+            "entities": true,
+            "error-handler": new XMLDOMErrorHandler(),
+            "infoset": true,
+            "validate-if-schema": false,
+            "namespaces": true,
+            "namespace-declarations": true,
+            "normalize-characters": false,
+            "schema-location": "",
+            "schema-type": "",
+            "split-cdata-sections": true,
+            "validate": false,
+            "well-formed": true
+          };
+          this.params = clonedSelf = Object.create(this.defaultParams);
+        }
+        Object.defineProperty(XMLDOMConfiguration2.prototype, "parameterNames", {
+          get: function() {
+            return new XMLDOMStringList(Object.keys(this.defaultParams));
+          }
+        });
+        XMLDOMConfiguration2.prototype.getParameter = function(name) {
+          if (this.params.hasOwnProperty(name)) {
+            return this.params[name];
+          } else {
+            return null;
+          }
+        };
+        XMLDOMConfiguration2.prototype.canSetParameter = function(name, value) {
+          return true;
+        };
+        XMLDOMConfiguration2.prototype.setParameter = function(name, value) {
+          if (value != null) {
+            return this.params[name] = value;
+          } else {
+            return delete this.params[name];
+          }
+        };
+        return XMLDOMConfiguration2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/NodeType.js
+var require_NodeType = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/NodeType.js"(exports2, module2) {
+    (function() {
+      module2.exports = {
+        Element: 1,
+        Attribute: 2,
+        Text: 3,
+        CData: 4,
+        EntityReference: 5,
+        EntityDeclaration: 6,
+        ProcessingInstruction: 7,
+        Comment: 8,
+        Document: 9,
+        DocType: 10,
+        DocumentFragment: 11,
+        NotationDeclaration: 12,
+        Declaration: 201,
+        Raw: 202,
+        AttributeDeclaration: 203,
+        ElementDeclaration: 204,
+        Dummy: 205
+      };
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLAttribute.js
+var require_XMLAttribute = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLAttribute.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLAttribute, XMLNode;
+      NodeType = require_NodeType();
+      XMLNode = require_XMLNode();
+      module2.exports = XMLAttribute = function() {
+        function XMLAttribute2(parent2, name, value) {
+          this.parent = parent2;
+          if (this.parent) {
+            this.options = this.parent.options;
+            this.stringify = this.parent.stringify;
+          }
+          if (name == null) {
+            throw new Error("Missing attribute name. " + this.debugInfo(name));
+          }
+          this.name = this.stringify.name(name);
+          this.value = this.stringify.attValue(value);
+          this.type = NodeType.Attribute;
+          this.isId = false;
+          this.schemaTypeInfo = null;
+        }
+        Object.defineProperty(XMLAttribute2.prototype, "nodeType", {
+          get: function() {
+            return this.type;
+          }
+        });
+        Object.defineProperty(XMLAttribute2.prototype, "ownerElement", {
+          get: function() {
+            return this.parent;
+          }
+        });
+        Object.defineProperty(XMLAttribute2.prototype, "textContent", {
+          get: function() {
+            return this.value;
+          },
+          set: function(value) {
+            return this.value = value || "";
+          }
+        });
+        Object.defineProperty(XMLAttribute2.prototype, "namespaceURI", {
+          get: function() {
+            return "";
+          }
+        });
+        Object.defineProperty(XMLAttribute2.prototype, "prefix", {
+          get: function() {
+            return "";
+          }
+        });
+        Object.defineProperty(XMLAttribute2.prototype, "localName", {
+          get: function() {
+            return this.name;
+          }
+        });
+        Object.defineProperty(XMLAttribute2.prototype, "specified", {
+          get: function() {
+            return true;
+          }
+        });
+        XMLAttribute2.prototype.clone = function() {
+          return Object.create(this);
+        };
+        XMLAttribute2.prototype.toString = function(options) {
+          return this.options.writer.attribute(this, this.options.writer.filterOptions(options));
+        };
+        XMLAttribute2.prototype.debugInfo = function(name) {
+          name = name || this.name;
+          if (name == null) {
+            return "parent: <" + this.parent.name + ">";
+          } else {
+            return "attribute: {" + name + "}, parent: <" + this.parent.name + ">";
+          }
+        };
+        XMLAttribute2.prototype.isEqualNode = function(node) {
+          if (node.namespaceURI !== this.namespaceURI) {
+            return false;
+          }
+          if (node.prefix !== this.prefix) {
+            return false;
+          }
+          if (node.localName !== this.localName) {
+            return false;
+          }
+          if (node.value !== this.value) {
+            return false;
+          }
+          return true;
+        };
+        return XMLAttribute2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLNamedNodeMap.js
+var require_XMLNamedNodeMap = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLNamedNodeMap.js"(exports2, module2) {
+    (function() {
+      var XMLNamedNodeMap;
+      module2.exports = XMLNamedNodeMap = function() {
+        function XMLNamedNodeMap2(nodes) {
+          this.nodes = nodes;
+        }
+        Object.defineProperty(XMLNamedNodeMap2.prototype, "length", {
+          get: function() {
+            return Object.keys(this.nodes).length || 0;
+          }
+        });
+        XMLNamedNodeMap2.prototype.clone = function() {
+          return this.nodes = null;
+        };
+        XMLNamedNodeMap2.prototype.getNamedItem = function(name) {
+          return this.nodes[name];
+        };
+        XMLNamedNodeMap2.prototype.setNamedItem = function(node) {
+          var oldNode;
+          oldNode = this.nodes[node.nodeName];
+          this.nodes[node.nodeName] = node;
+          return oldNode || null;
+        };
+        XMLNamedNodeMap2.prototype.removeNamedItem = function(name) {
+          var oldNode;
+          oldNode = this.nodes[name];
+          delete this.nodes[name];
+          return oldNode || null;
+        };
+        XMLNamedNodeMap2.prototype.item = function(index2) {
+          return this.nodes[Object.keys(this.nodes)[index2]] || null;
+        };
+        XMLNamedNodeMap2.prototype.getNamedItemNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented.");
+        };
+        XMLNamedNodeMap2.prototype.setNamedItemNS = function(node) {
+          throw new Error("This DOM method is not implemented.");
+        };
+        XMLNamedNodeMap2.prototype.removeNamedItemNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented.");
+        };
+        return XMLNamedNodeMap2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLElement.js
+var require_XMLElement = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLElement.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLAttribute, XMLElement, XMLNamedNodeMap, XMLNode, getValue, isFunction2, isObject2, ref, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      ref = require_Utility(), isObject2 = ref.isObject, isFunction2 = ref.isFunction, getValue = ref.getValue;
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      XMLAttribute = require_XMLAttribute();
+      XMLNamedNodeMap = require_XMLNamedNodeMap();
+      module2.exports = XMLElement = function(superClass) {
+        extend2(XMLElement2, superClass);
+        function XMLElement2(parent2, name, attributes2) {
+          var child, j, len, ref1;
+          XMLElement2.__super__.constructor.call(this, parent2);
+          if (name == null) {
+            throw new Error("Missing element name. " + this.debugInfo());
+          }
+          this.name = this.stringify.name(name);
+          this.type = NodeType.Element;
+          this.attribs = {};
+          this.schemaTypeInfo = null;
+          if (attributes2 != null) {
+            this.attribute(attributes2);
+          }
+          if (parent2.type === NodeType.Document) {
+            this.isRoot = true;
+            this.documentObject = parent2;
+            parent2.rootObject = this;
+            if (parent2.children) {
+              ref1 = parent2.children;
+              for (j = 0, len = ref1.length; j < len; j++) {
+                child = ref1[j];
+                if (child.type === NodeType.DocType) {
+                  child.name = this.name;
+                  break;
+                }
+              }
+            }
+          }
+        }
+        Object.defineProperty(XMLElement2.prototype, "tagName", {
+          get: function() {
+            return this.name;
+          }
+        });
+        Object.defineProperty(XMLElement2.prototype, "namespaceURI", {
+          get: function() {
+            return "";
+          }
+        });
+        Object.defineProperty(XMLElement2.prototype, "prefix", {
+          get: function() {
+            return "";
+          }
+        });
+        Object.defineProperty(XMLElement2.prototype, "localName", {
+          get: function() {
+            return this.name;
+          }
+        });
+        Object.defineProperty(XMLElement2.prototype, "id", {
+          get: function() {
+            throw new Error("This DOM method is not implemented." + this.debugInfo());
+          }
+        });
+        Object.defineProperty(XMLElement2.prototype, "className", {
+          get: function() {
+            throw new Error("This DOM method is not implemented." + this.debugInfo());
+          }
+        });
+        Object.defineProperty(XMLElement2.prototype, "classList", {
+          get: function() {
+            throw new Error("This DOM method is not implemented." + this.debugInfo());
+          }
+        });
+        Object.defineProperty(XMLElement2.prototype, "attributes", {
+          get: function() {
+            if (!this.attributeMap || !this.attributeMap.nodes) {
+              this.attributeMap = new XMLNamedNodeMap(this.attribs);
+            }
+            return this.attributeMap;
+          }
+        });
+        XMLElement2.prototype.clone = function() {
+          var att, attName, clonedSelf, ref1;
+          clonedSelf = Object.create(this);
+          if (clonedSelf.isRoot) {
+            clonedSelf.documentObject = null;
+          }
+          clonedSelf.attribs = {};
+          ref1 = this.attribs;
+          for (attName in ref1) {
+            if (!hasProp.call(ref1, attName)) continue;
+            att = ref1[attName];
+            clonedSelf.attribs[attName] = att.clone();
+          }
+          clonedSelf.children = [];
+          this.children.forEach(function(child) {
+            var clonedChild;
+            clonedChild = child.clone();
+            clonedChild.parent = clonedSelf;
+            return clonedSelf.children.push(clonedChild);
+          });
+          return clonedSelf;
+        };
+        XMLElement2.prototype.attribute = function(name, value) {
+          var attName, attValue;
+          if (name != null) {
+            name = getValue(name);
+          }
+          if (isObject2(name)) {
+            for (attName in name) {
+              if (!hasProp.call(name, attName)) continue;
+              attValue = name[attName];
+              this.attribute(attName, attValue);
+            }
+          } else {
+            if (isFunction2(value)) {
+              value = value.apply();
+            }
+            if (this.options.keepNullAttributes && value == null) {
+              this.attribs[name] = new XMLAttribute(this, name, "");
+            } else if (value != null) {
+              this.attribs[name] = new XMLAttribute(this, name, value);
+            }
+          }
+          return this;
+        };
+        XMLElement2.prototype.removeAttribute = function(name) {
+          var attName, j, len;
+          if (name == null) {
+            throw new Error("Missing attribute name. " + this.debugInfo());
+          }
+          name = getValue(name);
+          if (Array.isArray(name)) {
+            for (j = 0, len = name.length; j < len; j++) {
+              attName = name[j];
+              delete this.attribs[attName];
+            }
+          } else {
+            delete this.attribs[name];
+          }
+          return this;
+        };
+        XMLElement2.prototype.toString = function(options) {
+          return this.options.writer.element(this, this.options.writer.filterOptions(options));
+        };
+        XMLElement2.prototype.att = function(name, value) {
+          return this.attribute(name, value);
+        };
+        XMLElement2.prototype.a = function(name, value) {
+          return this.attribute(name, value);
+        };
+        XMLElement2.prototype.getAttribute = function(name) {
+          if (this.attribs.hasOwnProperty(name)) {
+            return this.attribs[name].value;
+          } else {
+            return null;
+          }
+        };
+        XMLElement2.prototype.setAttribute = function(name, value) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.getAttributeNode = function(name) {
+          if (this.attribs.hasOwnProperty(name)) {
+            return this.attribs[name];
+          } else {
+            return null;
+          }
+        };
+        XMLElement2.prototype.setAttributeNode = function(newAttr) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.removeAttributeNode = function(oldAttr) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.getElementsByTagName = function(name) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.getAttributeNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.removeAttributeNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.getAttributeNodeNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.setAttributeNodeNS = function(newAttr) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.hasAttribute = function(name) {
+          return this.attribs.hasOwnProperty(name);
+        };
+        XMLElement2.prototype.hasAttributeNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.setIdAttribute = function(name, isId) {
+          if (this.attribs.hasOwnProperty(name)) {
+            return this.attribs[name].isId;
+          } else {
+            return isId;
+          }
+        };
+        XMLElement2.prototype.setIdAttributeNS = function(namespaceURI, localName, isId) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.setIdAttributeNode = function(idAttr, isId) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.getElementsByTagName = function(tagname) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.getElementsByClassName = function(classNames) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLElement2.prototype.isEqualNode = function(node) {
+          var i7, j, ref1;
+          if (!XMLElement2.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
+            return false;
+          }
+          if (node.namespaceURI !== this.namespaceURI) {
+            return false;
+          }
+          if (node.prefix !== this.prefix) {
+            return false;
+          }
+          if (node.localName !== this.localName) {
+            return false;
+          }
+          if (node.attribs.length !== this.attribs.length) {
+            return false;
+          }
+          for (i7 = j = 0, ref1 = this.attribs.length - 1; 0 <= ref1 ? j <= ref1 : j >= ref1; i7 = 0 <= ref1 ? ++j : --j) {
+            if (!this.attribs[i7].isEqualNode(node.attribs[i7])) {
+              return false;
+            }
+          }
+          return true;
+        };
+        return XMLElement2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLCharacterData.js
+var require_XMLCharacterData = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLCharacterData.js"(exports2, module2) {
+    (function() {
+      var XMLCharacterData, XMLNode, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      XMLNode = require_XMLNode();
+      module2.exports = XMLCharacterData = function(superClass) {
+        extend2(XMLCharacterData2, superClass);
+        function XMLCharacterData2(parent2) {
+          XMLCharacterData2.__super__.constructor.call(this, parent2);
+          this.value = "";
+        }
+        Object.defineProperty(XMLCharacterData2.prototype, "data", {
+          get: function() {
+            return this.value;
+          },
+          set: function(value) {
+            return this.value = value || "";
+          }
+        });
+        Object.defineProperty(XMLCharacterData2.prototype, "length", {
+          get: function() {
+            return this.value.length;
+          }
+        });
+        Object.defineProperty(XMLCharacterData2.prototype, "textContent", {
+          get: function() {
+            return this.value;
+          },
+          set: function(value) {
+            return this.value = value || "";
+          }
+        });
+        XMLCharacterData2.prototype.clone = function() {
+          return Object.create(this);
+        };
+        XMLCharacterData2.prototype.substringData = function(offset, count) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLCharacterData2.prototype.appendData = function(arg) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLCharacterData2.prototype.insertData = function(offset, arg) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLCharacterData2.prototype.deleteData = function(offset, count) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLCharacterData2.prototype.replaceData = function(offset, count, arg) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLCharacterData2.prototype.isEqualNode = function(node) {
+          if (!XMLCharacterData2.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
+            return false;
+          }
+          if (node.data !== this.data) {
+            return false;
+          }
+          return true;
+        };
+        return XMLCharacterData2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLCData.js
+var require_XMLCData = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLCData.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLCData, XMLCharacterData, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      NodeType = require_NodeType();
+      XMLCharacterData = require_XMLCharacterData();
+      module2.exports = XMLCData = function(superClass) {
+        extend2(XMLCData2, superClass);
+        function XMLCData2(parent2, text3) {
+          XMLCData2.__super__.constructor.call(this, parent2);
+          if (text3 == null) {
+            throw new Error("Missing CDATA text. " + this.debugInfo());
+          }
+          this.name = "#cdata-section";
+          this.type = NodeType.CData;
+          this.value = this.stringify.cdata(text3);
+        }
+        XMLCData2.prototype.clone = function() {
+          return Object.create(this);
+        };
+        XMLCData2.prototype.toString = function(options) {
+          return this.options.writer.cdata(this, this.options.writer.filterOptions(options));
+        };
+        return XMLCData2;
+      }(XMLCharacterData);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLComment.js
+var require_XMLComment = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLComment.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLCharacterData, XMLComment, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      NodeType = require_NodeType();
+      XMLCharacterData = require_XMLCharacterData();
+      module2.exports = XMLComment = function(superClass) {
+        extend2(XMLComment2, superClass);
+        function XMLComment2(parent2, text3) {
+          XMLComment2.__super__.constructor.call(this, parent2);
+          if (text3 == null) {
+            throw new Error("Missing comment text. " + this.debugInfo());
+          }
+          this.name = "#comment";
+          this.type = NodeType.Comment;
+          this.value = this.stringify.comment(text3);
+        }
+        XMLComment2.prototype.clone = function() {
+          return Object.create(this);
+        };
+        XMLComment2.prototype.toString = function(options) {
+          return this.options.writer.comment(this, this.options.writer.filterOptions(options));
+        };
+        return XMLComment2;
+      }(XMLCharacterData);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDeclaration.js
+var require_XMLDeclaration = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDeclaration.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLDeclaration, XMLNode, isObject2, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      isObject2 = require_Utility().isObject;
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      module2.exports = XMLDeclaration = function(superClass) {
+        extend2(XMLDeclaration2, superClass);
+        function XMLDeclaration2(parent2, version3, encoding, standalone) {
+          var ref;
+          XMLDeclaration2.__super__.constructor.call(this, parent2);
+          if (isObject2(version3)) {
+            ref = version3, version3 = ref.version, encoding = ref.encoding, standalone = ref.standalone;
+          }
+          if (!version3) {
+            version3 = "1.0";
+          }
+          this.type = NodeType.Declaration;
+          this.version = this.stringify.xmlVersion(version3);
+          if (encoding != null) {
+            this.encoding = this.stringify.xmlEncoding(encoding);
+          }
+          if (standalone != null) {
+            this.standalone = this.stringify.xmlStandalone(standalone);
+          }
+        }
+        XMLDeclaration2.prototype.toString = function(options) {
+          return this.options.writer.declaration(this, this.options.writer.filterOptions(options));
+        };
+        return XMLDeclaration2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDTDAttList.js
+var require_XMLDTDAttList = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDTDAttList.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLDTDAttList, XMLNode, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      module2.exports = XMLDTDAttList = function(superClass) {
+        extend2(XMLDTDAttList2, superClass);
+        function XMLDTDAttList2(parent2, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+          XMLDTDAttList2.__super__.constructor.call(this, parent2);
+          if (elementName == null) {
+            throw new Error("Missing DTD element name. " + this.debugInfo());
+          }
+          if (attributeName == null) {
+            throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName));
+          }
+          if (!attributeType) {
+            throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName));
+          }
+          if (!defaultValueType) {
+            throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName));
+          }
+          if (defaultValueType.indexOf("#") !== 0) {
+            defaultValueType = "#" + defaultValueType;
+          }
+          if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {
+            throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. " + this.debugInfo(elementName));
+          }
+          if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
+            throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName));
+          }
+          this.elementName = this.stringify.name(elementName);
+          this.type = NodeType.AttributeDeclaration;
+          this.attributeName = this.stringify.name(attributeName);
+          this.attributeType = this.stringify.dtdAttType(attributeType);
+          if (defaultValue) {
+            this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
+          }
+          this.defaultValueType = defaultValueType;
+        }
+        XMLDTDAttList2.prototype.toString = function(options) {
+          return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));
+        };
+        return XMLDTDAttList2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDTDEntity.js
+var require_XMLDTDEntity = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDTDEntity.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLDTDEntity, XMLNode, isObject2, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      isObject2 = require_Utility().isObject;
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      module2.exports = XMLDTDEntity = function(superClass) {
+        extend2(XMLDTDEntity2, superClass);
+        function XMLDTDEntity2(parent2, pe, name, value) {
+          XMLDTDEntity2.__super__.constructor.call(this, parent2);
+          if (name == null) {
+            throw new Error("Missing DTD entity name. " + this.debugInfo(name));
+          }
+          if (value == null) {
+            throw new Error("Missing DTD entity value. " + this.debugInfo(name));
+          }
+          this.pe = !!pe;
+          this.name = this.stringify.name(name);
+          this.type = NodeType.EntityDeclaration;
+          if (!isObject2(value)) {
+            this.value = this.stringify.dtdEntityValue(value);
+            this.internal = true;
+          } else {
+            if (!value.pubID && !value.sysID) {
+              throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name));
+            }
+            if (value.pubID && !value.sysID) {
+              throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name));
+            }
+            this.internal = false;
+            if (value.pubID != null) {
+              this.pubID = this.stringify.dtdPubID(value.pubID);
+            }
+            if (value.sysID != null) {
+              this.sysID = this.stringify.dtdSysID(value.sysID);
+            }
+            if (value.nData != null) {
+              this.nData = this.stringify.dtdNData(value.nData);
+            }
+            if (this.pe && this.nData) {
+              throw new Error("Notation declaration is not allowed in a parameter entity. " + this.debugInfo(name));
+            }
+          }
+        }
+        Object.defineProperty(XMLDTDEntity2.prototype, "publicId", {
+          get: function() {
+            return this.pubID;
+          }
+        });
+        Object.defineProperty(XMLDTDEntity2.prototype, "systemId", {
+          get: function() {
+            return this.sysID;
+          }
+        });
+        Object.defineProperty(XMLDTDEntity2.prototype, "notationName", {
+          get: function() {
+            return this.nData || null;
+          }
+        });
+        Object.defineProperty(XMLDTDEntity2.prototype, "inputEncoding", {
+          get: function() {
+            return null;
+          }
+        });
+        Object.defineProperty(XMLDTDEntity2.prototype, "xmlEncoding", {
+          get: function() {
+            return null;
+          }
+        });
+        Object.defineProperty(XMLDTDEntity2.prototype, "xmlVersion", {
+          get: function() {
+            return null;
+          }
+        });
+        XMLDTDEntity2.prototype.toString = function(options) {
+          return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));
+        };
+        return XMLDTDEntity2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDTDElement.js
+var require_XMLDTDElement = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDTDElement.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLDTDElement, XMLNode, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      module2.exports = XMLDTDElement = function(superClass) {
+        extend2(XMLDTDElement2, superClass);
+        function XMLDTDElement2(parent2, name, value) {
+          XMLDTDElement2.__super__.constructor.call(this, parent2);
+          if (name == null) {
+            throw new Error("Missing DTD element name. " + this.debugInfo());
+          }
+          if (!value) {
+            value = "(#PCDATA)";
+          }
+          if (Array.isArray(value)) {
+            value = "(" + value.join(",") + ")";
+          }
+          this.name = this.stringify.name(name);
+          this.type = NodeType.ElementDeclaration;
+          this.value = this.stringify.dtdElementValue(value);
+        }
+        XMLDTDElement2.prototype.toString = function(options) {
+          return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));
+        };
+        return XMLDTDElement2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDTDNotation.js
+var require_XMLDTDNotation = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDTDNotation.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLDTDNotation, XMLNode, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      module2.exports = XMLDTDNotation = function(superClass) {
+        extend2(XMLDTDNotation2, superClass);
+        function XMLDTDNotation2(parent2, name, value) {
+          XMLDTDNotation2.__super__.constructor.call(this, parent2);
+          if (name == null) {
+            throw new Error("Missing DTD notation name. " + this.debugInfo(name));
+          }
+          if (!value.pubID && !value.sysID) {
+            throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name));
+          }
+          this.name = this.stringify.name(name);
+          this.type = NodeType.NotationDeclaration;
+          if (value.pubID != null) {
+            this.pubID = this.stringify.dtdPubID(value.pubID);
+          }
+          if (value.sysID != null) {
+            this.sysID = this.stringify.dtdSysID(value.sysID);
+          }
+        }
+        Object.defineProperty(XMLDTDNotation2.prototype, "publicId", {
+          get: function() {
+            return this.pubID;
+          }
+        });
+        Object.defineProperty(XMLDTDNotation2.prototype, "systemId", {
+          get: function() {
+            return this.sysID;
+          }
+        });
+        XMLDTDNotation2.prototype.toString = function(options) {
+          return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
+        };
+        return XMLDTDNotation2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDocType.js
+var require_XMLDocType = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDocType.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject2, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      isObject2 = require_Utility().isObject;
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      XMLDTDAttList = require_XMLDTDAttList();
+      XMLDTDEntity = require_XMLDTDEntity();
+      XMLDTDElement = require_XMLDTDElement();
+      XMLDTDNotation = require_XMLDTDNotation();
+      XMLNamedNodeMap = require_XMLNamedNodeMap();
+      module2.exports = XMLDocType = function(superClass) {
+        extend2(XMLDocType2, superClass);
+        function XMLDocType2(parent2, pubID, sysID) {
+          var child, i7, len, ref, ref1, ref2;
+          XMLDocType2.__super__.constructor.call(this, parent2);
+          this.type = NodeType.DocType;
+          if (parent2.children) {
+            ref = parent2.children;
+            for (i7 = 0, len = ref.length; i7 < len; i7++) {
+              child = ref[i7];
+              if (child.type === NodeType.Element) {
+                this.name = child.name;
+                break;
+              }
+            }
+          }
+          this.documentObject = parent2;
+          if (isObject2(pubID)) {
+            ref1 = pubID, pubID = ref1.pubID, sysID = ref1.sysID;
+          }
+          if (sysID == null) {
+            ref2 = [pubID, sysID], sysID = ref2[0], pubID = ref2[1];
+          }
+          if (pubID != null) {
+            this.pubID = this.stringify.dtdPubID(pubID);
+          }
+          if (sysID != null) {
+            this.sysID = this.stringify.dtdSysID(sysID);
+          }
+        }
+        Object.defineProperty(XMLDocType2.prototype, "entities", {
+          get: function() {
+            var child, i7, len, nodes, ref;
+            nodes = {};
+            ref = this.children;
+            for (i7 = 0, len = ref.length; i7 < len; i7++) {
+              child = ref[i7];
+              if (child.type === NodeType.EntityDeclaration && !child.pe) {
+                nodes[child.name] = child;
+              }
+            }
+            return new XMLNamedNodeMap(nodes);
+          }
+        });
+        Object.defineProperty(XMLDocType2.prototype, "notations", {
+          get: function() {
+            var child, i7, len, nodes, ref;
+            nodes = {};
+            ref = this.children;
+            for (i7 = 0, len = ref.length; i7 < len; i7++) {
+              child = ref[i7];
+              if (child.type === NodeType.NotationDeclaration) {
+                nodes[child.name] = child;
+              }
+            }
+            return new XMLNamedNodeMap(nodes);
+          }
+        });
+        Object.defineProperty(XMLDocType2.prototype, "publicId", {
+          get: function() {
+            return this.pubID;
+          }
+        });
+        Object.defineProperty(XMLDocType2.prototype, "systemId", {
+          get: function() {
+            return this.sysID;
+          }
+        });
+        Object.defineProperty(XMLDocType2.prototype, "internalSubset", {
+          get: function() {
+            throw new Error("This DOM method is not implemented." + this.debugInfo());
+          }
+        });
+        XMLDocType2.prototype.element = function(name, value) {
+          var child;
+          child = new XMLDTDElement(this, name, value);
+          this.children.push(child);
+          return this;
+        };
+        XMLDocType2.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+          var child;
+          child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
+          this.children.push(child);
+          return this;
+        };
+        XMLDocType2.prototype.entity = function(name, value) {
+          var child;
+          child = new XMLDTDEntity(this, false, name, value);
+          this.children.push(child);
+          return this;
+        };
+        XMLDocType2.prototype.pEntity = function(name, value) {
+          var child;
+          child = new XMLDTDEntity(this, true, name, value);
+          this.children.push(child);
+          return this;
+        };
+        XMLDocType2.prototype.notation = function(name, value) {
+          var child;
+          child = new XMLDTDNotation(this, name, value);
+          this.children.push(child);
+          return this;
+        };
+        XMLDocType2.prototype.toString = function(options) {
+          return this.options.writer.docType(this, this.options.writer.filterOptions(options));
+        };
+        XMLDocType2.prototype.ele = function(name, value) {
+          return this.element(name, value);
+        };
+        XMLDocType2.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+          return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
+        };
+        XMLDocType2.prototype.ent = function(name, value) {
+          return this.entity(name, value);
+        };
+        XMLDocType2.prototype.pent = function(name, value) {
+          return this.pEntity(name, value);
+        };
+        XMLDocType2.prototype.not = function(name, value) {
+          return this.notation(name, value);
+        };
+        XMLDocType2.prototype.up = function() {
+          return this.root() || this.documentObject;
+        };
+        XMLDocType2.prototype.isEqualNode = function(node) {
+          if (!XMLDocType2.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
+            return false;
+          }
+          if (node.name !== this.name) {
+            return false;
+          }
+          if (node.publicId !== this.publicId) {
+            return false;
+          }
+          if (node.systemId !== this.systemId) {
+            return false;
+          }
+          return true;
+        };
+        return XMLDocType2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLRaw.js
+var require_XMLRaw = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLRaw.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLNode, XMLRaw, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      NodeType = require_NodeType();
+      XMLNode = require_XMLNode();
+      module2.exports = XMLRaw = function(superClass) {
+        extend2(XMLRaw2, superClass);
+        function XMLRaw2(parent2, text3) {
+          XMLRaw2.__super__.constructor.call(this, parent2);
+          if (text3 == null) {
+            throw new Error("Missing raw text. " + this.debugInfo());
+          }
+          this.type = NodeType.Raw;
+          this.value = this.stringify.raw(text3);
+        }
+        XMLRaw2.prototype.clone = function() {
+          return Object.create(this);
+        };
+        XMLRaw2.prototype.toString = function(options) {
+          return this.options.writer.raw(this, this.options.writer.filterOptions(options));
+        };
+        return XMLRaw2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLText.js
+var require_XMLText = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLText.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLCharacterData, XMLText, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      NodeType = require_NodeType();
+      XMLCharacterData = require_XMLCharacterData();
+      module2.exports = XMLText = function(superClass) {
+        extend2(XMLText2, superClass);
+        function XMLText2(parent2, text3) {
+          XMLText2.__super__.constructor.call(this, parent2);
+          if (text3 == null) {
+            throw new Error("Missing element text. " + this.debugInfo());
+          }
+          this.name = "#text";
+          this.type = NodeType.Text;
+          this.value = this.stringify.text(text3);
+        }
+        Object.defineProperty(XMLText2.prototype, "isElementContentWhitespace", {
+          get: function() {
+            throw new Error("This DOM method is not implemented." + this.debugInfo());
+          }
+        });
+        Object.defineProperty(XMLText2.prototype, "wholeText", {
+          get: function() {
+            var next2, prev2, str;
+            str = "";
+            prev2 = this.previousSibling;
+            while (prev2) {
+              str = prev2.data + str;
+              prev2 = prev2.previousSibling;
+            }
+            str += this.data;
+            next2 = this.nextSibling;
+            while (next2) {
+              str = str + next2.data;
+              next2 = next2.nextSibling;
+            }
+            return str;
+          }
+        });
+        XMLText2.prototype.clone = function() {
+          return Object.create(this);
+        };
+        XMLText2.prototype.toString = function(options) {
+          return this.options.writer.text(this, this.options.writer.filterOptions(options));
+        };
+        XMLText2.prototype.splitText = function(offset) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLText2.prototype.replaceWholeText = function(content) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        return XMLText2;
+      }(XMLCharacterData);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLProcessingInstruction.js
+var require_XMLProcessingInstruction = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLProcessingInstruction.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLCharacterData, XMLProcessingInstruction, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      NodeType = require_NodeType();
+      XMLCharacterData = require_XMLCharacterData();
+      module2.exports = XMLProcessingInstruction = function(superClass) {
+        extend2(XMLProcessingInstruction2, superClass);
+        function XMLProcessingInstruction2(parent2, target, value) {
+          XMLProcessingInstruction2.__super__.constructor.call(this, parent2);
+          if (target == null) {
+            throw new Error("Missing instruction target. " + this.debugInfo());
+          }
+          this.type = NodeType.ProcessingInstruction;
+          this.target = this.stringify.insTarget(target);
+          this.name = this.target;
+          if (value) {
+            this.value = this.stringify.insValue(value);
+          }
+        }
+        XMLProcessingInstruction2.prototype.clone = function() {
+          return Object.create(this);
+        };
+        XMLProcessingInstruction2.prototype.toString = function(options) {
+          return this.options.writer.processingInstruction(this, this.options.writer.filterOptions(options));
+        };
+        XMLProcessingInstruction2.prototype.isEqualNode = function(node) {
+          if (!XMLProcessingInstruction2.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
+            return false;
+          }
+          if (node.target !== this.target) {
+            return false;
+          }
+          return true;
+        };
+        return XMLProcessingInstruction2;
+      }(XMLCharacterData);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDummy.js
+var require_XMLDummy = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDummy.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLDummy, XMLNode, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      module2.exports = XMLDummy = function(superClass) {
+        extend2(XMLDummy2, superClass);
+        function XMLDummy2(parent2) {
+          XMLDummy2.__super__.constructor.call(this, parent2);
+          this.type = NodeType.Dummy;
+        }
+        XMLDummy2.prototype.clone = function() {
+          return Object.create(this);
+        };
+        XMLDummy2.prototype.toString = function(options) {
+          return "";
+        };
+        return XMLDummy2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLNodeList.js
+var require_XMLNodeList = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLNodeList.js"(exports2, module2) {
+    (function() {
+      var XMLNodeList;
+      module2.exports = XMLNodeList = function() {
+        function XMLNodeList2(nodes) {
+          this.nodes = nodes;
+        }
+        Object.defineProperty(XMLNodeList2.prototype, "length", {
+          get: function() {
+            return this.nodes.length || 0;
+          }
+        });
+        XMLNodeList2.prototype.clone = function() {
+          return this.nodes = null;
+        };
+        XMLNodeList2.prototype.item = function(index2) {
+          return this.nodes[index2] || null;
+        };
+        return XMLNodeList2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/DocumentPosition.js
+var require_DocumentPosition = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/DocumentPosition.js"(exports2, module2) {
+    (function() {
+      module2.exports = {
+        Disconnected: 1,
+        Preceding: 2,
+        Following: 4,
+        Contains: 8,
+        ContainedBy: 16,
+        ImplementationSpecific: 32
+      };
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLNode.js
+var require_XMLNode = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLNode.js"(exports2, module2) {
+    (function() {
+      var DocumentPosition2, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction2, isObject2, ref1, hasProp = {}.hasOwnProperty;
+      ref1 = require_Utility(), isObject2 = ref1.isObject, isFunction2 = ref1.isFunction, isEmpty = ref1.isEmpty, getValue = ref1.getValue;
+      XMLElement = null;
+      XMLCData = null;
+      XMLComment = null;
+      XMLDeclaration = null;
+      XMLDocType = null;
+      XMLRaw = null;
+      XMLText = null;
+      XMLProcessingInstruction = null;
+      XMLDummy = null;
+      NodeType = null;
+      XMLNodeList = null;
+      XMLNamedNodeMap = null;
+      DocumentPosition2 = null;
+      module2.exports = XMLNode = function() {
+        function XMLNode2(parent1) {
+          this.parent = parent1;
+          if (this.parent) {
+            this.options = this.parent.options;
+            this.stringify = this.parent.stringify;
+          }
+          this.value = null;
+          this.children = [];
+          this.baseURI = null;
+          if (!XMLElement) {
+            XMLElement = require_XMLElement();
+            XMLCData = require_XMLCData();
+            XMLComment = require_XMLComment();
+            XMLDeclaration = require_XMLDeclaration();
+            XMLDocType = require_XMLDocType();
+            XMLRaw = require_XMLRaw();
+            XMLText = require_XMLText();
+            XMLProcessingInstruction = require_XMLProcessingInstruction();
+            XMLDummy = require_XMLDummy();
+            NodeType = require_NodeType();
+            XMLNodeList = require_XMLNodeList();
+            XMLNamedNodeMap = require_XMLNamedNodeMap();
+            DocumentPosition2 = require_DocumentPosition();
+          }
+        }
+        Object.defineProperty(XMLNode2.prototype, "nodeName", {
+          get: function() {
+            return this.name;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "nodeType", {
+          get: function() {
+            return this.type;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "nodeValue", {
+          get: function() {
+            return this.value;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "parentNode", {
+          get: function() {
+            return this.parent;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "childNodes", {
+          get: function() {
+            if (!this.childNodeList || !this.childNodeList.nodes) {
+              this.childNodeList = new XMLNodeList(this.children);
+            }
+            return this.childNodeList;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "firstChild", {
+          get: function() {
+            return this.children[0] || null;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "lastChild", {
+          get: function() {
+            return this.children[this.children.length - 1] || null;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "previousSibling", {
+          get: function() {
+            var i7;
+            i7 = this.parent.children.indexOf(this);
+            return this.parent.children[i7 - 1] || null;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "nextSibling", {
+          get: function() {
+            var i7;
+            i7 = this.parent.children.indexOf(this);
+            return this.parent.children[i7 + 1] || null;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "ownerDocument", {
+          get: function() {
+            return this.document() || null;
+          }
+        });
+        Object.defineProperty(XMLNode2.prototype, "textContent", {
+          get: function() {
+            var child, j, len, ref2, str;
+            if (this.nodeType === NodeType.Element || this.nodeType === NodeType.DocumentFragment) {
+              str = "";
+              ref2 = this.children;
+              for (j = 0, len = ref2.length; j < len; j++) {
+                child = ref2[j];
+                if (child.textContent) {
+                  str += child.textContent;
+                }
+              }
+              return str;
+            } else {
+              return null;
+            }
+          },
+          set: function(value) {
+            throw new Error("This DOM method is not implemented." + this.debugInfo());
+          }
+        });
+        XMLNode2.prototype.setParent = function(parent2) {
+          var child, j, len, ref2, results;
+          this.parent = parent2;
+          if (parent2) {
+            this.options = parent2.options;
+            this.stringify = parent2.stringify;
+          }
+          ref2 = this.children;
+          results = [];
+          for (j = 0, len = ref2.length; j < len; j++) {
+            child = ref2[j];
+            results.push(child.setParent(this));
+          }
+          return results;
+        };
+        XMLNode2.prototype.element = function(name, attributes2, text3) {
+          var childNode, item, j, k, key, lastChild, len, len1, ref2, ref3, val3;
+          lastChild = null;
+          if (attributes2 === null && text3 == null) {
+            ref2 = [{}, null], attributes2 = ref2[0], text3 = ref2[1];
+          }
+          if (attributes2 == null) {
+            attributes2 = {};
+          }
+          attributes2 = getValue(attributes2);
+          if (!isObject2(attributes2)) {
+            ref3 = [attributes2, text3], text3 = ref3[0], attributes2 = ref3[1];
+          }
+          if (name != null) {
+            name = getValue(name);
+          }
+          if (Array.isArray(name)) {
+            for (j = 0, len = name.length; j < len; j++) {
+              item = name[j];
+              lastChild = this.element(item);
+            }
+          } else if (isFunction2(name)) {
+            lastChild = this.element(name.apply());
+          } else if (isObject2(name)) {
+            for (key in name) {
+              if (!hasProp.call(name, key)) continue;
+              val3 = name[key];
+              if (isFunction2(val3)) {
+                val3 = val3.apply();
+              }
+              if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
+                lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val3);
+              } else if (!this.options.separateArrayItems && Array.isArray(val3) && isEmpty(val3)) {
+                lastChild = this.dummy();
+              } else if (isObject2(val3) && isEmpty(val3)) {
+                lastChild = this.element(key);
+              } else if (!this.options.keepNullNodes && val3 == null) {
+                lastChild = this.dummy();
+              } else if (!this.options.separateArrayItems && Array.isArray(val3)) {
+                for (k = 0, len1 = val3.length; k < len1; k++) {
+                  item = val3[k];
+                  childNode = {};
+                  childNode[key] = item;
+                  lastChild = this.element(childNode);
+                }
+              } else if (isObject2(val3)) {
+                if (!this.options.ignoreDecorators && this.stringify.convertTextKey && key.indexOf(this.stringify.convertTextKey) === 0) {
+                  lastChild = this.element(val3);
+                } else {
+                  lastChild = this.element(key);
+                  lastChild.element(val3);
+                }
+              } else {
+                lastChild = this.element(key, val3);
+              }
+            }
+          } else if (!this.options.keepNullNodes && text3 === null) {
+            lastChild = this.dummy();
+          } else {
+            if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
+              lastChild = this.text(text3);
+            } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
+              lastChild = this.cdata(text3);
+            } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
+              lastChild = this.comment(text3);
+            } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
+              lastChild = this.raw(text3);
+            } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) {
+              lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text3);
+            } else {
+              lastChild = this.node(name, attributes2, text3);
+            }
+          }
+          if (lastChild == null) {
+            throw new Error("Could not create any elements with: " + name + ". " + this.debugInfo());
+          }
+          return lastChild;
+        };
+        XMLNode2.prototype.insertBefore = function(name, attributes2, text3) {
+          var child, i7, newChild, refChild, removed;
+          if (name != null ? name.type : void 0) {
+            newChild = name;
+            refChild = attributes2;
+            newChild.setParent(this);
+            if (refChild) {
+              i7 = children.indexOf(refChild);
+              removed = children.splice(i7);
+              children.push(newChild);
+              Array.prototype.push.apply(children, removed);
+            } else {
+              children.push(newChild);
+            }
+            return newChild;
+          } else {
+            if (this.isRoot) {
+              throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
+            }
+            i7 = this.parent.children.indexOf(this);
+            removed = this.parent.children.splice(i7);
+            child = this.parent.element(name, attributes2, text3);
+            Array.prototype.push.apply(this.parent.children, removed);
+            return child;
+          }
+        };
+        XMLNode2.prototype.insertAfter = function(name, attributes2, text3) {
+          var child, i7, removed;
+          if (this.isRoot) {
+            throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
+          }
+          i7 = this.parent.children.indexOf(this);
+          removed = this.parent.children.splice(i7 + 1);
+          child = this.parent.element(name, attributes2, text3);
+          Array.prototype.push.apply(this.parent.children, removed);
+          return child;
+        };
+        XMLNode2.prototype.remove = function() {
+          var i7, ref2;
+          if (this.isRoot) {
+            throw new Error("Cannot remove the root element. " + this.debugInfo());
+          }
+          i7 = this.parent.children.indexOf(this);
+          [].splice.apply(this.parent.children, [i7, i7 - i7 + 1].concat(ref2 = [])), ref2;
+          return this.parent;
+        };
+        XMLNode2.prototype.node = function(name, attributes2, text3) {
+          var child, ref2;
+          if (name != null) {
+            name = getValue(name);
+          }
+          attributes2 || (attributes2 = {});
+          attributes2 = getValue(attributes2);
+          if (!isObject2(attributes2)) {
+            ref2 = [attributes2, text3], text3 = ref2[0], attributes2 = ref2[1];
+          }
+          child = new XMLElement(this, name, attributes2);
+          if (text3 != null) {
+            child.text(text3);
+          }
+          this.children.push(child);
+          return child;
+        };
+        XMLNode2.prototype.text = function(value) {
+          var child;
+          if (isObject2(value)) {
+            this.element(value);
+          }
+          child = new XMLText(this, value);
+          this.children.push(child);
+          return this;
+        };
+        XMLNode2.prototype.cdata = function(value) {
+          var child;
+          child = new XMLCData(this, value);
+          this.children.push(child);
+          return this;
+        };
+        XMLNode2.prototype.comment = function(value) {
+          var child;
+          child = new XMLComment(this, value);
+          this.children.push(child);
+          return this;
+        };
+        XMLNode2.prototype.commentBefore = function(value) {
+          var child, i7, removed;
+          i7 = this.parent.children.indexOf(this);
+          removed = this.parent.children.splice(i7);
+          child = this.parent.comment(value);
+          Array.prototype.push.apply(this.parent.children, removed);
+          return this;
+        };
+        XMLNode2.prototype.commentAfter = function(value) {
+          var child, i7, removed;
+          i7 = this.parent.children.indexOf(this);
+          removed = this.parent.children.splice(i7 + 1);
+          child = this.parent.comment(value);
+          Array.prototype.push.apply(this.parent.children, removed);
+          return this;
+        };
+        XMLNode2.prototype.raw = function(value) {
+          var child;
+          child = new XMLRaw(this, value);
+          this.children.push(child);
+          return this;
+        };
+        XMLNode2.prototype.dummy = function() {
+          var child;
+          child = new XMLDummy(this);
+          return child;
+        };
+        XMLNode2.prototype.instruction = function(target, value) {
+          var insTarget, insValue, instruction, j, len;
+          if (target != null) {
+            target = getValue(target);
+          }
+          if (value != null) {
+            value = getValue(value);
+          }
+          if (Array.isArray(target)) {
+            for (j = 0, len = target.length; j < len; j++) {
+              insTarget = target[j];
+              this.instruction(insTarget);
+            }
+          } else if (isObject2(target)) {
+            for (insTarget in target) {
+              if (!hasProp.call(target, insTarget)) continue;
+              insValue = target[insTarget];
+              this.instruction(insTarget, insValue);
+            }
+          } else {
+            if (isFunction2(value)) {
+              value = value.apply();
+            }
+            instruction = new XMLProcessingInstruction(this, target, value);
+            this.children.push(instruction);
+          }
+          return this;
+        };
+        XMLNode2.prototype.instructionBefore = function(target, value) {
+          var child, i7, removed;
+          i7 = this.parent.children.indexOf(this);
+          removed = this.parent.children.splice(i7);
+          child = this.parent.instruction(target, value);
+          Array.prototype.push.apply(this.parent.children, removed);
+          return this;
+        };
+        XMLNode2.prototype.instructionAfter = function(target, value) {
+          var child, i7, removed;
+          i7 = this.parent.children.indexOf(this);
+          removed = this.parent.children.splice(i7 + 1);
+          child = this.parent.instruction(target, value);
+          Array.prototype.push.apply(this.parent.children, removed);
+          return this;
+        };
+        XMLNode2.prototype.declaration = function(version3, encoding, standalone) {
+          var doc, xmldec;
+          doc = this.document();
+          xmldec = new XMLDeclaration(doc, version3, encoding, standalone);
+          if (doc.children.length === 0) {
+            doc.children.unshift(xmldec);
+          } else if (doc.children[0].type === NodeType.Declaration) {
+            doc.children[0] = xmldec;
+          } else {
+            doc.children.unshift(xmldec);
+          }
+          return doc.root() || doc;
+        };
+        XMLNode2.prototype.dtd = function(pubID, sysID) {
+          var child, doc, doctype, i7, j, k, len, len1, ref2, ref3;
+          doc = this.document();
+          doctype = new XMLDocType(doc, pubID, sysID);
+          ref2 = doc.children;
+          for (i7 = j = 0, len = ref2.length; j < len; i7 = ++j) {
+            child = ref2[i7];
+            if (child.type === NodeType.DocType) {
+              doc.children[i7] = doctype;
+              return doctype;
+            }
+          }
+          ref3 = doc.children;
+          for (i7 = k = 0, len1 = ref3.length; k < len1; i7 = ++k) {
+            child = ref3[i7];
+            if (child.isRoot) {
+              doc.children.splice(i7, 0, doctype);
+              return doctype;
+            }
+          }
+          doc.children.push(doctype);
+          return doctype;
+        };
+        XMLNode2.prototype.up = function() {
+          if (this.isRoot) {
+            throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
+          }
+          return this.parent;
+        };
+        XMLNode2.prototype.root = function() {
+          var node;
+          node = this;
+          while (node) {
+            if (node.type === NodeType.Document) {
+              return node.rootObject;
+            } else if (node.isRoot) {
+              return node;
+            } else {
+              node = node.parent;
+            }
+          }
+        };
+        XMLNode2.prototype.document = function() {
+          var node;
+          node = this;
+          while (node) {
+            if (node.type === NodeType.Document) {
+              return node;
+            } else {
+              node = node.parent;
+            }
+          }
+        };
+        XMLNode2.prototype.end = function(options) {
+          return this.document().end(options);
+        };
+        XMLNode2.prototype.prev = function() {
+          var i7;
+          i7 = this.parent.children.indexOf(this);
+          if (i7 < 1) {
+            throw new Error("Already at the first node. " + this.debugInfo());
+          }
+          return this.parent.children[i7 - 1];
+        };
+        XMLNode2.prototype.next = function() {
+          var i7;
+          i7 = this.parent.children.indexOf(this);
+          if (i7 === -1 || i7 === this.parent.children.length - 1) {
+            throw new Error("Already at the last node. " + this.debugInfo());
+          }
+          return this.parent.children[i7 + 1];
+        };
+        XMLNode2.prototype.importDocument = function(doc) {
+          var clonedRoot;
+          clonedRoot = doc.root().clone();
+          clonedRoot.parent = this;
+          clonedRoot.isRoot = false;
+          this.children.push(clonedRoot);
+          return this;
+        };
+        XMLNode2.prototype.debugInfo = function(name) {
+          var ref2, ref3;
+          name = name || this.name;
+          if (name == null && !((ref2 = this.parent) != null ? ref2.name : void 0)) {
+            return "";
+          } else if (name == null) {
+            return "parent: <" + this.parent.name + ">";
+          } else if (!((ref3 = this.parent) != null ? ref3.name : void 0)) {
+            return "node: <" + name + ">";
+          } else {
+            return "node: <" + name + ">, parent: <" + this.parent.name + ">";
+          }
+        };
+        XMLNode2.prototype.ele = function(name, attributes2, text3) {
+          return this.element(name, attributes2, text3);
+        };
+        XMLNode2.prototype.nod = function(name, attributes2, text3) {
+          return this.node(name, attributes2, text3);
+        };
+        XMLNode2.prototype.txt = function(value) {
+          return this.text(value);
+        };
+        XMLNode2.prototype.dat = function(value) {
+          return this.cdata(value);
+        };
+        XMLNode2.prototype.com = function(value) {
+          return this.comment(value);
+        };
+        XMLNode2.prototype.ins = function(target, value) {
+          return this.instruction(target, value);
+        };
+        XMLNode2.prototype.doc = function() {
+          return this.document();
+        };
+        XMLNode2.prototype.dec = function(version3, encoding, standalone) {
+          return this.declaration(version3, encoding, standalone);
+        };
+        XMLNode2.prototype.e = function(name, attributes2, text3) {
+          return this.element(name, attributes2, text3);
+        };
+        XMLNode2.prototype.n = function(name, attributes2, text3) {
+          return this.node(name, attributes2, text3);
+        };
+        XMLNode2.prototype.t = function(value) {
+          return this.text(value);
+        };
+        XMLNode2.prototype.d = function(value) {
+          return this.cdata(value);
+        };
+        XMLNode2.prototype.c = function(value) {
+          return this.comment(value);
+        };
+        XMLNode2.prototype.r = function(value) {
+          return this.raw(value);
+        };
+        XMLNode2.prototype.i = function(target, value) {
+          return this.instruction(target, value);
+        };
+        XMLNode2.prototype.u = function() {
+          return this.up();
+        };
+        XMLNode2.prototype.importXMLBuilder = function(doc) {
+          return this.importDocument(doc);
+        };
+        XMLNode2.prototype.replaceChild = function(newChild, oldChild) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.removeChild = function(oldChild) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.appendChild = function(newChild) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.hasChildNodes = function() {
+          return this.children.length !== 0;
+        };
+        XMLNode2.prototype.cloneNode = function(deep) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.normalize = function() {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.isSupported = function(feature, version3) {
+          return true;
+        };
+        XMLNode2.prototype.hasAttributes = function() {
+          return this.attribs.length !== 0;
+        };
+        XMLNode2.prototype.compareDocumentPosition = function(other) {
+          var ref, res;
+          ref = this;
+          if (ref === other) {
+            return 0;
+          } else if (this.document() !== other.document()) {
+            res = DocumentPosition2.Disconnected | DocumentPosition2.ImplementationSpecific;
+            if (Math.random() < 0.5) {
+              res |= DocumentPosition2.Preceding;
+            } else {
+              res |= DocumentPosition2.Following;
+            }
+            return res;
+          } else if (ref.isAncestor(other)) {
+            return DocumentPosition2.Contains | DocumentPosition2.Preceding;
+          } else if (ref.isDescendant(other)) {
+            return DocumentPosition2.Contains | DocumentPosition2.Following;
+          } else if (ref.isPreceding(other)) {
+            return DocumentPosition2.Preceding;
+          } else {
+            return DocumentPosition2.Following;
+          }
+        };
+        XMLNode2.prototype.isSameNode = function(other) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.lookupPrefix = function(namespaceURI) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.isDefaultNamespace = function(namespaceURI) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.lookupNamespaceURI = function(prefix) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.isEqualNode = function(node) {
+          var i7, j, ref2;
+          if (node.nodeType !== this.nodeType) {
+            return false;
+          }
+          if (node.children.length !== this.children.length) {
+            return false;
+          }
+          for (i7 = j = 0, ref2 = this.children.length - 1; 0 <= ref2 ? j <= ref2 : j >= ref2; i7 = 0 <= ref2 ? ++j : --j) {
+            if (!this.children[i7].isEqualNode(node.children[i7])) {
+              return false;
+            }
+          }
+          return true;
+        };
+        XMLNode2.prototype.getFeature = function(feature, version3) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.setUserData = function(key, data2, handler) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.getUserData = function(key) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLNode2.prototype.contains = function(other) {
+          if (!other) {
+            return false;
+          }
+          return other === this || this.isDescendant(other);
+        };
+        XMLNode2.prototype.isDescendant = function(node) {
+          var child, isDescendantChild, j, len, ref2;
+          ref2 = this.children;
+          for (j = 0, len = ref2.length; j < len; j++) {
+            child = ref2[j];
+            if (node === child) {
+              return true;
+            }
+            isDescendantChild = child.isDescendant(node);
+            if (isDescendantChild) {
+              return true;
+            }
+          }
+          return false;
+        };
+        XMLNode2.prototype.isAncestor = function(node) {
+          return node.isDescendant(this);
+        };
+        XMLNode2.prototype.isPreceding = function(node) {
+          var nodePos, thisPos;
+          nodePos = this.treePosition(node);
+          thisPos = this.treePosition(this);
+          if (nodePos === -1 || thisPos === -1) {
+            return false;
+          } else {
+            return nodePos < thisPos;
+          }
+        };
+        XMLNode2.prototype.isFollowing = function(node) {
+          var nodePos, thisPos;
+          nodePos = this.treePosition(node);
+          thisPos = this.treePosition(this);
+          if (nodePos === -1 || thisPos === -1) {
+            return false;
+          } else {
+            return nodePos > thisPos;
+          }
+        };
+        XMLNode2.prototype.treePosition = function(node) {
+          var found, pos;
+          pos = 0;
+          found = false;
+          this.foreachTreeNode(this.document(), function(childNode) {
+            pos++;
+            if (!found && childNode === node) {
+              return found = true;
+            }
+          });
+          if (found) {
+            return pos;
+          } else {
+            return -1;
+          }
+        };
+        XMLNode2.prototype.foreachTreeNode = function(node, func) {
+          var child, j, len, ref2, res;
+          node || (node = this.document());
+          ref2 = node.children;
+          for (j = 0, len = ref2.length; j < len; j++) {
+            child = ref2[j];
+            if (res = func(child)) {
+              return res;
+            } else {
+              res = this.foreachTreeNode(child, func);
+              if (res) {
+                return res;
+              }
+            }
+          }
+        };
+        return XMLNode2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLStringifier.js
+var require_XMLStringifier = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLStringifier.js"(exports2, module2) {
+    (function() {
+      var XMLStringifier, bind2 = function(fn2, me) {
+        return function() {
+          return fn2.apply(me, arguments);
+        };
+      }, hasProp = {}.hasOwnProperty;
+      module2.exports = XMLStringifier = function() {
+        function XMLStringifier2(options) {
+          this.assertLegalName = bind2(this.assertLegalName, this);
+          this.assertLegalChar = bind2(this.assertLegalChar, this);
+          var key, ref, value;
+          options || (options = {});
+          this.options = options;
+          if (!this.options.version) {
+            this.options.version = "1.0";
+          }
+          ref = options.stringify || {};
+          for (key in ref) {
+            if (!hasProp.call(ref, key)) continue;
+            value = ref[key];
+            this[key] = value;
+          }
+        }
+        XMLStringifier2.prototype.name = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalName("" + val3 || "");
+        };
+        XMLStringifier2.prototype.text = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar(this.textEscape("" + val3 || ""));
+        };
+        XMLStringifier2.prototype.cdata = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          val3 = "" + val3 || "";
+          val3 = val3.replace("]]>", "]]]]><![CDATA[>");
+          return this.assertLegalChar(val3);
+        };
+        XMLStringifier2.prototype.comment = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          val3 = "" + val3 || "";
+          if (val3.match(/--/)) {
+            throw new Error("Comment text cannot contain double-hypen: " + val3);
+          }
+          return this.assertLegalChar(val3);
+        };
+        XMLStringifier2.prototype.raw = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return "" + val3 || "";
+        };
+        XMLStringifier2.prototype.attValue = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar(this.attEscape(val3 = "" + val3 || ""));
+        };
+        XMLStringifier2.prototype.insTarget = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar("" + val3 || "");
+        };
+        XMLStringifier2.prototype.insValue = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          val3 = "" + val3 || "";
+          if (val3.match(/\?>/)) {
+            throw new Error("Invalid processing instruction value: " + val3);
+          }
+          return this.assertLegalChar(val3);
+        };
+        XMLStringifier2.prototype.xmlVersion = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          val3 = "" + val3 || "";
+          if (!val3.match(/1\.[0-9]+/)) {
+            throw new Error("Invalid version number: " + val3);
+          }
+          return val3;
+        };
+        XMLStringifier2.prototype.xmlEncoding = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          val3 = "" + val3 || "";
+          if (!val3.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) {
+            throw new Error("Invalid encoding: " + val3);
+          }
+          return this.assertLegalChar(val3);
+        };
+        XMLStringifier2.prototype.xmlStandalone = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          if (val3) {
+            return "yes";
+          } else {
+            return "no";
+          }
+        };
+        XMLStringifier2.prototype.dtdPubID = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar("" + val3 || "");
+        };
+        XMLStringifier2.prototype.dtdSysID = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar("" + val3 || "");
+        };
+        XMLStringifier2.prototype.dtdElementValue = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar("" + val3 || "");
+        };
+        XMLStringifier2.prototype.dtdAttType = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar("" + val3 || "");
+        };
+        XMLStringifier2.prototype.dtdAttDefault = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar("" + val3 || "");
+        };
+        XMLStringifier2.prototype.dtdEntityValue = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar("" + val3 || "");
+        };
+        XMLStringifier2.prototype.dtdNData = function(val3) {
+          if (this.options.noValidation) {
+            return val3;
+          }
+          return this.assertLegalChar("" + val3 || "");
+        };
+        XMLStringifier2.prototype.convertAttKey = "@";
+        XMLStringifier2.prototype.convertPIKey = "?";
+        XMLStringifier2.prototype.convertTextKey = "#text";
+        XMLStringifier2.prototype.convertCDataKey = "#cdata";
+        XMLStringifier2.prototype.convertCommentKey = "#comment";
+        XMLStringifier2.prototype.convertRawKey = "#raw";
+        XMLStringifier2.prototype.assertLegalChar = function(str) {
+          var regex, res;
+          if (this.options.noValidation) {
+            return str;
+          }
+          regex = "";
+          if (this.options.version === "1.0") {
+            regex = /[\0-\x08\x0B\f\x0E-\x1F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+            if (res = str.match(regex)) {
+              throw new Error("Invalid character in string: " + str + " at index " + res.index);
+            }
+          } else if (this.options.version === "1.1") {
+            regex = /[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+            if (res = str.match(regex)) {
+              throw new Error("Invalid character in string: " + str + " at index " + res.index);
+            }
+          }
+          return str;
+        };
+        XMLStringifier2.prototype.assertLegalName = function(str) {
+          var regex;
+          if (this.options.noValidation) {
+            return str;
+          }
+          this.assertLegalChar(str);
+          regex = /^([:A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])([\x2D\.0-:A-Z_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*$/;
+          if (!str.match(regex)) {
+            throw new Error("Invalid character in name");
+          }
+          return str;
+        };
+        XMLStringifier2.prototype.textEscape = function(str) {
+          var ampregex;
+          if (this.options.noValidation) {
+            return str;
+          }
+          ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
+          return str.replace(ampregex, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#xD;");
+        };
+        XMLStringifier2.prototype.attEscape = function(str) {
+          var ampregex;
+          if (this.options.noValidation) {
+            return str;
+          }
+          ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
+          return str.replace(ampregex, "&amp;").replace(/</g, "&lt;").replace(/"/g, "&quot;").replace(/\t/g, "&#x9;").replace(/\n/g, "&#xA;").replace(/\r/g, "&#xD;");
+        };
+        return XMLStringifier2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/WriterState.js
+var require_WriterState = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/WriterState.js"(exports2, module2) {
+    (function() {
+      module2.exports = {
+        None: 0,
+        OpenTag: 1,
+        InsideTag: 2,
+        CloseTag: 3
+      };
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLWriterBase.js
+var require_XMLWriterBase = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLWriterBase.js"(exports2, module2) {
+    (function() {
+      var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign, hasProp = {}.hasOwnProperty;
+      assign = require_Utility().assign;
+      NodeType = require_NodeType();
+      XMLDeclaration = require_XMLDeclaration();
+      XMLDocType = require_XMLDocType();
+      XMLCData = require_XMLCData();
+      XMLComment = require_XMLComment();
+      XMLElement = require_XMLElement();
+      XMLRaw = require_XMLRaw();
+      XMLText = require_XMLText();
+      XMLProcessingInstruction = require_XMLProcessingInstruction();
+      XMLDummy = require_XMLDummy();
+      XMLDTDAttList = require_XMLDTDAttList();
+      XMLDTDElement = require_XMLDTDElement();
+      XMLDTDEntity = require_XMLDTDEntity();
+      XMLDTDNotation = require_XMLDTDNotation();
+      WriterState = require_WriterState();
+      module2.exports = XMLWriterBase = function() {
+        function XMLWriterBase2(options) {
+          var key, ref, value;
+          options || (options = {});
+          this.options = options;
+          ref = options.writer || {};
+          for (key in ref) {
+            if (!hasProp.call(ref, key)) continue;
+            value = ref[key];
+            this["_" + key] = this[key];
+            this[key] = value;
+          }
+        }
+        XMLWriterBase2.prototype.filterOptions = function(options) {
+          var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6;
+          options || (options = {});
+          options = assign({}, this.options, options);
+          filteredOptions = {
+            writer: this
+          };
+          filteredOptions.pretty = options.pretty || false;
+          filteredOptions.allowEmpty = options.allowEmpty || false;
+          filteredOptions.indent = (ref = options.indent) != null ? ref : "  ";
+          filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : "\n";
+          filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0;
+          filteredOptions.dontPrettyTextNodes = (ref3 = (ref4 = options.dontPrettyTextNodes) != null ? ref4 : options.dontprettytextnodes) != null ? ref3 : 0;
+          filteredOptions.spaceBeforeSlash = (ref5 = (ref6 = options.spaceBeforeSlash) != null ? ref6 : options.spacebeforeslash) != null ? ref5 : "";
+          if (filteredOptions.spaceBeforeSlash === true) {
+            filteredOptions.spaceBeforeSlash = " ";
+          }
+          filteredOptions.suppressPrettyCount = 0;
+          filteredOptions.user = {};
+          filteredOptions.state = WriterState.None;
+          return filteredOptions;
+        };
+        XMLWriterBase2.prototype.indent = function(node, options, level) {
+          var indentLevel;
+          if (!options.pretty || options.suppressPrettyCount) {
+            return "";
+          } else if (options.pretty) {
+            indentLevel = (level || 0) + options.offset + 1;
+            if (indentLevel > 0) {
+              return new Array(indentLevel).join(options.indent);
+            }
+          }
+          return "";
+        };
+        XMLWriterBase2.prototype.endline = function(node, options, level) {
+          if (!options.pretty || options.suppressPrettyCount) {
+            return "";
+          } else {
+            return options.newline;
+          }
+        };
+        XMLWriterBase2.prototype.attribute = function(att, options, level) {
+          var r2;
+          this.openAttribute(att, options, level);
+          r2 = " " + att.name + '="' + att.value + '"';
+          this.closeAttribute(att, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.cdata = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level) + "<![CDATA[";
+          options.state = WriterState.InsideTag;
+          r2 += node.value;
+          options.state = WriterState.CloseTag;
+          r2 += "]]>" + this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.comment = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level) + "<!-- ";
+          options.state = WriterState.InsideTag;
+          r2 += node.value;
+          options.state = WriterState.CloseTag;
+          r2 += " -->" + this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.declaration = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level) + "<?xml";
+          options.state = WriterState.InsideTag;
+          r2 += ' version="' + node.version + '"';
+          if (node.encoding != null) {
+            r2 += ' encoding="' + node.encoding + '"';
+          }
+          if (node.standalone != null) {
+            r2 += ' standalone="' + node.standalone + '"';
+          }
+          options.state = WriterState.CloseTag;
+          r2 += options.spaceBeforeSlash + "?>";
+          r2 += this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.docType = function(node, options, level) {
+          var child, i7, len, r2, ref;
+          level || (level = 0);
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level);
+          r2 += "<!DOCTYPE " + node.root().name;
+          if (node.pubID && node.sysID) {
+            r2 += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
+          } else if (node.sysID) {
+            r2 += ' SYSTEM "' + node.sysID + '"';
+          }
+          if (node.children.length > 0) {
+            r2 += " [";
+            r2 += this.endline(node, options, level);
+            options.state = WriterState.InsideTag;
+            ref = node.children;
+            for (i7 = 0, len = ref.length; i7 < len; i7++) {
+              child = ref[i7];
+              r2 += this.writeChildNode(child, options, level + 1);
+            }
+            options.state = WriterState.CloseTag;
+            r2 += "]";
+          }
+          options.state = WriterState.CloseTag;
+          r2 += options.spaceBeforeSlash + ">";
+          r2 += this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.element = function(node, options, level) {
+          var att, child, childNodeCount, firstChildNode, i7, j, len, len1, name, prettySuppressed, r2, ref, ref1, ref2;
+          level || (level = 0);
+          prettySuppressed = false;
+          r2 = "";
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 += this.indent(node, options, level) + "<" + node.name;
+          ref = node.attribs;
+          for (name in ref) {
+            if (!hasProp.call(ref, name)) continue;
+            att = ref[name];
+            r2 += this.attribute(att, options, level);
+          }
+          childNodeCount = node.children.length;
+          firstChildNode = childNodeCount === 0 ? null : node.children[0];
+          if (childNodeCount === 0 || node.children.every(function(e) {
+            return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === "";
+          })) {
+            if (options.allowEmpty) {
+              r2 += ">";
+              options.state = WriterState.CloseTag;
+              r2 += "</" + node.name + ">" + this.endline(node, options, level);
+            } else {
+              options.state = WriterState.CloseTag;
+              r2 += options.spaceBeforeSlash + "/>" + this.endline(node, options, level);
+            }
+          } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && firstChildNode.value != null) {
+            r2 += ">";
+            options.state = WriterState.InsideTag;
+            options.suppressPrettyCount++;
+            prettySuppressed = true;
+            r2 += this.writeChildNode(firstChildNode, options, level + 1);
+            options.suppressPrettyCount--;
+            prettySuppressed = false;
+            options.state = WriterState.CloseTag;
+            r2 += "</" + node.name + ">" + this.endline(node, options, level);
+          } else {
+            if (options.dontPrettyTextNodes) {
+              ref1 = node.children;
+              for (i7 = 0, len = ref1.length; i7 < len; i7++) {
+                child = ref1[i7];
+                if ((child.type === NodeType.Text || child.type === NodeType.Raw) && child.value != null) {
+                  options.suppressPrettyCount++;
+                  prettySuppressed = true;
+                  break;
+                }
+              }
+            }
+            r2 += ">" + this.endline(node, options, level);
+            options.state = WriterState.InsideTag;
+            ref2 = node.children;
+            for (j = 0, len1 = ref2.length; j < len1; j++) {
+              child = ref2[j];
+              r2 += this.writeChildNode(child, options, level + 1);
+            }
+            options.state = WriterState.CloseTag;
+            r2 += this.indent(node, options, level) + "</" + node.name + ">";
+            if (prettySuppressed) {
+              options.suppressPrettyCount--;
+            }
+            r2 += this.endline(node, options, level);
+            options.state = WriterState.None;
+          }
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.writeChildNode = function(node, options, level) {
+          switch (node.type) {
+            case NodeType.CData:
+              return this.cdata(node, options, level);
+            case NodeType.Comment:
+              return this.comment(node, options, level);
+            case NodeType.Element:
+              return this.element(node, options, level);
+            case NodeType.Raw:
+              return this.raw(node, options, level);
+            case NodeType.Text:
+              return this.text(node, options, level);
+            case NodeType.ProcessingInstruction:
+              return this.processingInstruction(node, options, level);
+            case NodeType.Dummy:
+              return "";
+            case NodeType.Declaration:
+              return this.declaration(node, options, level);
+            case NodeType.DocType:
+              return this.docType(node, options, level);
+            case NodeType.AttributeDeclaration:
+              return this.dtdAttList(node, options, level);
+            case NodeType.ElementDeclaration:
+              return this.dtdElement(node, options, level);
+            case NodeType.EntityDeclaration:
+              return this.dtdEntity(node, options, level);
+            case NodeType.NotationDeclaration:
+              return this.dtdNotation(node, options, level);
+            default:
+              throw new Error("Unknown XML node type: " + node.constructor.name);
+          }
+        };
+        XMLWriterBase2.prototype.processingInstruction = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level) + "<?";
+          options.state = WriterState.InsideTag;
+          r2 += node.target;
+          if (node.value) {
+            r2 += " " + node.value;
+          }
+          options.state = WriterState.CloseTag;
+          r2 += options.spaceBeforeSlash + "?>";
+          r2 += this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.raw = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level);
+          options.state = WriterState.InsideTag;
+          r2 += node.value;
+          options.state = WriterState.CloseTag;
+          r2 += this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.text = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level);
+          options.state = WriterState.InsideTag;
+          r2 += node.value;
+          options.state = WriterState.CloseTag;
+          r2 += this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.dtdAttList = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level) + "<!ATTLIST";
+          options.state = WriterState.InsideTag;
+          r2 += " " + node.elementName + " " + node.attributeName + " " + node.attributeType;
+          if (node.defaultValueType !== "#DEFAULT") {
+            r2 += " " + node.defaultValueType;
+          }
+          if (node.defaultValue) {
+            r2 += ' "' + node.defaultValue + '"';
+          }
+          options.state = WriterState.CloseTag;
+          r2 += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.dtdElement = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level) + "<!ELEMENT";
+          options.state = WriterState.InsideTag;
+          r2 += " " + node.name + " " + node.value;
+          options.state = WriterState.CloseTag;
+          r2 += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.dtdEntity = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level) + "<!ENTITY";
+          options.state = WriterState.InsideTag;
+          if (node.pe) {
+            r2 += " %";
+          }
+          r2 += " " + node.name;
+          if (node.value) {
+            r2 += ' "' + node.value + '"';
+          } else {
+            if (node.pubID && node.sysID) {
+              r2 += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
+            } else if (node.sysID) {
+              r2 += ' SYSTEM "' + node.sysID + '"';
+            }
+            if (node.nData) {
+              r2 += " NDATA " + node.nData;
+            }
+          }
+          options.state = WriterState.CloseTag;
+          r2 += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.dtdNotation = function(node, options, level) {
+          var r2;
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          r2 = this.indent(node, options, level) + "<!NOTATION";
+          options.state = WriterState.InsideTag;
+          r2 += " " + node.name;
+          if (node.pubID && node.sysID) {
+            r2 += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
+          } else if (node.pubID) {
+            r2 += ' PUBLIC "' + node.pubID + '"';
+          } else if (node.sysID) {
+            r2 += ' SYSTEM "' + node.sysID + '"';
+          }
+          options.state = WriterState.CloseTag;
+          r2 += options.spaceBeforeSlash + ">" + this.endline(node, options, level);
+          options.state = WriterState.None;
+          this.closeNode(node, options, level);
+          return r2;
+        };
+        XMLWriterBase2.prototype.openNode = function(node, options, level) {
+        };
+        XMLWriterBase2.prototype.closeNode = function(node, options, level) {
+        };
+        XMLWriterBase2.prototype.openAttribute = function(att, options, level) {
+        };
+        XMLWriterBase2.prototype.closeAttribute = function(att, options, level) {
+        };
+        return XMLWriterBase2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLStringWriter.js
+var require_XMLStringWriter = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLStringWriter.js"(exports2, module2) {
+    (function() {
+      var XMLStringWriter, XMLWriterBase, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      XMLWriterBase = require_XMLWriterBase();
+      module2.exports = XMLStringWriter = function(superClass) {
+        extend2(XMLStringWriter2, superClass);
+        function XMLStringWriter2(options) {
+          XMLStringWriter2.__super__.constructor.call(this, options);
+        }
+        XMLStringWriter2.prototype.document = function(doc, options) {
+          var child, i7, len, r2, ref;
+          options = this.filterOptions(options);
+          r2 = "";
+          ref = doc.children;
+          for (i7 = 0, len = ref.length; i7 < len; i7++) {
+            child = ref[i7];
+            r2 += this.writeChildNode(child, options, 0);
+          }
+          if (options.pretty && r2.slice(-options.newline.length) === options.newline) {
+            r2 = r2.slice(0, -options.newline.length);
+          }
+          return r2;
+        };
+        return XMLStringWriter2;
+      }(XMLWriterBase);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDocument.js
+var require_XMLDocument = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDocument.js"(exports2, module2) {
+    (function() {
+      var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject2, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      isPlainObject2 = require_Utility().isPlainObject;
+      XMLDOMImplementation = require_XMLDOMImplementation();
+      XMLDOMConfiguration = require_XMLDOMConfiguration();
+      XMLNode = require_XMLNode();
+      NodeType = require_NodeType();
+      XMLStringifier = require_XMLStringifier();
+      XMLStringWriter = require_XMLStringWriter();
+      module2.exports = XMLDocument = function(superClass) {
+        extend2(XMLDocument2, superClass);
+        function XMLDocument2(options) {
+          XMLDocument2.__super__.constructor.call(this, null);
+          this.name = "#document";
+          this.type = NodeType.Document;
+          this.documentURI = null;
+          this.domConfig = new XMLDOMConfiguration();
+          options || (options = {});
+          if (!options.writer) {
+            options.writer = new XMLStringWriter();
+          }
+          this.options = options;
+          this.stringify = new XMLStringifier(options);
+        }
+        Object.defineProperty(XMLDocument2.prototype, "implementation", {
+          value: new XMLDOMImplementation()
+        });
+        Object.defineProperty(XMLDocument2.prototype, "doctype", {
+          get: function() {
+            var child, i7, len, ref;
+            ref = this.children;
+            for (i7 = 0, len = ref.length; i7 < len; i7++) {
+              child = ref[i7];
+              if (child.type === NodeType.DocType) {
+                return child;
+              }
+            }
+            return null;
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "documentElement", {
+          get: function() {
+            return this.rootObject || null;
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "inputEncoding", {
+          get: function() {
+            return null;
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "strictErrorChecking", {
+          get: function() {
+            return false;
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "xmlEncoding", {
+          get: function() {
+            if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
+              return this.children[0].encoding;
+            } else {
+              return null;
+            }
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "xmlStandalone", {
+          get: function() {
+            if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
+              return this.children[0].standalone === "yes";
+            } else {
+              return false;
+            }
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "xmlVersion", {
+          get: function() {
+            if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
+              return this.children[0].version;
+            } else {
+              return "1.0";
+            }
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "URL", {
+          get: function() {
+            return this.documentURI;
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "origin", {
+          get: function() {
+            return null;
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "compatMode", {
+          get: function() {
+            return null;
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "characterSet", {
+          get: function() {
+            return null;
+          }
+        });
+        Object.defineProperty(XMLDocument2.prototype, "contentType", {
+          get: function() {
+            return null;
+          }
+        });
+        XMLDocument2.prototype.end = function(writer) {
+          var writerOptions;
+          writerOptions = {};
+          if (!writer) {
+            writer = this.options.writer;
+          } else if (isPlainObject2(writer)) {
+            writerOptions = writer;
+            writer = this.options.writer;
+          }
+          return writer.document(this, writer.filterOptions(writerOptions));
+        };
+        XMLDocument2.prototype.toString = function(options) {
+          return this.options.writer.document(this, this.options.writer.filterOptions(options));
+        };
+        XMLDocument2.prototype.createElement = function(tagName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createDocumentFragment = function() {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createTextNode = function(data2) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createComment = function(data2) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createCDATASection = function(data2) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createProcessingInstruction = function(target, data2) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createAttribute = function(name) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createEntityReference = function(name) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.getElementsByTagName = function(tagname) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.importNode = function(importedNode, deep) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createElementNS = function(namespaceURI, qualifiedName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createAttributeNS = function(namespaceURI, qualifiedName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.getElementById = function(elementId) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.adoptNode = function(source) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.normalizeDocument = function() {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.renameNode = function(node, namespaceURI, qualifiedName) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.getElementsByClassName = function(classNames) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createEvent = function(eventInterface) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createRange = function() {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createNodeIterator = function(root3, whatToShow, filter6) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        XMLDocument2.prototype.createTreeWalker = function(root3, whatToShow, filter6) {
+          throw new Error("This DOM method is not implemented." + this.debugInfo());
+        };
+        return XMLDocument2;
+      }(XMLNode);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDocumentCB.js
+var require_XMLDocumentCB = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLDocumentCB.js"(exports2, module2) {
+    (function() {
+      var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction2, isObject2, isPlainObject2, ref, hasProp = {}.hasOwnProperty;
+      ref = require_Utility(), isObject2 = ref.isObject, isFunction2 = ref.isFunction, isPlainObject2 = ref.isPlainObject, getValue = ref.getValue;
+      NodeType = require_NodeType();
+      XMLDocument = require_XMLDocument();
+      XMLElement = require_XMLElement();
+      XMLCData = require_XMLCData();
+      XMLComment = require_XMLComment();
+      XMLRaw = require_XMLRaw();
+      XMLText = require_XMLText();
+      XMLProcessingInstruction = require_XMLProcessingInstruction();
+      XMLDeclaration = require_XMLDeclaration();
+      XMLDocType = require_XMLDocType();
+      XMLDTDAttList = require_XMLDTDAttList();
+      XMLDTDEntity = require_XMLDTDEntity();
+      XMLDTDElement = require_XMLDTDElement();
+      XMLDTDNotation = require_XMLDTDNotation();
+      XMLAttribute = require_XMLAttribute();
+      XMLStringifier = require_XMLStringifier();
+      XMLStringWriter = require_XMLStringWriter();
+      WriterState = require_WriterState();
+      module2.exports = XMLDocumentCB = function() {
+        function XMLDocumentCB2(options, onData, onEnd) {
+          var writerOptions;
+          this.name = "?xml";
+          this.type = NodeType.Document;
+          options || (options = {});
+          writerOptions = {};
+          if (!options.writer) {
+            options.writer = new XMLStringWriter();
+          } else if (isPlainObject2(options.writer)) {
+            writerOptions = options.writer;
+            options.writer = new XMLStringWriter();
+          }
+          this.options = options;
+          this.writer = options.writer;
+          this.writerOptions = this.writer.filterOptions(writerOptions);
+          this.stringify = new XMLStringifier(options);
+          this.onDataCallback = onData || function() {
+          };
+          this.onEndCallback = onEnd || function() {
+          };
+          this.currentNode = null;
+          this.currentLevel = -1;
+          this.openTags = {};
+          this.documentStarted = false;
+          this.documentCompleted = false;
+          this.root = null;
+        }
+        XMLDocumentCB2.prototype.createChildNode = function(node) {
+          var att, attName, attributes2, child, i7, len, ref1, ref2;
+          switch (node.type) {
+            case NodeType.CData:
+              this.cdata(node.value);
+              break;
+            case NodeType.Comment:
+              this.comment(node.value);
+              break;
+            case NodeType.Element:
+              attributes2 = {};
+              ref1 = node.attribs;
+              for (attName in ref1) {
+                if (!hasProp.call(ref1, attName)) continue;
+                att = ref1[attName];
+                attributes2[attName] = att.value;
+              }
+              this.node(node.name, attributes2);
+              break;
+            case NodeType.Dummy:
+              this.dummy();
+              break;
+            case NodeType.Raw:
+              this.raw(node.value);
+              break;
+            case NodeType.Text:
+              this.text(node.value);
+              break;
+            case NodeType.ProcessingInstruction:
+              this.instruction(node.target, node.value);
+              break;
+            default:
+              throw new Error("This XML node type is not supported in a JS object: " + node.constructor.name);
+          }
+          ref2 = node.children;
+          for (i7 = 0, len = ref2.length; i7 < len; i7++) {
+            child = ref2[i7];
+            this.createChildNode(child);
+            if (child.type === NodeType.Element) {
+              this.up();
+            }
+          }
+          return this;
+        };
+        XMLDocumentCB2.prototype.dummy = function() {
+          return this;
+        };
+        XMLDocumentCB2.prototype.node = function(name, attributes2, text3) {
+          var ref1;
+          if (name == null) {
+            throw new Error("Missing node name.");
+          }
+          if (this.root && this.currentLevel === -1) {
+            throw new Error("Document can only have one root node. " + this.debugInfo(name));
+          }
+          this.openCurrent();
+          name = getValue(name);
+          if (attributes2 == null) {
+            attributes2 = {};
+          }
+          attributes2 = getValue(attributes2);
+          if (!isObject2(attributes2)) {
+            ref1 = [attributes2, text3], text3 = ref1[0], attributes2 = ref1[1];
+          }
+          this.currentNode = new XMLElement(this, name, attributes2);
+          this.currentNode.children = false;
+          this.currentLevel++;
+          this.openTags[this.currentLevel] = this.currentNode;
+          if (text3 != null) {
+            this.text(text3);
+          }
+          return this;
+        };
+        XMLDocumentCB2.prototype.element = function(name, attributes2, text3) {
+          var child, i7, len, oldValidationFlag, ref1, root3;
+          if (this.currentNode && this.currentNode.type === NodeType.DocType) {
+            this.dtdElement.apply(this, arguments);
+          } else {
+            if (Array.isArray(name) || isObject2(name) || isFunction2(name)) {
+              oldValidationFlag = this.options.noValidation;
+              this.options.noValidation = true;
+              root3 = new XMLDocument(this.options).element("TEMP_ROOT");
+              root3.element(name);
+              this.options.noValidation = oldValidationFlag;
+              ref1 = root3.children;
+              for (i7 = 0, len = ref1.length; i7 < len; i7++) {
+                child = ref1[i7];
+                this.createChildNode(child);
+                if (child.type === NodeType.Element) {
+                  this.up();
+                }
+              }
+            } else {
+              this.node(name, attributes2, text3);
+            }
+          }
+          return this;
+        };
+        XMLDocumentCB2.prototype.attribute = function(name, value) {
+          var attName, attValue;
+          if (!this.currentNode || this.currentNode.children) {
+            throw new Error("att() can only be used immediately after an ele() call in callback mode. " + this.debugInfo(name));
+          }
+          if (name != null) {
+            name = getValue(name);
+          }
+          if (isObject2(name)) {
+            for (attName in name) {
+              if (!hasProp.call(name, attName)) continue;
+              attValue = name[attName];
+              this.attribute(attName, attValue);
+            }
+          } else {
+            if (isFunction2(value)) {
+              value = value.apply();
+            }
+            if (this.options.keepNullAttributes && value == null) {
+              this.currentNode.attribs[name] = new XMLAttribute(this, name, "");
+            } else if (value != null) {
+              this.currentNode.attribs[name] = new XMLAttribute(this, name, value);
+            }
+          }
+          return this;
+        };
+        XMLDocumentCB2.prototype.text = function(value) {
+          var node;
+          this.openCurrent();
+          node = new XMLText(this, value);
+          this.onData(this.writer.text(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.cdata = function(value) {
+          var node;
+          this.openCurrent();
+          node = new XMLCData(this, value);
+          this.onData(this.writer.cdata(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.comment = function(value) {
+          var node;
+          this.openCurrent();
+          node = new XMLComment(this, value);
+          this.onData(this.writer.comment(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.raw = function(value) {
+          var node;
+          this.openCurrent();
+          node = new XMLRaw(this, value);
+          this.onData(this.writer.raw(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.instruction = function(target, value) {
+          var i7, insTarget, insValue, len, node;
+          this.openCurrent();
+          if (target != null) {
+            target = getValue(target);
+          }
+          if (value != null) {
+            value = getValue(value);
+          }
+          if (Array.isArray(target)) {
+            for (i7 = 0, len = target.length; i7 < len; i7++) {
+              insTarget = target[i7];
+              this.instruction(insTarget);
+            }
+          } else if (isObject2(target)) {
+            for (insTarget in target) {
+              if (!hasProp.call(target, insTarget)) continue;
+              insValue = target[insTarget];
+              this.instruction(insTarget, insValue);
+            }
+          } else {
+            if (isFunction2(value)) {
+              value = value.apply();
+            }
+            node = new XMLProcessingInstruction(this, target, value);
+            this.onData(this.writer.processingInstruction(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          }
+          return this;
+        };
+        XMLDocumentCB2.prototype.declaration = function(version3, encoding, standalone) {
+          var node;
+          this.openCurrent();
+          if (this.documentStarted) {
+            throw new Error("declaration() must be the first node.");
+          }
+          node = new XMLDeclaration(this, version3, encoding, standalone);
+          this.onData(this.writer.declaration(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.doctype = function(root3, pubID, sysID) {
+          this.openCurrent();
+          if (root3 == null) {
+            throw new Error("Missing root node name.");
+          }
+          if (this.root) {
+            throw new Error("dtd() must come before the root node.");
+          }
+          this.currentNode = new XMLDocType(this, pubID, sysID);
+          this.currentNode.rootNodeName = root3;
+          this.currentNode.children = false;
+          this.currentLevel++;
+          this.openTags[this.currentLevel] = this.currentNode;
+          return this;
+        };
+        XMLDocumentCB2.prototype.dtdElement = function(name, value) {
+          var node;
+          this.openCurrent();
+          node = new XMLDTDElement(this, name, value);
+          this.onData(this.writer.dtdElement(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
+          var node;
+          this.openCurrent();
+          node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
+          this.onData(this.writer.dtdAttList(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.entity = function(name, value) {
+          var node;
+          this.openCurrent();
+          node = new XMLDTDEntity(this, false, name, value);
+          this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.pEntity = function(name, value) {
+          var node;
+          this.openCurrent();
+          node = new XMLDTDEntity(this, true, name, value);
+          this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.notation = function(name, value) {
+          var node;
+          this.openCurrent();
+          node = new XMLDTDNotation(this, name, value);
+          this.onData(this.writer.dtdNotation(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
+          return this;
+        };
+        XMLDocumentCB2.prototype.up = function() {
+          if (this.currentLevel < 0) {
+            throw new Error("The document node has no parent.");
+          }
+          if (this.currentNode) {
+            if (this.currentNode.children) {
+              this.closeNode(this.currentNode);
+            } else {
+              this.openNode(this.currentNode);
+            }
+            this.currentNode = null;
+          } else {
+            this.closeNode(this.openTags[this.currentLevel]);
+          }
+          delete this.openTags[this.currentLevel];
+          this.currentLevel--;
+          return this;
+        };
+        XMLDocumentCB2.prototype.end = function() {
+          while (this.currentLevel >= 0) {
+            this.up();
+          }
+          return this.onEnd();
+        };
+        XMLDocumentCB2.prototype.openCurrent = function() {
+          if (this.currentNode) {
+            this.currentNode.children = true;
+            return this.openNode(this.currentNode);
+          }
+        };
+        XMLDocumentCB2.prototype.openNode = function(node) {
+          var att, chunk, name, ref1;
+          if (!node.isOpen) {
+            if (!this.root && this.currentLevel === 0 && node.type === NodeType.Element) {
+              this.root = node;
+            }
+            chunk = "";
+            if (node.type === NodeType.Element) {
+              this.writerOptions.state = WriterState.OpenTag;
+              chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "<" + node.name;
+              ref1 = node.attribs;
+              for (name in ref1) {
+                if (!hasProp.call(ref1, name)) continue;
+                att = ref1[name];
+                chunk += this.writer.attribute(att, this.writerOptions, this.currentLevel);
+              }
+              chunk += (node.children ? ">" : "/>") + this.writer.endline(node, this.writerOptions, this.currentLevel);
+              this.writerOptions.state = WriterState.InsideTag;
+            } else {
+              this.writerOptions.state = WriterState.OpenTag;
+              chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "<!DOCTYPE " + node.rootNodeName;
+              if (node.pubID && node.sysID) {
+                chunk += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
+              } else if (node.sysID) {
+                chunk += ' SYSTEM "' + node.sysID + '"';
+              }
+              if (node.children) {
+                chunk += " [";
+                this.writerOptions.state = WriterState.InsideTag;
+              } else {
+                this.writerOptions.state = WriterState.CloseTag;
+                chunk += ">";
+              }
+              chunk += this.writer.endline(node, this.writerOptions, this.currentLevel);
+            }
+            this.onData(chunk, this.currentLevel);
+            return node.isOpen = true;
+          }
+        };
+        XMLDocumentCB2.prototype.closeNode = function(node) {
+          var chunk;
+          if (!node.isClosed) {
+            chunk = "";
+            this.writerOptions.state = WriterState.CloseTag;
+            if (node.type === NodeType.Element) {
+              chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "</" + node.name + ">" + this.writer.endline(node, this.writerOptions, this.currentLevel);
+            } else {
+              chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + "]>" + this.writer.endline(node, this.writerOptions, this.currentLevel);
+            }
+            this.writerOptions.state = WriterState.None;
+            this.onData(chunk, this.currentLevel);
+            return node.isClosed = true;
+          }
+        };
+        XMLDocumentCB2.prototype.onData = function(chunk, level) {
+          this.documentStarted = true;
+          return this.onDataCallback(chunk, level + 1);
+        };
+        XMLDocumentCB2.prototype.onEnd = function() {
+          this.documentCompleted = true;
+          return this.onEndCallback();
+        };
+        XMLDocumentCB2.prototype.debugInfo = function(name) {
+          if (name == null) {
+            return "";
+          } else {
+            return "node: <" + name + ">";
+          }
+        };
+        XMLDocumentCB2.prototype.ele = function() {
+          return this.element.apply(this, arguments);
+        };
+        XMLDocumentCB2.prototype.nod = function(name, attributes2, text3) {
+          return this.node(name, attributes2, text3);
+        };
+        XMLDocumentCB2.prototype.txt = function(value) {
+          return this.text(value);
+        };
+        XMLDocumentCB2.prototype.dat = function(value) {
+          return this.cdata(value);
+        };
+        XMLDocumentCB2.prototype.com = function(value) {
+          return this.comment(value);
+        };
+        XMLDocumentCB2.prototype.ins = function(target, value) {
+          return this.instruction(target, value);
+        };
+        XMLDocumentCB2.prototype.dec = function(version3, encoding, standalone) {
+          return this.declaration(version3, encoding, standalone);
+        };
+        XMLDocumentCB2.prototype.dtd = function(root3, pubID, sysID) {
+          return this.doctype(root3, pubID, sysID);
+        };
+        XMLDocumentCB2.prototype.e = function(name, attributes2, text3) {
+          return this.element(name, attributes2, text3);
+        };
+        XMLDocumentCB2.prototype.n = function(name, attributes2, text3) {
+          return this.node(name, attributes2, text3);
+        };
+        XMLDocumentCB2.prototype.t = function(value) {
+          return this.text(value);
+        };
+        XMLDocumentCB2.prototype.d = function(value) {
+          return this.cdata(value);
+        };
+        XMLDocumentCB2.prototype.c = function(value) {
+          return this.comment(value);
+        };
+        XMLDocumentCB2.prototype.r = function(value) {
+          return this.raw(value);
+        };
+        XMLDocumentCB2.prototype.i = function(target, value) {
+          return this.instruction(target, value);
+        };
+        XMLDocumentCB2.prototype.att = function() {
+          if (this.currentNode && this.currentNode.type === NodeType.DocType) {
+            return this.attList.apply(this, arguments);
+          } else {
+            return this.attribute.apply(this, arguments);
+          }
+        };
+        XMLDocumentCB2.prototype.a = function() {
+          if (this.currentNode && this.currentNode.type === NodeType.DocType) {
+            return this.attList.apply(this, arguments);
+          } else {
+            return this.attribute.apply(this, arguments);
+          }
+        };
+        XMLDocumentCB2.prototype.ent = function(name, value) {
+          return this.entity(name, value);
+        };
+        XMLDocumentCB2.prototype.pent = function(name, value) {
+          return this.pEntity(name, value);
+        };
+        XMLDocumentCB2.prototype.not = function(name, value) {
+          return this.notation(name, value);
+        };
+        return XMLDocumentCB2;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLStreamWriter.js
+var require_XMLStreamWriter = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/XMLStreamWriter.js"(exports2, module2) {
+    (function() {
+      var NodeType, WriterState, XMLStreamWriter, XMLWriterBase, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      NodeType = require_NodeType();
+      XMLWriterBase = require_XMLWriterBase();
+      WriterState = require_WriterState();
+      module2.exports = XMLStreamWriter = function(superClass) {
+        extend2(XMLStreamWriter2, superClass);
+        function XMLStreamWriter2(stream5, options) {
+          this.stream = stream5;
+          XMLStreamWriter2.__super__.constructor.call(this, options);
+        }
+        XMLStreamWriter2.prototype.endline = function(node, options, level) {
+          if (node.isLastRootNode && options.state === WriterState.CloseTag) {
+            return "";
+          } else {
+            return XMLStreamWriter2.__super__.endline.call(this, node, options, level);
+          }
+        };
+        XMLStreamWriter2.prototype.document = function(doc, options) {
+          var child, i7, j, k, len, len1, ref, ref1, results;
+          ref = doc.children;
+          for (i7 = j = 0, len = ref.length; j < len; i7 = ++j) {
+            child = ref[i7];
+            child.isLastRootNode = i7 === doc.children.length - 1;
+          }
+          options = this.filterOptions(options);
+          ref1 = doc.children;
+          results = [];
+          for (k = 0, len1 = ref1.length; k < len1; k++) {
+            child = ref1[k];
+            results.push(this.writeChildNode(child, options, 0));
+          }
+          return results;
+        };
+        XMLStreamWriter2.prototype.attribute = function(att, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.attribute.call(this, att, options, level));
+        };
+        XMLStreamWriter2.prototype.cdata = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.cdata.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.comment = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.comment.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.declaration = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.declaration.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.docType = function(node, options, level) {
+          var child, j, len, ref;
+          level || (level = 0);
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          this.stream.write(this.indent(node, options, level));
+          this.stream.write("<!DOCTYPE " + node.root().name);
+          if (node.pubID && node.sysID) {
+            this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
+          } else if (node.sysID) {
+            this.stream.write(' SYSTEM "' + node.sysID + '"');
+          }
+          if (node.children.length > 0) {
+            this.stream.write(" [");
+            this.stream.write(this.endline(node, options, level));
+            options.state = WriterState.InsideTag;
+            ref = node.children;
+            for (j = 0, len = ref.length; j < len; j++) {
+              child = ref[j];
+              this.writeChildNode(child, options, level + 1);
+            }
+            options.state = WriterState.CloseTag;
+            this.stream.write("]");
+          }
+          options.state = WriterState.CloseTag;
+          this.stream.write(options.spaceBeforeSlash + ">");
+          this.stream.write(this.endline(node, options, level));
+          options.state = WriterState.None;
+          return this.closeNode(node, options, level);
+        };
+        XMLStreamWriter2.prototype.element = function(node, options, level) {
+          var att, child, childNodeCount, firstChildNode, j, len, name, prettySuppressed, ref, ref1;
+          level || (level = 0);
+          this.openNode(node, options, level);
+          options.state = WriterState.OpenTag;
+          this.stream.write(this.indent(node, options, level) + "<" + node.name);
+          ref = node.attribs;
+          for (name in ref) {
+            if (!hasProp.call(ref, name)) continue;
+            att = ref[name];
+            this.attribute(att, options, level);
+          }
+          childNodeCount = node.children.length;
+          firstChildNode = childNodeCount === 0 ? null : node.children[0];
+          if (childNodeCount === 0 || node.children.every(function(e) {
+            return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === "";
+          })) {
+            if (options.allowEmpty) {
+              this.stream.write(">");
+              options.state = WriterState.CloseTag;
+              this.stream.write("</" + node.name + ">");
+            } else {
+              options.state = WriterState.CloseTag;
+              this.stream.write(options.spaceBeforeSlash + "/>");
+            }
+          } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && firstChildNode.value != null) {
+            this.stream.write(">");
+            options.state = WriterState.InsideTag;
+            options.suppressPrettyCount++;
+            prettySuppressed = true;
+            this.writeChildNode(firstChildNode, options, level + 1);
+            options.suppressPrettyCount--;
+            prettySuppressed = false;
+            options.state = WriterState.CloseTag;
+            this.stream.write("</" + node.name + ">");
+          } else {
+            this.stream.write(">" + this.endline(node, options, level));
+            options.state = WriterState.InsideTag;
+            ref1 = node.children;
+            for (j = 0, len = ref1.length; j < len; j++) {
+              child = ref1[j];
+              this.writeChildNode(child, options, level + 1);
+            }
+            options.state = WriterState.CloseTag;
+            this.stream.write(this.indent(node, options, level) + "</" + node.name + ">");
+          }
+          this.stream.write(this.endline(node, options, level));
+          options.state = WriterState.None;
+          return this.closeNode(node, options, level);
+        };
+        XMLStreamWriter2.prototype.processingInstruction = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.processingInstruction.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.raw = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.raw.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.text = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.text.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.dtdAttList = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.dtdAttList.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.dtdElement = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.dtdElement.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.dtdEntity = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.dtdEntity.call(this, node, options, level));
+        };
+        XMLStreamWriter2.prototype.dtdNotation = function(node, options, level) {
+          return this.stream.write(XMLStreamWriter2.__super__.dtdNotation.call(this, node, options, level));
+        };
+        return XMLStreamWriter2;
+      }(XMLWriterBase);
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/index.js
+var require_lib22 = __commonJS({
+  "../../node_modules/.pnpm/xmlbuilder@11.0.1/node_modules/xmlbuilder/lib/index.js"(exports2, module2) {
+    (function() {
+      var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction2, ref;
+      ref = require_Utility(), assign = ref.assign, isFunction2 = ref.isFunction;
+      XMLDOMImplementation = require_XMLDOMImplementation();
+      XMLDocument = require_XMLDocument();
+      XMLDocumentCB = require_XMLDocumentCB();
+      XMLStringWriter = require_XMLStringWriter();
+      XMLStreamWriter = require_XMLStreamWriter();
+      NodeType = require_NodeType();
+      WriterState = require_WriterState();
+      module2.exports.create = function(name, xmldec, doctype, options) {
+        var doc, root3;
+        if (name == null) {
+          throw new Error("Root element needs a name.");
+        }
+        options = assign({}, xmldec, doctype, options);
+        doc = new XMLDocument(options);
+        root3 = doc.element(name);
+        if (!options.headless) {
+          doc.declaration(options);
+          if (options.pubID != null || options.sysID != null) {
+            doc.dtd(options);
+          }
+        }
+        return root3;
+      };
+      module2.exports.begin = function(options, onData, onEnd) {
+        var ref1;
+        if (isFunction2(options)) {
+          ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];
+          options = {};
+        }
+        if (onData) {
+          return new XMLDocumentCB(options, onData, onEnd);
+        } else {
+          return new XMLDocument(options);
+        }
+      };
+      module2.exports.stringWriter = function(options) {
+        return new XMLStringWriter(options);
+      };
+      module2.exports.streamWriter = function(stream5, options) {
+        return new XMLStreamWriter(stream5, options);
+      };
+      module2.exports.implementation = new XMLDOMImplementation();
+      module2.exports.nodeType = NodeType;
+      module2.exports.writerState = WriterState;
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/builder.js
+var require_builder = __commonJS({
+  "../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/builder.js"(exports2) {
+    (function() {
+      "use strict";
+      var builder, defaults3, escapeCDATA, requiresCDATA, wrapCDATA, hasProp = {}.hasOwnProperty;
+      builder = require_lib22();
+      defaults3 = require_defaults2().defaults;
+      requiresCDATA = function(entry) {
+        return typeof entry === "string" && (entry.indexOf("&") >= 0 || entry.indexOf(">") >= 0 || entry.indexOf("<") >= 0);
+      };
+      wrapCDATA = function(entry) {
+        return "<![CDATA[" + escapeCDATA(entry) + "]]>";
+      };
+      escapeCDATA = function(entry) {
+        return entry.replace("]]>", "]]]]><![CDATA[>");
+      };
+      exports2.Builder = function() {
+        function Builder(opts) {
+          var key, ref, value;
+          this.options = {};
+          ref = defaults3["0.2"];
+          for (key in ref) {
+            if (!hasProp.call(ref, key)) continue;
+            value = ref[key];
+            this.options[key] = value;
+          }
+          for (key in opts) {
+            if (!hasProp.call(opts, key)) continue;
+            value = opts[key];
+            this.options[key] = value;
+          }
+        }
+        Builder.prototype.buildObject = function(rootObj) {
+          var attrkey, charkey, render3, rootElement, rootName;
+          attrkey = this.options.attrkey;
+          charkey = this.options.charkey;
+          if (Object.keys(rootObj).length === 1 && this.options.rootName === defaults3["0.2"].rootName) {
+            rootName = Object.keys(rootObj)[0];
+            rootObj = rootObj[rootName];
+          } else {
+            rootName = this.options.rootName;
+          }
+          render3 = /* @__PURE__ */ function(_this) {
+            return function(element, obj) {
+              var attr2, child, entry, index2, key, value;
+              if (typeof obj !== "object") {
+                if (_this.options.cdata && requiresCDATA(obj)) {
+                  element.raw(wrapCDATA(obj));
+                } else {
+                  element.txt(obj);
+                }
+              } else if (Array.isArray(obj)) {
+                for (index2 in obj) {
+                  if (!hasProp.call(obj, index2)) continue;
+                  child = obj[index2];
+                  for (key in child) {
+                    entry = child[key];
+                    element = render3(element.ele(key), entry).up();
+                  }
+                }
+              } else {
+                for (key in obj) {
+                  if (!hasProp.call(obj, key)) continue;
+                  child = obj[key];
+                  if (key === attrkey) {
+                    if (typeof child === "object") {
+                      for (attr2 in child) {
+                        value = child[attr2];
+                        element = element.att(attr2, value);
+                      }
+                    }
+                  } else if (key === charkey) {
+                    if (_this.options.cdata && requiresCDATA(child)) {
+                      element = element.raw(wrapCDATA(child));
+                    } else {
+                      element = element.txt(child);
+                    }
+                  } else if (Array.isArray(child)) {
+                    for (index2 in child) {
+                      if (!hasProp.call(child, index2)) continue;
+                      entry = child[index2];
+                      if (typeof entry === "string") {
+                        if (_this.options.cdata && requiresCDATA(entry)) {
+                          element = element.ele(key).raw(wrapCDATA(entry)).up();
+                        } else {
+                          element = element.ele(key, entry).up();
+                        }
+                      } else {
+                        element = render3(element.ele(key), entry).up();
+                      }
+                    }
+                  } else if (typeof child === "object") {
+                    element = render3(element.ele(key), child).up();
+                  } else {
+                    if (typeof child === "string" && _this.options.cdata && requiresCDATA(child)) {
+                      element = element.ele(key).raw(wrapCDATA(child)).up();
+                    } else {
+                      if (child == null) {
+                        child = "";
+                      }
+                      element = element.ele(key, child.toString()).up();
+                    }
+                  }
+                }
+              }
+              return element;
+            };
+          }(this);
+          rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, {
+            headless: this.options.headless,
+            allowSurrogateChars: this.options.allowSurrogateChars
+          });
+          return render3(rootElement, rootObj).end(this.options.renderOpts);
+        };
+        return Builder;
+      }();
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/bom.js
+var require_bom = __commonJS({
+  "../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/bom.js"(exports2) {
+    (function() {
+      "use strict";
+      exports2.stripBOM = function(str) {
+        if (str[0] === "\uFEFF") {
+          return str.substring(1);
+        } else {
+          return str;
+        }
+      };
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/processors.js
+var require_processors = __commonJS({
+  "../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/processors.js"(exports2) {
+    (function() {
+      "use strict";
+      var prefixMatch;
+      prefixMatch = new RegExp(/(?!xmlns)^.*:/);
+      exports2.normalize = function(str) {
+        return str.toLowerCase();
+      };
+      exports2.firstCharLowerCase = function(str) {
+        return str.charAt(0).toLowerCase() + str.slice(1);
+      };
+      exports2.stripPrefix = function(str) {
+        return str.replace(prefixMatch, "");
+      };
+      exports2.parseNumbers = function(str) {
+        if (!isNaN(str)) {
+          str = str % 1 === 0 ? parseInt(str, 10) : parseFloat(str);
+        }
+        return str;
+      };
+      exports2.parseBooleans = function(str) {
+        if (/^(?:true|false)$/i.test(str)) {
+          str = str.toLowerCase() === "true";
+        }
+        return str;
+      };
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/parser.js
+var require_parser3 = __commonJS({
+  "../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/parser.js"(exports2) {
+    (function() {
+      "use strict";
+      var bom, defaults3, defineProperty, events, isEmpty, processItem, processors, sax, setImmediate2, bind2 = function(fn2, me) {
+        return function() {
+          return fn2.apply(me, arguments);
+        };
+      }, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      sax = require_sax();
+      events = __require("events");
+      bom = require_bom();
+      processors = require_processors();
+      setImmediate2 = __require("timers").setImmediate;
+      defaults3 = require_defaults2().defaults;
+      isEmpty = function(thing) {
+        return typeof thing === "object" && thing != null && Object.keys(thing).length === 0;
+      };
+      processItem = function(processors2, item, key) {
+        var i7, len, process2;
+        for (i7 = 0, len = processors2.length; i7 < len; i7++) {
+          process2 = processors2[i7];
+          item = process2(item, key);
+        }
+        return item;
+      };
+      defineProperty = function(obj, key, value) {
+        var descriptor;
+        descriptor = /* @__PURE__ */ Object.create(null);
+        descriptor.value = value;
+        descriptor.writable = true;
+        descriptor.enumerable = true;
+        descriptor.configurable = true;
+        return Object.defineProperty(obj, key, descriptor);
+      };
+      exports2.Parser = function(superClass) {
+        extend2(Parser4, superClass);
+        function Parser4(opts) {
+          this.parseStringPromise = bind2(this.parseStringPromise, this);
+          this.parseString = bind2(this.parseString, this);
+          this.reset = bind2(this.reset, this);
+          this.assignOrPush = bind2(this.assignOrPush, this);
+          this.processAsync = bind2(this.processAsync, this);
+          var key, ref, value;
+          if (!(this instanceof exports2.Parser)) {
+            return new exports2.Parser(opts);
+          }
+          this.options = {};
+          ref = defaults3["0.2"];
+          for (key in ref) {
+            if (!hasProp.call(ref, key)) continue;
+            value = ref[key];
+            this.options[key] = value;
+          }
+          for (key in opts) {
+            if (!hasProp.call(opts, key)) continue;
+            value = opts[key];
+            this.options[key] = value;
+          }
+          if (this.options.xmlns) {
+            this.options.xmlnskey = this.options.attrkey + "ns";
+          }
+          if (this.options.normalizeTags) {
+            if (!this.options.tagNameProcessors) {
+              this.options.tagNameProcessors = [];
+            }
+            this.options.tagNameProcessors.unshift(processors.normalize);
+          }
+          this.reset();
+        }
+        Parser4.prototype.processAsync = function() {
+          var chunk, err;
+          try {
+            if (this.remaining.length <= this.options.chunkSize) {
+              chunk = this.remaining;
+              this.remaining = "";
+              this.saxParser = this.saxParser.write(chunk);
+              return this.saxParser.close();
+            } else {
+              chunk = this.remaining.substr(0, this.options.chunkSize);
+              this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length);
+              this.saxParser = this.saxParser.write(chunk);
+              return setImmediate2(this.processAsync);
+            }
+          } catch (error1) {
+            err = error1;
+            if (!this.saxParser.errThrown) {
+              this.saxParser.errThrown = true;
+              return this.emit(err);
+            }
+          }
+        };
+        Parser4.prototype.assignOrPush = function(obj, key, newValue) {
+          if (!(key in obj)) {
+            if (!this.options.explicitArray) {
+              return defineProperty(obj, key, newValue);
+            } else {
+              return defineProperty(obj, key, [newValue]);
+            }
+          } else {
+            if (!(obj[key] instanceof Array)) {
+              defineProperty(obj, key, [obj[key]]);
+            }
+            return obj[key].push(newValue);
+          }
+        };
+        Parser4.prototype.reset = function() {
+          var attrkey, charkey, ontext, stack2;
+          this.removeAllListeners();
+          this.saxParser = sax.parser(this.options.strict, {
+            trim: false,
+            normalize: false,
+            xmlns: this.options.xmlns
+          });
+          this.saxParser.errThrown = false;
+          this.saxParser.onerror = /* @__PURE__ */ function(_this) {
+            return function(error) {
+              _this.saxParser.resume();
+              if (!_this.saxParser.errThrown) {
+                _this.saxParser.errThrown = true;
+                return _this.emit("error", error);
+              }
+            };
+          }(this);
+          this.saxParser.onend = /* @__PURE__ */ function(_this) {
+            return function() {
+              if (!_this.saxParser.ended) {
+                _this.saxParser.ended = true;
+                return _this.emit("end", _this.resultObject);
+              }
+            };
+          }(this);
+          this.saxParser.ended = false;
+          this.EXPLICIT_CHARKEY = this.options.explicitCharkey;
+          this.resultObject = null;
+          stack2 = [];
+          attrkey = this.options.attrkey;
+          charkey = this.options.charkey;
+          this.saxParser.onopentag = /* @__PURE__ */ function(_this) {
+            return function(node) {
+              var key, newValue, obj, processedKey, ref;
+              obj = {};
+              obj[charkey] = "";
+              if (!_this.options.ignoreAttrs) {
+                ref = node.attributes;
+                for (key in ref) {
+                  if (!hasProp.call(ref, key)) continue;
+                  if (!(attrkey in obj) && !_this.options.mergeAttrs) {
+                    obj[attrkey] = {};
+                  }
+                  newValue = _this.options.attrValueProcessors ? processItem(_this.options.attrValueProcessors, node.attributes[key], key) : node.attributes[key];
+                  processedKey = _this.options.attrNameProcessors ? processItem(_this.options.attrNameProcessors, key) : key;
+                  if (_this.options.mergeAttrs) {
+                    _this.assignOrPush(obj, processedKey, newValue);
+                  } else {
+                    defineProperty(obj[attrkey], processedKey, newValue);
+                  }
+                }
+              }
+              obj["#name"] = _this.options.tagNameProcessors ? processItem(_this.options.tagNameProcessors, node.name) : node.name;
+              if (_this.options.xmlns) {
+                obj[_this.options.xmlnskey] = {
+                  uri: node.uri,
+                  local: node.local
+                };
+              }
+              return stack2.push(obj);
+            };
+          }(this);
+          this.saxParser.onclosetag = /* @__PURE__ */ function(_this) {
+            return function() {
+              var cdata, emptyStr, key, node, nodeName, obj, objClone, old, s4, xpath;
+              obj = stack2.pop();
+              nodeName = obj["#name"];
+              if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder) {
+                delete obj["#name"];
+              }
+              if (obj.cdata === true) {
+                cdata = obj.cdata;
+                delete obj.cdata;
+              }
+              s4 = stack2[stack2.length - 1];
+              if (obj[charkey].match(/^\s*$/) && !cdata) {
+                emptyStr = obj[charkey];
+                delete obj[charkey];
+              } else {
+                if (_this.options.trim) {
+                  obj[charkey] = obj[charkey].trim();
+                }
+                if (_this.options.normalize) {
+                  obj[charkey] = obj[charkey].replace(/\s{2,}/g, " ").trim();
+                }
+                obj[charkey] = _this.options.valueProcessors ? processItem(_this.options.valueProcessors, obj[charkey], nodeName) : obj[charkey];
+                if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
+                  obj = obj[charkey];
+                }
+              }
+              if (isEmpty(obj)) {
+                if (typeof _this.options.emptyTag === "function") {
+                  obj = _this.options.emptyTag();
+                } else {
+                  obj = _this.options.emptyTag !== "" ? _this.options.emptyTag : emptyStr;
+                }
+              }
+              if (_this.options.validator != null) {
+                xpath = "/" + function() {
+                  var i7, len, results;
+                  results = [];
+                  for (i7 = 0, len = stack2.length; i7 < len; i7++) {
+                    node = stack2[i7];
+                    results.push(node["#name"]);
+                  }
+                  return results;
+                }().concat(nodeName).join("/");
+                (function() {
+                  var err;
+                  try {
+                    return obj = _this.options.validator(xpath, s4 && s4[nodeName], obj);
+                  } catch (error1) {
+                    err = error1;
+                    return _this.emit("error", err);
+                  }
+                })();
+              }
+              if (_this.options.explicitChildren && !_this.options.mergeAttrs && typeof obj === "object") {
+                if (!_this.options.preserveChildrenOrder) {
+                  node = {};
+                  if (_this.options.attrkey in obj) {
+                    node[_this.options.attrkey] = obj[_this.options.attrkey];
+                    delete obj[_this.options.attrkey];
+                  }
+                  if (!_this.options.charsAsChildren && _this.options.charkey in obj) {
+                    node[_this.options.charkey] = obj[_this.options.charkey];
+                    delete obj[_this.options.charkey];
+                  }
+                  if (Object.getOwnPropertyNames(obj).length > 0) {
+                    node[_this.options.childkey] = obj;
+                  }
+                  obj = node;
+                } else if (s4) {
+                  s4[_this.options.childkey] = s4[_this.options.childkey] || [];
+                  objClone = {};
+                  for (key in obj) {
+                    if (!hasProp.call(obj, key)) continue;
+                    defineProperty(objClone, key, obj[key]);
+                  }
+                  s4[_this.options.childkey].push(objClone);
+                  delete obj["#name"];
+                  if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
+                    obj = obj[charkey];
+                  }
+                }
+              }
+              if (stack2.length > 0) {
+                return _this.assignOrPush(s4, nodeName, obj);
+              } else {
+                if (_this.options.explicitRoot) {
+                  old = obj;
+                  obj = {};
+                  defineProperty(obj, nodeName, old);
+                }
+                _this.resultObject = obj;
+                _this.saxParser.ended = true;
+                return _this.emit("end", _this.resultObject);
+              }
+            };
+          }(this);
+          ontext = /* @__PURE__ */ function(_this) {
+            return function(text3) {
+              var charChild, s4;
+              s4 = stack2[stack2.length - 1];
+              if (s4) {
+                s4[charkey] += text3;
+                if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text3.replace(/\\n/g, "").trim() !== "")) {
+                  s4[_this.options.childkey] = s4[_this.options.childkey] || [];
+                  charChild = {
+                    "#name": "__text__"
+                  };
+                  charChild[charkey] = text3;
+                  if (_this.options.normalize) {
+                    charChild[charkey] = charChild[charkey].replace(/\s{2,}/g, " ").trim();
+                  }
+                  s4[_this.options.childkey].push(charChild);
+                }
+                return s4;
+              }
+            };
+          }(this);
+          this.saxParser.ontext = ontext;
+          return this.saxParser.oncdata = /* @__PURE__ */ function(_this) {
+            return function(text3) {
+              var s4;
+              s4 = ontext(text3);
+              if (s4) {
+                return s4.cdata = true;
+              }
+            };
+          }(this);
+        };
+        Parser4.prototype.parseString = function(str, cb) {
+          var err;
+          if (cb != null && typeof cb === "function") {
+            this.on("end", function(result) {
+              this.reset();
+              return cb(null, result);
+            });
+            this.on("error", function(err2) {
+              this.reset();
+              return cb(err2);
+            });
+          }
+          try {
+            str = str.toString();
+            if (str.trim() === "") {
+              this.emit("end", null);
+              return true;
+            }
+            str = bom.stripBOM(str);
+            if (this.options.async) {
+              this.remaining = str;
+              setImmediate2(this.processAsync);
+              return this.saxParser;
+            }
+            return this.saxParser.write(str).close();
+          } catch (error1) {
+            err = error1;
+            if (!(this.saxParser.errThrown || this.saxParser.ended)) {
+              this.emit("error", err);
+              return this.saxParser.errThrown = true;
+            } else if (this.saxParser.ended) {
+              throw err;
+            }
+          }
+        };
+        Parser4.prototype.parseStringPromise = function(str) {
+          return new Promise(/* @__PURE__ */ function(_this) {
+            return function(resolve28, reject) {
+              return _this.parseString(str, function(err, value) {
+                if (err) {
+                  return reject(err);
+                } else {
+                  return resolve28(value);
+                }
+              });
+            };
+          }(this));
+        };
+        return Parser4;
+      }(events);
+      exports2.parseString = function(str, a2, b) {
+        var cb, options, parser;
+        if (b != null) {
+          if (typeof b === "function") {
+            cb = b;
+          }
+          if (typeof a2 === "object") {
+            options = a2;
+          }
+        } else {
+          if (typeof a2 === "function") {
+            cb = a2;
+          }
+          options = {};
+        }
+        parser = new exports2.Parser(options);
+        return parser.parseString(str, cb);
+      };
+      exports2.parseStringPromise = function(str, a2) {
+        var options, parser;
+        if (typeof a2 === "object") {
+          options = a2;
+        }
+        parser = new exports2.Parser(options);
+        return parser.parseStringPromise(str);
+      };
+    }).call(exports2);
+  }
+});
+
+// ../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/xml2js.js
+var require_xml2js2 = __commonJS({
+  "../../node_modules/.pnpm/xml2js@0.6.2/node_modules/xml2js/lib/xml2js.js"(exports2) {
+    (function() {
+      "use strict";
+      var builder, defaults3, parser, processors, extend2 = function(child, parent2) {
+        for (var key in parent2) {
+          if (hasProp.call(parent2, key)) child[key] = parent2[key];
+        }
+        function ctor() {
+          this.constructor = child;
+        }
+        ctor.prototype = parent2.prototype;
+        child.prototype = new ctor();
+        child.__super__ = parent2.prototype;
+        return child;
+      }, hasProp = {}.hasOwnProperty;
+      defaults3 = require_defaults2();
+      builder = require_builder();
+      parser = require_parser3();
+      processors = require_processors();
+      exports2.defaults = defaults3.defaults;
+      exports2.processors = processors;
+      exports2.ValidationError = function(superClass) {
+        extend2(ValidationError, superClass);
+        function ValidationError(message2) {
+          this.message = message2;
+        }
+        return ValidationError;
+      }(Error);
+      exports2.Builder = builder.Builder;
+      exports2.Parser = parser.Parser;
+      exports2.parseString = parser.parseString;
+      exports2.parseStringPromise = parser.parseStringPromise;
+    }).call(exports2);
+  }
+});
+
 // ../../node_modules/.pnpm/@octokit+plugin-paginate-graphql@4.0.1_@octokit+core@5.2.0/node_modules/@octokit/plugin-paginate-graphql/dist-node/index.js
 var require_dist_node11 = __commonJS({
   "../../node_modules/.pnpm/@octokit+plugin-paginate-graphql@4.0.1_@octokit+core@5.2.0/node_modules/@octokit/plugin-paginate-graphql/dist-node/index.js"(exports2, module2) {
@@ -172579,14 +177022,14 @@ var PathBase = class {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root3, roots, nocase, children2, opts) {
+  constructor(name, type = UNKNOWN, root3, roots, nocase, children3, opts) {
     this.name = name;
     this.#matchName = nocase ? normalizeNocase(name) : normalize(name);
     this.#type = type & TYPEMASK;
     this.nocase = nocase;
     this.roots = roots;
     this.root = root3 || this;
-    this.#children = children2;
+    this.#children = children3;
     this.#fullpath = opts.fullpath;
     this.#relative = opts.relative;
     this.#relativePosix = opts.relativePosix;
@@ -172648,10 +177091,10 @@ var PathBase = class {
     if (cached) {
       return cached;
     }
-    const children2 = Object.assign([], { provisional: 0 });
-    this.#children.set(this, children2);
+    const children3 = Object.assign([], { provisional: 0 });
+    this.#children.set(this, children3);
     this.#type &= ~READDIR_CALLED;
-    return children2;
+    return children3;
   }
   /**
    * Resolves a path portion and returns or creates the child Path.
@@ -172673,9 +177116,9 @@ var PathBase = class {
     if (pathPart === "..") {
       return this.parent || this;
     }
-    const children2 = this.children();
+    const children3 = this.children();
     const name = this.nocase ? normalizeNocase(pathPart) : normalize(pathPart);
-    for (const p3 of children2) {
+    for (const p3 of children3) {
       if (p3.#matchName === name) {
         return p3;
       }
@@ -172690,7 +177133,7 @@ var PathBase = class {
     if (!this.canReaddir()) {
       pchild.#type |= ENOENT;
     }
-    children2.push(pchild);
+    children3.push(pchild);
     return pchild;
   }
   /**
@@ -172874,8 +177317,8 @@ var PathBase = class {
    * readdir() has been called recently enough to still be valid.
    */
   readdirCached() {
-    const children2 = this.children();
-    return children2.slice(0, children2.provisional);
+    const children3 = this.children();
+    return children3.slice(0, children3.provisional);
   }
   /**
    * Return true if it's worth trying to readlink.  Ie, we don't (yet) have
@@ -172976,10 +177419,10 @@ var PathBase = class {
       return void 0;
     }
   }
-  #readdirSuccess(children2) {
+  #readdirSuccess(children3) {
     this.#type |= READDIR_CALLED;
-    for (let p3 = children2.provisional; p3 < children2.length; p3++) {
-      const c2 = children2[p3];
+    for (let p3 = children3.provisional; p3 < children3.length; p3++) {
+      const c2 = children3[p3];
       if (c2)
         c2.#markENOENT();
     }
@@ -172991,9 +177434,9 @@ var PathBase = class {
     this.#markChildrenENOENT();
   }
   #markChildrenENOENT() {
-    const children2 = this.children();
-    children2.provisional = 0;
-    for (const p3 of children2) {
+    const children3 = this.children();
+    children3.provisional = 0;
+    for (const p3 of children3) {
       p3.#markENOENT();
     }
   }
@@ -173146,11 +177589,11 @@ var PathBase = class {
   }
   #onReaddirCB = [];
   #readdirCBInFlight = false;
-  #callOnReaddirCB(children2) {
+  #callOnReaddirCB(children3) {
     this.#readdirCBInFlight = false;
     const cbs = this.#onReaddirCB.slice();
     this.#onReaddirCB.length = 0;
-    cbs.forEach((cb) => cb(null, children2));
+    cbs.forEach((cb) => cb(null, children3));
   }
   /**
    * Standard node-style callback interface to get list of directory entries.
@@ -173176,9 +177619,9 @@ var PathBase = class {
         queueMicrotask(() => cb(null, []));
       return;
     }
-    const children2 = this.children();
+    const children3 = this.children();
     if (this.calledReaddir()) {
-      const c2 = children2.slice(0, children2.provisional);
+      const c2 = children3.slice(0, children3.provisional);
       if (allowZalgo)
         cb(null, c2);
       else
@@ -173194,14 +177637,14 @@ var PathBase = class {
     this.#fs.readdir(fullpath, { withFileTypes: true }, (er, entries) => {
       if (er) {
         this.#readdirFail(er.code);
-        children2.provisional = 0;
+        children3.provisional = 0;
       } else {
         for (const e of entries) {
-          this.#readdirAddChild(e, children2);
+          this.#readdirAddChild(e, children3);
         }
-        this.#readdirSuccess(children2);
+        this.#readdirSuccess(children3);
       }
-      this.#callOnReaddirCB(children2.slice(0, children2.provisional));
+      this.#callOnReaddirCB(children3.slice(0, children3.provisional));
       return;
     });
   }
@@ -173219,9 +177662,9 @@ var PathBase = class {
     if (!this.canReaddir()) {
       return [];
     }
-    const children2 = this.children();
+    const children3 = this.children();
     if (this.calledReaddir()) {
-      return children2.slice(0, children2.provisional);
+      return children3.slice(0, children3.provisional);
     }
     const fullpath = this.fullpath();
     if (this.#asyncReaddirInFlight) {
@@ -173234,17 +177677,17 @@ var PathBase = class {
         for (const e of await this.#fs.promises.readdir(fullpath, {
           withFileTypes: true
         })) {
-          this.#readdirAddChild(e, children2);
+          this.#readdirAddChild(e, children3);
         }
-        this.#readdirSuccess(children2);
+        this.#readdirSuccess(children3);
       } catch (er) {
         this.#readdirFail(er.code);
-        children2.provisional = 0;
+        children3.provisional = 0;
       }
       this.#asyncReaddirInFlight = void 0;
       resolve28();
     }
-    return children2.slice(0, children2.provisional);
+    return children3.slice(0, children3.provisional);
   }
   /**
    * synchronous {@link PathBase.readdir}
@@ -173253,23 +177696,23 @@ var PathBase = class {
     if (!this.canReaddir()) {
       return [];
     }
-    const children2 = this.children();
+    const children3 = this.children();
     if (this.calledReaddir()) {
-      return children2.slice(0, children2.provisional);
+      return children3.slice(0, children3.provisional);
     }
     const fullpath = this.fullpath();
     try {
       for (const e of this.#fs.readdirSync(fullpath, {
         withFileTypes: true
       })) {
-        this.#readdirAddChild(e, children2);
+        this.#readdirAddChild(e, children3);
       }
-      this.#readdirSuccess(children2);
+      this.#readdirSuccess(children3);
     } catch (er) {
       this.#readdirFail(er.code);
-      children2.provisional = 0;
+      children3.provisional = 0;
     }
-    return children2.slice(0, children2.provisional);
+    return children3.slice(0, children3.provisional);
   }
   canReaddir() {
     if (this.#type & ENOCHILD)
@@ -173363,8 +177806,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root3, roots, nocase, children2, opts) {
-    super(name, type, root3, roots, nocase, children2, opts);
+  constructor(name, type = UNKNOWN, root3, roots, nocase, children3, opts) {
+    super(name, type, root3, roots, nocase, children3, opts);
   }
   /**
    * @internal
@@ -173416,8 +177859,8 @@ var PathPosix = class _PathPosix extends PathBase {
    *
    * @internal
    */
-  constructor(name, type = UNKNOWN, root3, roots, nocase, children2, opts) {
-    super(name, type, root3, roots, nocase, children2, opts);
+  constructor(name, type = UNKNOWN, root3, roots, nocase, children3, opts) {
+    super(name, type, root3, roots, nocase, children3, opts);
   }
   /**
    * @internal
@@ -174287,13 +178730,13 @@ var Ignore = class {
       }
       const p3 = new Pattern(parsed, globParts, 0, this.platform);
       const m2 = new Minimatch(p3.globString(), this.mmopts);
-      const children2 = globParts[globParts.length - 1] === "**";
+      const children3 = globParts[globParts.length - 1] === "**";
       const absolute = p3.isAbsolute();
       if (absolute)
         this.absolute.push(m2);
       else
         this.relative.push(m2);
-      if (children2) {
+      if (children3) {
         if (absolute)
           this.absoluteChildren.push(m2);
         else
@@ -174781,8 +179224,8 @@ var GlobUtil = class {
         continue;
       }
       tasks++;
-      const children2 = t4.readdirSync();
-      this.walkCB3Sync(t4, children2, processor, next2);
+      const children3 = t4.readdirSync();
+      this.walkCB3Sync(t4, children3, processor, next2);
     }
     next2();
   }
@@ -180068,8 +184511,8 @@ function augmentWithParentsMap(d2) {
 }
 function computeParentsMap(d2) {
   const parentsMap = /* @__PURE__ */ new Map();
-  const addToMap = (children2, id) => {
-    children2?.forEach((dep) => {
+  const addToMap = (children3, id) => {
+    children3?.forEach((dep) => {
       if (!parentsMap.has(dep)) parentsMap.set(dep, []);
       parentsMap.get(dep).push(id);
     });
@@ -180414,9 +184857,9 @@ var NodeWithChildren = class extends Node {
   /**
    * @param children Children of the node. Only certain node types can have children.
    */
-  constructor(children2) {
+  constructor(children3) {
     super();
-    this.children = children2;
+    this.children = children3;
   }
   // Aliases
   /** First child of the node. */
@@ -180435,8 +184878,8 @@ var NodeWithChildren = class extends Node {
   get childNodes() {
     return this.children;
   }
-  set childNodes(children2) {
-    this.children = children2;
+  set childNodes(children3) {
+    this.children = children3;
   }
 };
 var CDATA2 = class extends NodeWithChildren {
@@ -180463,8 +184906,8 @@ var Element2 = class extends NodeWithChildren {
    * @param attribs Object mapping attribute names to attribute values.
    * @param children Children of the node.
    */
-  constructor(name, attribs, children2 = [], type = name === "script" ? ElementType.Script : name === "style" ? ElementType.Style : ElementType.Tag) {
-    super(children2);
+  constructor(name, attribs, children3 = [], type = name === "script" ? ElementType.Script : name === "style" ? ElementType.Style : ElementType.Tag) {
+    super(children3);
     this.name = name;
     this.attribs = attribs;
     this.type = type;
@@ -180523,9 +184966,9 @@ function cloneNode(node, recursive = false) {
   } else if (isComment(node)) {
     result = new Comment2(node.data);
   } else if (isTag2(node)) {
-    const children2 = recursive ? cloneChildren(node.children) : [];
-    const clone2 = new Element2(node.name, { ...node.attribs }, children2);
-    children2.forEach((child) => child.parent = clone2);
+    const children3 = recursive ? cloneChildren(node.children) : [];
+    const clone2 = new Element2(node.name, { ...node.attribs }, children3);
+    children3.forEach((child) => child.parent = clone2);
     if (node.namespace != null) {
       clone2.namespace = node.namespace;
     }
@@ -180537,14 +184980,14 @@ function cloneNode(node, recursive = false) {
     }
     result = clone2;
   } else if (isCDATA(node)) {
-    const children2 = recursive ? cloneChildren(node.children) : [];
-    const clone2 = new CDATA2(children2);
-    children2.forEach((child) => child.parent = clone2);
+    const children3 = recursive ? cloneChildren(node.children) : [];
+    const clone2 = new CDATA2(children3);
+    children3.forEach((child) => child.parent = clone2);
     result = clone2;
   } else if (isDocument(node)) {
-    const children2 = recursive ? cloneChildren(node.children) : [];
-    const clone2 = new Document(children2);
-    children2.forEach((child) => child.parent = clone2);
+    const children3 = recursive ? cloneChildren(node.children) : [];
+    const clone2 = new Document(children3);
+    children3.forEach((child) => child.parent = clone2);
     if (node["x-mode"]) {
       clone2["x-mode"] = node["x-mode"];
     }
@@ -180568,12 +185011,12 @@ function cloneNode(node, recursive = false) {
   return result;
 }
 function cloneChildren(childs) {
-  const children2 = childs.map((child) => cloneNode(child, true));
-  for (let i7 = 1; i7 < children2.length; i7++) {
-    children2[i7].prev = children2[i7 - 1];
-    children2[i7 - 1].next = children2[i7];
+  const children3 = childs.map((child) => cloneNode(child, true));
+  for (let i7 = 1; i7 < children3.length; i7++) {
+    children3[i7].prev = children3[i7 - 1];
+    children3[i7 - 1].next = children3[i7];
   }
-  return children2;
+  return children3;
 }
 
 // ../../node_modules/.pnpm/domhandler@5.0.3/node_modules/domhandler/lib/esm/index.js
@@ -181876,19 +186319,19 @@ function getAtomFeed(feedRoot) {
     type: "atom",
     items: getElementsByTagName("entry", childs).map((item) => {
       var _a3;
-      const { children: children2 } = item;
-      const entry = { media: getMediaElements(children2) };
-      addConditionally(entry, "id", "id", children2);
-      addConditionally(entry, "title", "title", children2);
-      const href2 = (_a3 = getOneElement("link", children2)) === null || _a3 === void 0 ? void 0 : _a3.attribs["href"];
+      const { children: children3 } = item;
+      const entry = { media: getMediaElements(children3) };
+      addConditionally(entry, "id", "id", children3);
+      addConditionally(entry, "title", "title", children3);
+      const href2 = (_a3 = getOneElement("link", children3)) === null || _a3 === void 0 ? void 0 : _a3.attribs["href"];
       if (href2) {
         entry.link = href2;
       }
-      const description = fetch2("summary", children2) || fetch2("content", children2);
+      const description = fetch2("summary", children3) || fetch2("content", children3);
       if (description) {
         entry.description = description;
       }
-      const pubDate = fetch2("updated", children2);
+      const pubDate = fetch2("updated", children3);
       if (pubDate) {
         entry.pubDate = new Date(pubDate);
       }
@@ -181916,13 +186359,13 @@ function getRssFeed(feedRoot) {
     type: feedRoot.name.substr(0, 3),
     id: "",
     items: getElementsByTagName("item", feedRoot.children).map((item) => {
-      const { children: children2 } = item;
-      const entry = { media: getMediaElements(children2) };
-      addConditionally(entry, "id", "guid", children2);
-      addConditionally(entry, "title", "title", children2);
-      addConditionally(entry, "link", "link", children2);
-      addConditionally(entry, "description", "description", children2);
-      const pubDate = fetch2("pubDate", children2) || fetch2("dc:date", children2);
+      const { children: children3 } = item;
+      const entry = { media: getMediaElements(children3) };
+      addConditionally(entry, "id", "guid", children3);
+      addConditionally(entry, "title", "title", children3);
+      addConditionally(entry, "link", "link", children3);
+      addConditionally(entry, "description", "description", children3);
+      const pubDate = fetch2("pubDate", children3) || fetch2("dc:date", children3);
       if (pubDate)
         entry.pubDate = new Date(pubDate);
       return entry;
@@ -182504,7 +186947,7 @@ var traversing_exports = {};
 __export(traversing_exports, {
   add: () => add,
   addBack: () => addBack,
-  children: () => children,
+  children: () => children2,
   closest: () => closest,
   contents: () => contents,
   each: () => each,
@@ -183843,7 +188286,7 @@ var prevAll = _matcher((elem) => {
 }, _removeDuplicates);
 var prevUntil = _matchUntil((el) => prevElementSibling(el), _removeDuplicates);
 var siblings = _matcher((elem) => getSiblings(elem).filter((el) => isTag2(el) && el !== elem), uniqueSort);
-var children = _matcher((elem) => getChildren(elem).filter(isTag2), _removeDuplicates);
+var children2 = _matcher((elem) => getChildren(elem).filter(isTag2), _removeDuplicates);
 function contents() {
   const elems = this.toArray().reduce((newElems, elem) => hasChildren(elem) ? newElems.concat(elem.children) : newElems, []);
   return this._make(elems);
@@ -184104,11 +188547,11 @@ function prependTo(target) {
   prependTarget.prepend(this);
   return this;
 }
-var append3 = _insert((dom, children2, parent2) => {
-  uniqueSplice(children2, children2.length, 0, dom, parent2);
+var append3 = _insert((dom, children3, parent2) => {
+  uniqueSplice(children3, children3.length, 0, dom, parent2);
 });
-var prepend2 = _insert((dom, children2, parent2) => {
-  uniqueSplice(children2, 0, 0, dom, parent2);
+var prepend2 = _insert((dom, children3, parent2) => {
+  uniqueSplice(children3, 0, 0, dom, parent2);
 });
 function _wrap(insert) {
   return function(wrapper) {
@@ -193714,6 +198157,7 @@ var { root: root2 } = static_exports;
 
 // ../utils/src/maven-utils.ts
 var import_lodash14 = __toESM(require_lodash(), 1);
+var import_xml2js = __toESM(require_xml2js2(), 1);
 import { existsSync as existsSync12, readdirSync as readdirSync5, statSync as statSync4 } from "fs";
 import { join as join16, resolve as resolve26 } from "path";
 var { memoize: memoize3 } = import_lodash14.default;
@@ -195039,7 +199483,7 @@ async function onlineScan(dependencyTree, apiKey, timeout) {
 }
 
 // dist/version.js
-var version2 = "14.8.6";
+var version2 = "14.8.7";
 
 // dist/cli-core.js
 var { omit, partition, pick } = import_lodash15.default;