@rqml/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,3625 @@
+#!/usr/bin/env node
+import { __commonJS, __toESM } from './chunk-5WRI5ZAA.js';
+import { existsSync, writeFileSync, readFileSync, readdirSync } from 'fs';
+import { resolve, isAbsolute } from 'path';
+import { fileURLToPath } from 'url';
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/util.js
+var require_util = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/util.js"(exports) {
+    var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
+    var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
+    var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
+    var regexName = new RegExp("^" + nameRegexp + "$");
+    var getAllMatches = function(string, regex) {
+      const matches = [];
+      let match = regex.exec(string);
+      while (match) {
+        const allmatches = [];
+        allmatches.startIndex = regex.lastIndex - match[0].length;
+        const len = match.length;
+        for (let index = 0; index < len; index++) {
+          allmatches.push(match[index]);
+        }
+        matches.push(allmatches);
+        match = regex.exec(string);
+      }
+      return matches;
+    };
+    var isName = function(string) {
+      const match = regexName.exec(string);
+      return !(match === null || typeof match === "undefined");
+    };
+    exports.isExist = function(v) {
+      return typeof v !== "undefined";
+    };
+    exports.isEmptyObject = function(obj) {
+      return Object.keys(obj).length === 0;
+    };
+    exports.merge = function(target, a, arrayMode) {
+      if (a) {
+        const keys = Object.keys(a);
+        const len = keys.length;
+        for (let i = 0; i < len; i++) {
+          if (arrayMode === "strict") {
+            target[keys[i]] = [a[keys[i]]];
+          } else {
+            target[keys[i]] = a[keys[i]];
+          }
+        }
+      }
+    };
+    exports.getValue = function(v) {
+      if (exports.isExist(v)) {
+        return v;
+      } else {
+        return "";
+      }
+    };
+    var DANGEROUS_PROPERTY_NAMES = [
+      // '__proto__',
+      // 'constructor',
+      // 'prototype',
+      "hasOwnProperty",
+      "toString",
+      "valueOf",
+      "__defineGetter__",
+      "__defineSetter__",
+      "__lookupGetter__",
+      "__lookupSetter__"
+    ];
+    var criticalProperties = ["__proto__", "constructor", "prototype"];
+    exports.isName = isName;
+    exports.getAllMatches = getAllMatches;
+    exports.nameRegexp = nameRegexp;
+    exports.DANGEROUS_PROPERTY_NAMES = DANGEROUS_PROPERTY_NAMES;
+    exports.criticalProperties = criticalProperties;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/validator.js
+var require_validator = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/validator.js"(exports) {
+    var util = require_util();
+    var defaultOptions = {
+      allowBooleanAttributes: false,
+      //A tag can have attributes without any value
+      unpairedTags: []
+    };
+    exports.validate = function(xmlData, options) {
+      options = Object.assign({}, defaultOptions, options);
+      const tags = [];
+      let tagFound = false;
+      let reachedRoot = false;
+      if (xmlData[0] === "\uFEFF") {
+        xmlData = xmlData.substr(1);
+      }
+      for (let i = 0; i < xmlData.length; i++) {
+        if (xmlData[i] === "<" && xmlData[i + 1] === "?") {
+          i += 2;
+          i = readPI(xmlData, i);
+          if (i.err) return i;
+        } else if (xmlData[i] === "<") {
+          let tagStartPos = i;
+          i++;
+          if (xmlData[i] === "!") {
+            i = readCommentAndCDATA(xmlData, i);
+            continue;
+          } else {
+            let closingTag = false;
+            if (xmlData[i] === "/") {
+              closingTag = true;
+              i++;
+            }
+            let tagName = "";
+            for (; i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== "	" && xmlData[i] !== "\n" && xmlData[i] !== "\r"; i++) {
+              tagName += xmlData[i];
+            }
+            tagName = tagName.trim();
+            if (tagName[tagName.length - 1] === "/") {
+              tagName = tagName.substring(0, tagName.length - 1);
+              i--;
+            }
+            if (!validateTagName(tagName)) {
+              let msg;
+              if (tagName.trim().length === 0) {
+                msg = "Invalid space after '<'.";
+              } else {
+                msg = "Tag '" + tagName + "' is an invalid name.";
+              }
+              return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i));
+            }
+            const result = readAttributeStr(xmlData, i);
+            if (result === false) {
+              return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i));
+            }
+            let attrStr = result.value;
+            i = result.index;
+            if (attrStr[attrStr.length - 1] === "/") {
+              const attrStrStart = i - attrStr.length;
+              attrStr = attrStr.substring(0, attrStr.length - 1);
+              const isValid = validateAttributeString(attrStr, options);
+              if (isValid === true) {
+                tagFound = true;
+              } else {
+                return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));
+              }
+            } else if (closingTag) {
+              if (!result.tagClosed) {
+                return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
+              } else if (attrStr.trim().length > 0) {
+                return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
+              } else if (tags.length === 0) {
+                return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
+              } else {
+                const otg = tags.pop();
+                if (tagName !== otg.tagName) {
+                  let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
+                  return getErrorObject(
+                    "InvalidTag",
+                    "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.",
+                    getLineNumberForPosition(xmlData, tagStartPos)
+                  );
+                }
+                if (tags.length == 0) {
+                  reachedRoot = true;
+                }
+              }
+            } else {
+              const isValid = validateAttributeString(attrStr, options);
+              if (isValid !== true) {
+                return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
+              }
+              if (reachedRoot === true) {
+                return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i));
+              } else if (options.unpairedTags.indexOf(tagName) !== -1) ; else {
+                tags.push({ tagName, tagStartPos });
+              }
+              tagFound = true;
+            }
+            for (i++; i < xmlData.length; i++) {
+              if (xmlData[i] === "<") {
+                if (xmlData[i + 1] === "!") {
+                  i++;
+                  i = readCommentAndCDATA(xmlData, i);
+                  continue;
+                } else if (xmlData[i + 1] === "?") {
+                  i = readPI(xmlData, ++i);
+                  if (i.err) return i;
+                } else {
+                  break;
+                }
+              } else if (xmlData[i] === "&") {
+                const afterAmp = validateAmpersand(xmlData, i);
+                if (afterAmp == -1)
+                  return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
+                i = afterAmp;
+              } else {
+                if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {
+                  return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i));
+                }
+              }
+            }
+            if (xmlData[i] === "<") {
+              i--;
+            }
+          }
+        } else {
+          if (isWhiteSpace(xmlData[i])) {
+            continue;
+          }
+          return getErrorObject("InvalidChar", "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i));
+        }
+      }
+      if (!tagFound) {
+        return getErrorObject("InvalidXml", "Start tag expected.", 1);
+      } else if (tags.length == 1) {
+        return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
+      } else if (tags.length > 0) {
+        return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
+      }
+      return true;
+    };
+    function isWhiteSpace(char) {
+      return char === " " || char === "	" || char === "\n" || char === "\r";
+    }
+    function readPI(xmlData, i) {
+      const start = i;
+      for (; i < xmlData.length; i++) {
+        if (xmlData[i] == "?" || xmlData[i] == " ") {
+          const tagname = xmlData.substr(start, i - start);
+          if (i > 5 && tagname === "xml") {
+            return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i));
+          } else if (xmlData[i] == "?" && xmlData[i + 1] == ">") {
+            i++;
+            break;
+          } else {
+            continue;
+          }
+        }
+      }
+      return i;
+    }
+    function readCommentAndCDATA(xmlData, i) {
+      if (xmlData.length > i + 5 && xmlData[i + 1] === "-" && xmlData[i + 2] === "-") {
+        for (i += 3; i < xmlData.length; i++) {
+          if (xmlData[i] === "-" && xmlData[i + 1] === "-" && xmlData[i + 2] === ">") {
+            i += 2;
+            break;
+          }
+        }
+      } else if (xmlData.length > i + 8 && xmlData[i + 1] === "D" && xmlData[i + 2] === "O" && xmlData[i + 3] === "C" && xmlData[i + 4] === "T" && xmlData[i + 5] === "Y" && xmlData[i + 6] === "P" && xmlData[i + 7] === "E") {
+        let angleBracketsCount = 1;
+        for (i += 8; i < xmlData.length; i++) {
+          if (xmlData[i] === "<") {
+            angleBracketsCount++;
+          } else if (xmlData[i] === ">") {
+            angleBracketsCount--;
+            if (angleBracketsCount === 0) {
+              break;
+            }
+          }
+        }
+      } else if (xmlData.length > i + 9 && xmlData[i + 1] === "[" && xmlData[i + 2] === "C" && xmlData[i + 3] === "D" && xmlData[i + 4] === "A" && xmlData[i + 5] === "T" && xmlData[i + 6] === "A" && xmlData[i + 7] === "[") {
+        for (i += 8; i < xmlData.length; i++) {
+          if (xmlData[i] === "]" && xmlData[i + 1] === "]" && xmlData[i + 2] === ">") {
+            i += 2;
+            break;
+          }
+        }
+      }
+      return i;
+    }
+    var doubleQuote = '"';
+    var singleQuote = "'";
+    function readAttributeStr(xmlData, i) {
+      let attrStr = "";
+      let startChar = "";
+      let tagClosed = false;
+      for (; i < xmlData.length; i++) {
+        if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
+          if (startChar === "") {
+            startChar = xmlData[i];
+          } else if (startChar !== xmlData[i]) ; else {
+            startChar = "";
+          }
+        } else if (xmlData[i] === ">") {
+          if (startChar === "") {
+            tagClosed = true;
+            break;
+          }
+        }
+        attrStr += xmlData[i];
+      }
+      if (startChar !== "") {
+        return false;
+      }
+      return {
+        value: attrStr,
+        index: i,
+        tagClosed
+      };
+    }
+    var validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
+    function validateAttributeString(attrStr, options) {
+      const matches = util.getAllMatches(attrStr, validAttrStrRegxp);
+      const attrNames = {};
+      for (let i = 0; i < matches.length; i++) {
+        if (matches[i][1].length === 0) {
+          return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i]));
+        } else if (matches[i][3] !== void 0 && matches[i][4] === void 0) {
+          return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i]));
+        } else if (matches[i][3] === void 0 && !options.allowBooleanAttributes) {
+          return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i]));
+        }
+        const attrName = matches[i][2];
+        if (!validateAttrName(attrName)) {
+          return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i]));
+        }
+        if (!attrNames.hasOwnProperty(attrName)) {
+          attrNames[attrName] = 1;
+        } else {
+          return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i]));
+        }
+      }
+      return true;
+    }
+    function validateNumberAmpersand(xmlData, i) {
+      let re = /\d/;
+      if (xmlData[i] === "x") {
+        i++;
+        re = /[\da-fA-F]/;
+      }
+      for (; i < xmlData.length; i++) {
+        if (xmlData[i] === ";")
+          return i;
+        if (!xmlData[i].match(re))
+          break;
+      }
+      return -1;
+    }
+    function validateAmpersand(xmlData, i) {
+      i++;
+      if (xmlData[i] === ";")
+        return -1;
+      if (xmlData[i] === "#") {
+        i++;
+        return validateNumberAmpersand(xmlData, i);
+      }
+      let count = 0;
+      for (; i < xmlData.length; i++, count++) {
+        if (xmlData[i].match(/\w/) && count < 20)
+          continue;
+        if (xmlData[i] === ";")
+          break;
+        return -1;
+      }
+      return i;
+    }
+    function getErrorObject(code, message, lineNumber) {
+      return {
+        err: {
+          code,
+          msg: message,
+          line: lineNumber.line || lineNumber,
+          col: lineNumber.col
+        }
+      };
+    }
+    function validateAttrName(attrName) {
+      return util.isName(attrName);
+    }
+    function validateTagName(tagname) {
+      return util.isName(tagname);
+    }
+    function getLineNumberForPosition(xmlData, index) {
+      const lines = xmlData.substring(0, index).split(/\r?\n/);
+      return {
+        line: lines.length,
+        // column number is last line's length + 1, because column numbering starts at 1:
+        col: lines[lines.length - 1].length + 1
+      };
+    }
+    function getPositionFromMatch(match) {
+      return match.startIndex + match[1].length;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+var require_OptionsBuilder = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js"(exports) {
+    var { DANGEROUS_PROPERTY_NAMES, criticalProperties } = require_util();
+    var defaultOnDangerousProperty = (name) => {
+      if (DANGEROUS_PROPERTY_NAMES.includes(name)) {
+        return "__" + name;
+      }
+      return name;
+    };
+    var defaultOptions = {
+      preserveOrder: false,
+      attributeNamePrefix: "@_",
+      attributesGroupName: false,
+      textNodeName: "#text",
+      ignoreAttributes: true,
+      removeNSPrefix: false,
+      // remove NS from tag name or attribute name if true
+      allowBooleanAttributes: false,
+      //a tag can have attributes without any value
+      //ignoreRootElement : false,
+      parseTagValue: true,
+      parseAttributeValue: false,
+      trimValues: true,
+      //Trim string values of tag and attributes
+      cdataPropName: false,
+      numberParseOptions: {
+        hex: true,
+        leadingZeros: true,
+        eNotation: true
+      },
+      tagValueProcessor: function(tagName, val) {
+        return val;
+      },
+      attributeValueProcessor: function(attrName, val) {
+        return val;
+      },
+      stopNodes: [],
+      //nested tags will not be parsed even for errors
+      alwaysCreateTextNode: false,
+      isArray: () => false,
+      commentPropName: false,
+      unpairedTags: [],
+      processEntities: true,
+      htmlEntities: false,
+      ignoreDeclaration: false,
+      ignorePiTags: false,
+      transformTagName: false,
+      transformAttributeName: false,
+      updateTag: function(tagName, jPath, attrs) {
+        return tagName;
+      },
+      // skipEmptyListItem: false
+      captureMetaData: false,
+      maxNestedTags: 100,
+      strictReservedNames: true,
+      onDangerousProperty: defaultOnDangerousProperty
+    };
+    function validatePropertyName(propertyName, optionName) {
+      if (typeof propertyName !== "string") {
+        return;
+      }
+      const normalized = propertyName.toLowerCase();
+      if (DANGEROUS_PROPERTY_NAMES.some((dangerous) => normalized === dangerous.toLowerCase())) {
+        throw new Error(
+          `[SECURITY] Invalid ${optionName}: "${propertyName}" is a reserved JavaScript keyword that could cause prototype pollution`
+        );
+      }
+      if (criticalProperties.some((dangerous) => normalized === dangerous.toLowerCase())) {
+        throw new Error(
+          `[SECURITY] Invalid ${optionName}: "${propertyName}" is a reserved JavaScript keyword that could cause prototype pollution`
+        );
+      }
+    }
+    function normalizeProcessEntities(value) {
+      if (typeof value === "boolean") {
+        return {
+          enabled: value,
+          // true or false
+          maxEntitySize: 1e4,
+          maxExpansionDepth: 10,
+          maxTotalExpansions: 1e3,
+          maxExpandedLength: 1e5,
+          allowedTags: null,
+          tagFilter: null
+        };
+      }
+      if (typeof value === "object" && value !== null) {
+        return {
+          enabled: value.enabled !== false,
+          maxEntitySize: Math.max(1, value.maxEntitySize ?? 1e4),
+          maxExpansionDepth: Math.max(1, value.maxExpansionDepth ?? 1e4),
+          maxTotalExpansions: Math.max(1, value.maxTotalExpansions ?? Infinity),
+          maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 1e5),
+          maxEntityCount: Math.max(1, value.maxEntityCount ?? 1e3),
+          allowedTags: value.allowedTags ?? null,
+          tagFilter: value.tagFilter ?? null
+        };
+      }
+      return normalizeProcessEntities(true);
+    }
+    var buildOptions = function(options) {
+      const built = Object.assign({}, defaultOptions, options);
+      const propertyNameOptions = [
+        { value: built.attributeNamePrefix, name: "attributeNamePrefix" },
+        { value: built.attributesGroupName, name: "attributesGroupName" },
+        { value: built.textNodeName, name: "textNodeName" },
+        { value: built.cdataPropName, name: "cdataPropName" },
+        { value: built.commentPropName, name: "commentPropName" }
+      ];
+      for (const { value, name } of propertyNameOptions) {
+        if (value) {
+          validatePropertyName(value, name);
+        }
+      }
+      if (built.onDangerousProperty === null) {
+        built.onDangerousProperty = defaultOnDangerousProperty;
+      }
+      built.processEntities = normalizeProcessEntities(built.processEntities);
+      return built;
+    };
+    exports.buildOptions = buildOptions;
+    exports.defaultOptions = defaultOptions;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
+var require_xmlNode = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js"(exports, module) {
+    var XmlNode = class {
+      constructor(tagname) {
+        this.tagname = tagname;
+        this.child = [];
+        this[":@"] = {};
+      }
+      add(key, val) {
+        if (key === "__proto__") key = "#__proto__";
+        this.child.push({ [key]: val });
+      }
+      addChild(node) {
+        if (node.tagname === "__proto__") node.tagname = "#__proto__";
+        if (node[":@"] && Object.keys(node[":@"]).length > 0) {
+          this.child.push({ [node.tagname]: node.child, [":@"]: node[":@"] });
+        } else {
+          this.child.push({ [node.tagname]: node.child });
+        }
+      }
+    };
+    module.exports = XmlNode;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
+var require_DocTypeReader = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js"(exports, module) {
+    var util = require_util();
+    var DocTypeReader = class {
+      constructor(options) {
+        this.suppressValidationErr = !options;
+        this.options = options || {};
+      }
+      readDocType(xmlData, i) {
+        const entities = /* @__PURE__ */ Object.create(null);
+        let entityCount = 0;
+        if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") {
+          i = i + 9;
+          let angleBracketsCount = 1;
+          let hasBody = false, comment = false;
+          let exp = "";
+          for (; i < xmlData.length; i++) {
+            if (xmlData[i] === "<" && !comment) {
+              if (hasBody && hasSeq(xmlData, "!ENTITY", i)) {
+                i += 7;
+                let entityName, val;
+                [entityName, val, i] = this.readEntityExp(xmlData, i + 1, this.suppressValidationErr);
+                if (val.indexOf("&") === -1) {
+                  if (this.options.enabled !== false && this.options.maxEntityCount != null && entityCount >= this.options.maxEntityCount) {
+                    throw new Error(
+                      `Entity count (${entityCount + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`
+                    );
+                  }
+                  const escaped = entityName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                  entities[entityName] = {
+                    regx: RegExp(`&${escaped};`, "g"),
+                    val
+                  };
+                  entityCount++;
+                }
+              } else if (hasBody && hasSeq(xmlData, "!ELEMENT", i)) {
+                i += 8;
+                const { index } = this.readElementExp(xmlData, i + 1);
+                i = index;
+              } else if (hasBody && hasSeq(xmlData, "!ATTLIST", i)) {
+                i += 8;
+              } else if (hasBody && hasSeq(xmlData, "!NOTATION", i)) {
+                i += 9;
+                const { index } = this.readNotationExp(xmlData, i + 1, this.suppressValidationErr);
+                i = index;
+              } else if (hasSeq(xmlData, "!--", i)) {
+                comment = true;
+              } else {
+                throw new Error(`Invalid DOCTYPE`);
+              }
+              angleBracketsCount++;
+              exp = "";
+            } else if (xmlData[i] === ">") {
+              if (comment) {
+                if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") {
+                  comment = false;
+                  angleBracketsCount--;
+                }
+              } else {
+                angleBracketsCount--;
+              }
+              if (angleBracketsCount === 0) {
+                break;
+              }
+            } else if (xmlData[i] === "[") {
+              hasBody = true;
+            } else {
+              exp += xmlData[i];
+            }
+          }
+          if (angleBracketsCount !== 0) {
+            throw new Error(`Unclosed DOCTYPE`);
+          }
+        } else {
+          throw new Error(`Invalid Tag instead of DOCTYPE`);
+        }
+        return { entities, i };
+      }
+      readEntityExp(xmlData, i) {
+        i = skipWhitespace(xmlData, i);
+        let entityName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i]) && xmlData[i] !== '"' && xmlData[i] !== "'") {
+          entityName += xmlData[i];
+          i++;
+        }
+        validateEntityName(entityName);
+        i = skipWhitespace(xmlData, i);
+        if (!this.suppressValidationErr) {
+          if (xmlData.substring(i, i + 6).toUpperCase() === "SYSTEM") {
+            throw new Error("External entities are not supported");
+          } else if (xmlData[i] === "%") {
+            throw new Error("Parameter entities are not supported");
+          }
+        }
+        let entityValue = "";
+        [i, entityValue] = this.readIdentifierVal(xmlData, i, "entity");
+        if (this.options.enabled !== false && this.options.maxEntitySize != null && entityValue.length > this.options.maxEntitySize) {
+          throw new Error(
+            `Entity "${entityName}" size (${entityValue.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`
+          );
+        }
+        i--;
+        return [entityName, entityValue, i];
+      }
+      readNotationExp(xmlData, i) {
+        i = skipWhitespace(xmlData, i);
+        let notationName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+          notationName += xmlData[i];
+          i++;
+        }
+        !this.suppressValidationErr && validateEntityName(notationName);
+        i = skipWhitespace(xmlData, i);
+        const identifierType = xmlData.substring(i, i + 6).toUpperCase();
+        if (!this.suppressValidationErr && identifierType !== "SYSTEM" && identifierType !== "PUBLIC") {
+          throw new Error(`Expected SYSTEM or PUBLIC, found "${identifierType}"`);
+        }
+        i += identifierType.length;
+        i = skipWhitespace(xmlData, i);
+        let publicIdentifier = null;
+        let systemIdentifier = null;
+        if (identifierType === "PUBLIC") {
+          [i, publicIdentifier] = this.readIdentifierVal(xmlData, i, "publicIdentifier");
+          i = skipWhitespace(xmlData, i);
+          if (xmlData[i] === '"' || xmlData[i] === "'") {
+            [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
+          }
+        } else if (identifierType === "SYSTEM") {
+          [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, "systemIdentifier");
+          if (!this.suppressValidationErr && !systemIdentifier) {
+            throw new Error("Missing mandatory system identifier for SYSTEM notation");
+          }
+        }
+        return { notationName, publicIdentifier, systemIdentifier, index: --i };
+      }
+      readIdentifierVal(xmlData, i, type) {
+        let identifierVal = "";
+        const startChar = xmlData[i];
+        if (startChar !== '"' && startChar !== "'") {
+          throw new Error(`Expected quoted string, found "${startChar}"`);
+        }
+        i++;
+        while (i < xmlData.length && xmlData[i] !== startChar) {
+          identifierVal += xmlData[i];
+          i++;
+        }
+        if (xmlData[i] !== startChar) {
+          throw new Error(`Unterminated ${type} value`);
+        }
+        i++;
+        return [i, identifierVal];
+      }
+      readElementExp(xmlData, i) {
+        i = skipWhitespace(xmlData, i);
+        let elementName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+          elementName += xmlData[i];
+          i++;
+        }
+        if (!this.suppressValidationErr && !util.isName(elementName)) {
+          throw new Error(`Invalid element name: "${elementName}"`);
+        }
+        i = skipWhitespace(xmlData, i);
+        let contentModel = "";
+        if (xmlData[i] === "E" && hasSeq(xmlData, "MPTY", i)) {
+          i += 4;
+        } else if (xmlData[i] === "A" && hasSeq(xmlData, "NY", i)) {
+          i += 2;
+        } else if (xmlData[i] === "(") {
+          i++;
+          while (i < xmlData.length && xmlData[i] !== ")") {
+            contentModel += xmlData[i];
+            i++;
+          }
+          if (xmlData[i] !== ")") {
+            throw new Error("Unterminated content model");
+          }
+        } else if (!this.suppressValidationErr) {
+          throw new Error(`Invalid Element Expression, found "${xmlData[i]}"`);
+        }
+        return {
+          elementName,
+          contentModel: contentModel.trim(),
+          index: i
+        };
+      }
+      readAttlistExp(xmlData, i) {
+        i = skipWhitespace(xmlData, i);
+        let elementName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+          elementName += xmlData[i];
+          i++;
+        }
+        validateEntityName(elementName);
+        i = skipWhitespace(xmlData, i);
+        let attributeName = "";
+        while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+          attributeName += xmlData[i];
+          i++;
+        }
+        if (!validateEntityName(attributeName)) {
+          throw new Error(`Invalid attribute name: "${attributeName}"`);
+        }
+        i = skipWhitespace(xmlData, i);
+        let attributeType = "";
+        if (xmlData.substring(i, i + 8).toUpperCase() === "NOTATION") {
+          attributeType = "NOTATION";
+          i += 8;
+          i = skipWhitespace(xmlData, i);
+          if (xmlData[i] !== "(") {
+            throw new Error(`Expected '(', found "${xmlData[i]}"`);
+          }
+          i++;
+          let allowedNotations = [];
+          while (i < xmlData.length && xmlData[i] !== ")") {
+            let notation = "";
+            while (i < xmlData.length && xmlData[i] !== "|" && xmlData[i] !== ")") {
+              notation += xmlData[i];
+              i++;
+            }
+            notation = notation.trim();
+            if (!validateEntityName(notation)) {
+              throw new Error(`Invalid notation name: "${notation}"`);
+            }
+            allowedNotations.push(notation);
+            if (xmlData[i] === "|") {
+              i++;
+              i = skipWhitespace(xmlData, i);
+            }
+          }
+          if (xmlData[i] !== ")") {
+            throw new Error("Unterminated list of notations");
+          }
+          i++;
+          attributeType += " (" + allowedNotations.join("|") + ")";
+        } else {
+          while (i < xmlData.length && !/\s/.test(xmlData[i])) {
+            attributeType += xmlData[i];
+            i++;
+          }
+          const validTypes = ["CDATA", "ID", "IDREF", "IDREFS", "ENTITY", "ENTITIES", "NMTOKEN", "NMTOKENS"];
+          if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {
+            throw new Error(`Invalid attribute type: "${attributeType}"`);
+          }
+        }
+        i = skipWhitespace(xmlData, i);
+        let defaultValue = "";
+        if (xmlData.substring(i, i + 8).toUpperCase() === "#REQUIRED") {
+          defaultValue = "#REQUIRED";
+          i += 8;
+        } else if (xmlData.substring(i, i + 7).toUpperCase() === "#IMPLIED") {
+          defaultValue = "#IMPLIED";
+          i += 7;
+        } else {
+          [i, defaultValue] = this.readIdentifierVal(xmlData, i, "ATTLIST");
+        }
+        return {
+          elementName,
+          attributeName,
+          attributeType,
+          defaultValue,
+          index: i
+        };
+      }
+    };
+    var skipWhitespace = (data, index) => {
+      while (index < data.length && /\s/.test(data[index])) {
+        index++;
+      }
+      return index;
+    };
+    function hasSeq(data, seq, i) {
+      for (let j = 0; j < seq.length; j++) {
+        if (seq[j] !== data[i + j + 1]) return false;
+      }
+      return true;
+    }
+    function validateEntityName(name) {
+      if (util.isName(name))
+        return name;
+      else
+        throw new Error(`Invalid entity name ${name}`);
+    }
+    module.exports = DocTypeReader;
+  }
+});
+
+// ../../node_modules/.pnpm/strnum@1.1.2/node_modules/strnum/strnum.js
+var require_strnum = __commonJS({
+  "../../node_modules/.pnpm/strnum@1.1.2/node_modules/strnum/strnum.js"(exports, module) {
+    var hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
+    var numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
+    var consider = {
+      hex: true,
+      // oct: false,
+      leadingZeros: true,
+      decimalPoint: ".",
+      eNotation: true
+      //skipLike: /regex/
+    };
+    function toNumber(str2, options = {}) {
+      options = Object.assign({}, consider, options);
+      if (!str2 || typeof str2 !== "string") return str2;
+      let trimmedStr = str2.trim();
+      if (options.skipLike !== void 0 && options.skipLike.test(trimmedStr)) return str2;
+      else if (str2 === "0") return 0;
+      else if (options.hex && hexRegex.test(trimmedStr)) {
+        return parse_int(trimmedStr, 16);
+      } else if (trimmedStr.search(/[eE]/) !== -1) {
+        const notation = trimmedStr.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)$/);
+        if (notation) {
+          if (options.leadingZeros) {
+            trimmedStr = (notation[1] || "") + notation[3];
+          } else {
+            if (notation[2] === "0" && notation[3][0] === ".") ; else {
+              return str2;
+            }
+          }
+          return options.eNotation ? Number(trimmedStr) : str2;
+        } else {
+          return str2;
+        }
+      } else {
+        const match = numRegex.exec(trimmedStr);
+        if (match) {
+          const sign = match[1];
+          const leadingZeros = match[2];
+          let numTrimmedByZeros = trimZeros(match[3]);
+          if (!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str2;
+          else if (!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str2;
+          else if (options.leadingZeros && leadingZeros === str2) return 0;
+          else {
+            const num = Number(trimmedStr);
+            const numStr = "" + num;
+            if (numStr.search(/[eE]/) !== -1) {
+              if (options.eNotation) return num;
+              else return str2;
+            } else if (trimmedStr.indexOf(".") !== -1) {
+              if (numStr === "0" && numTrimmedByZeros === "") return num;
+              else if (numStr === numTrimmedByZeros) return num;
+              else if (sign && numStr === "-" + numTrimmedByZeros) return num;
+              else return str2;
+            }
+            if (leadingZeros) {
+              return numTrimmedByZeros === numStr || sign + numTrimmedByZeros === numStr ? num : str2;
+            } else {
+              return trimmedStr === numStr || trimmedStr === sign + numStr ? num : str2;
+            }
+          }
+        } else {
+          return str2;
+        }
+      }
+    }
+    function trimZeros(numStr) {
+      if (numStr && numStr.indexOf(".") !== -1) {
+        numStr = numStr.replace(/0+$/, "");
+        if (numStr === ".") numStr = "0";
+        else if (numStr[0] === ".") numStr = "0" + numStr;
+        else if (numStr[numStr.length - 1] === ".") numStr = numStr.substr(0, numStr.length - 1);
+        return numStr;
+      }
+      return numStr;
+    }
+    function parse_int(numStr, base) {
+      if (parseInt) return parseInt(numStr, base);
+      else if (Number.parseInt) return Number.parseInt(numStr, base);
+      else if (window && window.parseInt) return window.parseInt(numStr, base);
+      else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
+    }
+    module.exports = toNumber;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/ignoreAttributes.js
+var require_ignoreAttributes = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/ignoreAttributes.js"(exports, module) {
+    function getIgnoreAttributesFn(ignoreAttributes) {
+      if (typeof ignoreAttributes === "function") {
+        return ignoreAttributes;
+      }
+      if (Array.isArray(ignoreAttributes)) {
+        return (attrName) => {
+          for (const pattern of ignoreAttributes) {
+            if (typeof pattern === "string" && attrName === pattern) {
+              return true;
+            }
+            if (pattern instanceof RegExp && pattern.test(attrName)) {
+              return true;
+            }
+          }
+        };
+      }
+      return () => false;
+    }
+    module.exports = getIgnoreAttributesFn;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
+var require_OrderedObjParser = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js"(exports, module) {
+    var util = require_util();
+    var xmlNode = require_xmlNode();
+    var DocTypeReader = require_DocTypeReader();
+    var toNumber = require_strnum();
+    var getIgnoreAttributesFn = require_ignoreAttributes();
+    var OrderedObjParser = class {
+      constructor(options) {
+        this.options = options;
+        this.currentNode = null;
+        this.tagsNodeStack = [];
+        this.docTypeEntities = {};
+        this.lastEntities = {
+          "apos": { regex: /&(apos|#39|#x27);/g, val: "'" },
+          "gt": { regex: /&(gt|#62|#x3E);/g, val: ">" },
+          "lt": { regex: /&(lt|#60|#x3C);/g, val: "<" },
+          "quot": { regex: /&(quot|#34|#x22);/g, val: '"' }
+        };
+        this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" };
+        this.htmlEntities = {
+          "space": { regex: /&(nbsp|#160);/g, val: " " },
+          // "lt" : { regex: /&(lt|#60);/g, val: "<" },
+          // "gt" : { regex: /&(gt|#62);/g, val: ">" },
+          // "amp" : { regex: /&(amp|#38);/g, val: "&" },
+          // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
+          // "apos" : { regex: /&(apos|#39);/g, val: "'" },
+          "cent": { regex: /&(cent|#162);/g, val: "\xA2" },
+          "pound": { regex: /&(pound|#163);/g, val: "\xA3" },
+          "yen": { regex: /&(yen|#165);/g, val: "\xA5" },
+          "euro": { regex: /&(euro|#8364);/g, val: "\u20AC" },
+          "copyright": { regex: /&(copy|#169);/g, val: "\xA9" },
+          "reg": { regex: /&(reg|#174);/g, val: "\xAE" },
+          "inr": { regex: /&(inr|#8377);/g, val: "\u20B9" },
+          "num_dec": { regex: /&#([0-9]{1,7});/g, val: (_, str2) => fromCodePoint(str2, 10, "&#") },
+          "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str2) => fromCodePoint(str2, 16, "&#x") }
+        };
+        this.addExternalEntities = addExternalEntities;
+        this.parseXml = parseXml;
+        this.parseTextData = parseTextData;
+        this.resolveNameSpace = resolveNameSpace;
+        this.buildAttributesMap = buildAttributesMap;
+        this.isItStopNode = isItStopNode;
+        this.replaceEntitiesValue = replaceEntitiesValue;
+        this.readStopNodeData = readStopNodeData;
+        this.saveTextToParentTag = saveTextToParentTag;
+        this.addChild = addChild;
+        this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
+        this.entityExpansionCount = 0;
+        this.currentExpandedLength = 0;
+        if (this.options.stopNodes && this.options.stopNodes.length > 0) {
+          this.stopNodesExact = /* @__PURE__ */ new Set();
+          this.stopNodesWildcard = /* @__PURE__ */ new Set();
+          for (let i = 0; i < this.options.stopNodes.length; i++) {
+            const stopNodeExp = this.options.stopNodes[i];
+            if (typeof stopNodeExp !== "string") continue;
+            if (stopNodeExp.startsWith("*.")) {
+              this.stopNodesWildcard.add(stopNodeExp.substring(2));
+            } else {
+              this.stopNodesExact.add(stopNodeExp);
+            }
+          }
+        }
+      }
+    };
+    function addExternalEntities(externalEntities) {
+      const entKeys = Object.keys(externalEntities);
+      for (let i = 0; i < entKeys.length; i++) {
+        const ent = entKeys[i];
+        const escaped = ent.replace(/[.\-+*:]/g, "\\.");
+        this.lastEntities[ent] = {
+          regex: new RegExp("&" + escaped + ";", "g"),
+          val: externalEntities[ent]
+        };
+      }
+    }
+    function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
+      if (val !== void 0) {
+        if (this.options.trimValues && !dontTrim) {
+          val = val.trim();
+        }
+        if (val.length > 0) {
+          if (!escapeEntities) val = this.replaceEntitiesValue(val, tagName, jPath);
+          const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode);
+          if (newval === null || newval === void 0) {
+            return val;
+          } else if (typeof newval !== typeof val || newval !== val) {
+            return newval;
+          } else if (this.options.trimValues) {
+            return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+          } else {
+            const trimmedVal = val.trim();
+            if (trimmedVal === val) {
+              return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);
+            } else {
+              return val;
+            }
+          }
+        }
+      }
+    }
+    function resolveNameSpace(tagname) {
+      if (this.options.removeNSPrefix) {
+        const tags = tagname.split(":");
+        const prefix = tagname.charAt(0) === "/" ? "/" : "";
+        if (tags[0] === "xmlns") {
+          return "";
+        }
+        if (tags.length === 2) {
+          tagname = prefix + tags[1];
+        }
+      }
+      return tagname;
+    }
+    var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
+    function buildAttributesMap(attrStr, jPath, tagName) {
+      if (this.options.ignoreAttributes !== true && typeof attrStr === "string") {
+        const matches = util.getAllMatches(attrStr, attrsRegx);
+        const len = matches.length;
+        const attrs = {};
+        for (let i = 0; i < len; i++) {
+          const attrName = this.resolveNameSpace(matches[i][1]);
+          if (this.ignoreAttributesFn(attrName, jPath)) {
+            continue;
+          }
+          let oldVal = matches[i][4];
+          let aName = this.options.attributeNamePrefix + attrName;
+          if (attrName.length) {
+            if (this.options.transformAttributeName) {
+              aName = this.options.transformAttributeName(aName);
+            }
+            aName = sanitizeName(aName, this.options);
+            if (oldVal !== void 0) {
+              if (this.options.trimValues) {
+                oldVal = oldVal.trim();
+              }
+              oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);
+              const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
+              if (newVal === null || newVal === void 0) {
+                attrs[aName] = oldVal;
+              } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {
+                attrs[aName] = newVal;
+              } else {
+                attrs[aName] = parseValue(
+                  oldVal,
+                  this.options.parseAttributeValue,
+                  this.options.numberParseOptions
+                );
+              }
+            } else if (this.options.allowBooleanAttributes) {
+              attrs[aName] = true;
+            }
+          }
+        }
+        if (!Object.keys(attrs).length) {
+          return;
+        }
+        if (this.options.attributesGroupName) {
+          const attrCollection = {};
+          attrCollection[this.options.attributesGroupName] = attrs;
+          return attrCollection;
+        }
+        return attrs;
+      }
+    }
+    var parseXml = function(xmlData) {
+      xmlData = xmlData.replace(/\r\n?/g, "\n");
+      const xmlObj = new xmlNode("!xml");
+      let currentNode = xmlObj;
+      let textData = "";
+      let jPath = "";
+      this.entityExpansionCount = 0;
+      this.currentExpandedLength = 0;
+      const docTypeReader = new DocTypeReader(this.options.processEntities);
+      for (let i = 0; i < xmlData.length; i++) {
+        const ch = xmlData[i];
+        if (ch === "<") {
+          if (xmlData[i + 1] === "/") {
+            const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.");
+            let tagName = xmlData.substring(i + 2, closeIndex).trim();
+            if (this.options.removeNSPrefix) {
+              const colonIndex = tagName.indexOf(":");
+              if (colonIndex !== -1) {
+                tagName = tagName.substr(colonIndex + 1);
+              }
+            }
+            if (this.options.transformTagName) {
+              tagName = this.options.transformTagName(tagName);
+            }
+            if (currentNode) {
+              textData = this.saveTextToParentTag(textData, currentNode, jPath);
+            }
+            const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
+            if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
+              throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
+            }
+            let propIndex = 0;
+            if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
+              propIndex = jPath.lastIndexOf(".", jPath.lastIndexOf(".") - 1);
+              this.tagsNodeStack.pop();
+            } else {
+              propIndex = jPath.lastIndexOf(".");
+            }
+            jPath = jPath.substring(0, propIndex);
+            currentNode = this.tagsNodeStack.pop();
+            textData = "";
+            i = closeIndex;
+          } else if (xmlData[i + 1] === "?") {
+            let tagData = readTagExp(xmlData, i, false, "?>");
+            if (!tagData) throw new Error("Pi Tag is not closed.");
+            textData = this.saveTextToParentTag(textData, currentNode, jPath);
+            if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) ; else {
+              const childNode = new xmlNode(tagData.tagName);
+              childNode.add(this.options.textNodeName, "");
+              if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
+                childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
+              }
+              this.addChild(currentNode, childNode, jPath, i);
+            }
+            i = tagData.closeIndex + 1;
+          } else if (xmlData.substr(i + 1, 3) === "!--") {
+            const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed.");
+            if (this.options.commentPropName) {
+              const comment = xmlData.substring(i + 4, endIndex - 2);
+              textData = this.saveTextToParentTag(textData, currentNode, jPath);
+              currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
+            }
+            i = endIndex;
+          } else if (xmlData.substr(i + 1, 2) === "!D") {
+            const result = docTypeReader.readDocType(xmlData, i);
+            this.docTypeEntities = result.entities;
+            i = result.i;
+          } else if (xmlData.substr(i + 1, 2) === "![") {
+            const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2;
+            const tagExp = xmlData.substring(i + 9, closeIndex);
+            textData = this.saveTextToParentTag(textData, currentNode, jPath);
+            let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
+            if (val == void 0) val = "";
+            if (this.options.cdataPropName) {
+              currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
+            } else {
+              currentNode.add(this.options.textNodeName, val);
+            }
+            i = closeIndex + 2;
+          } else {
+            let result = readTagExp(xmlData, i, this.options.removeNSPrefix);
+            let tagName = result.tagName;
+            const rawTagName = result.rawTagName;
+            let tagExp = result.tagExp;
+            let attrExpPresent = result.attrExpPresent;
+            let closeIndex = result.closeIndex;
+            if (this.options.transformTagName) {
+              const newTagName = this.options.transformTagName(tagName);
+              if (tagExp === tagName) {
+                tagExp = newTagName;
+              }
+              tagName = newTagName;
+            }
+            if (this.options.strictReservedNames && (tagName === this.options.commentPropName || tagName === this.options.cdataPropName || tagName === this.options.textNodeName || tagName === this.options.attributesGroupName)) {
+              throw new Error(`Invalid tag name: ${tagName}`);
+            }
+            if (currentNode && textData) {
+              if (currentNode.tagname !== "!xml") {
+                textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
+              }
+            }
+            const lastTag = currentNode;
+            if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
+              currentNode = this.tagsNodeStack.pop();
+              jPath = jPath.substring(0, jPath.lastIndexOf("."));
+            }
+            if (tagName !== xmlObj.tagname) {
+              jPath += jPath ? "." + tagName : tagName;
+            }
+            const startIndex = i;
+            if (this.isItStopNode(this.stopNodesExact, this.stopNodesWildcard, jPath, tagName)) {
+              let tagContent = "";
+              if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
+                if (tagName[tagName.length - 1] === "/") {
+                  tagName = tagName.substr(0, tagName.length - 1);
+                  jPath = jPath.substr(0, jPath.length - 1);
+                  tagExp = tagName;
+                } else {
+                  tagExp = tagExp.substr(0, tagExp.length - 1);
+                }
+                i = result.closeIndex;
+              } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
+                i = result.closeIndex;
+              } else {
+                const result2 = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
+                if (!result2) throw new Error(`Unexpected end of ${rawTagName}`);
+                i = result2.i;
+                tagContent = result2.tagContent;
+              }
+              const childNode = new xmlNode(tagName);
+              if (tagName !== tagExp && attrExpPresent) {
+                childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
+              }
+              if (tagContent) {
+                tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
+              }
+              jPath = jPath.substr(0, jPath.lastIndexOf("."));
+              childNode.add(this.options.textNodeName, tagContent);
+              this.addChild(currentNode, childNode, jPath, startIndex);
+            } else {
+              if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
+                if (tagName[tagName.length - 1] === "/") {
+                  tagName = tagName.substr(0, tagName.length - 1);
+                  jPath = jPath.substr(0, jPath.length - 1);
+                  tagExp = tagName;
+                } else {
+                  tagExp = tagExp.substr(0, tagExp.length - 1);
+                }
+                if (this.options.transformTagName) {
+                  const newTagName = this.options.transformTagName(tagName);
+                  if (tagExp === tagName) {
+                    tagExp = newTagName;
+                  }
+                  tagName = newTagName;
+                }
+                const childNode = new xmlNode(tagName);
+                if (tagName !== tagExp && attrExpPresent) {
+                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
+                }
+                this.addChild(currentNode, childNode, jPath, startIndex);
+                jPath = jPath.substr(0, jPath.lastIndexOf("."));
+              } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
+                const childNode = new xmlNode(tagName);
+                if (tagName !== tagExp && attrExpPresent) {
+                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath);
+                }
+                this.addChild(currentNode, childNode, jPath, startIndex);
+                jPath = jPath.substr(0, jPath.lastIndexOf("."));
+                i = result.closeIndex;
+                continue;
+              } else {
+                const childNode = new xmlNode(tagName);
+                if (this.tagsNodeStack.length > this.options.maxNestedTags) {
+                  throw new Error("Maximum nested tags exceeded");
+                }
+                this.tagsNodeStack.push(currentNode);
+                if (tagName !== tagExp && attrExpPresent) {
+                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
+                }
+                this.addChild(currentNode, childNode, jPath);
+                currentNode = childNode;
+              }
+              textData = "";
+              i = closeIndex;
+            }
+          }
+        } else {
+          textData += xmlData[i];
+        }
+      }
+      return xmlObj.child;
+    };
+    function addChild(currentNode, childNode, jPath, startIndex) {
+      if (!this.options.captureMetaData) startIndex = void 0;
+      const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
+      if (result === false) ; else if (typeof result === "string") {
+        childNode.tagname = result;
+        currentNode.addChild(childNode, startIndex);
+      } else {
+        currentNode.addChild(childNode, startIndex);
+      }
+    }
+    var replaceEntitiesValue = function(val, tagName, jPath) {
+      if (val.indexOf("&") === -1) {
+        return val;
+      }
+      const entityConfig = this.options.processEntities;
+      if (!entityConfig.enabled) {
+        return val;
+      }
+      if (entityConfig.allowedTags) {
+        if (!entityConfig.allowedTags.includes(tagName)) {
+          return val;
+        }
+      }
+      if (entityConfig.tagFilter) {
+        if (!entityConfig.tagFilter(tagName, jPath)) {
+          return val;
+        }
+      }
+      for (let entityName in this.docTypeEntities) {
+        const entity = this.docTypeEntities[entityName];
+        const matches = val.match(entity.regx);
+        if (matches) {
+          this.entityExpansionCount += matches.length;
+          if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
+            throw new Error(
+              `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`
+            );
+          }
+          const lengthBefore = val.length;
+          val = val.replace(entity.regx, entity.val);
+          if (entityConfig.maxExpandedLength) {
+            this.currentExpandedLength += val.length - lengthBefore;
+            if (this.currentExpandedLength > entityConfig.maxExpandedLength) {
+              throw new Error(
+                `Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`
+              );
+            }
+          }
+        }
+      }
+      if (val.indexOf("&") === -1) return val;
+      for (const entityName of Object.keys(this.lastEntities)) {
+        const entity = this.lastEntities[entityName];
+        const matches = val.match(entity.regex);
+        if (matches) {
+          this.entityExpansionCount += matches.length;
+          if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
+            throw new Error(
+              `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`
+            );
+          }
+        }
+        val = val.replace(entity.regex, entity.val);
+      }
+      if (val.indexOf("&") === -1) return val;
+      if (this.options.htmlEntities) {
+        for (const entityName of Object.keys(this.htmlEntities)) {
+          const entity = this.htmlEntities[entityName];
+          const matches = val.match(entity.regex);
+          if (matches) {
+            this.entityExpansionCount += matches.length;
+            if (entityConfig.maxTotalExpansions && this.entityExpansionCount > entityConfig.maxTotalExpansions) {
+              throw new Error(
+                `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`
+              );
+            }
+          }
+          val = val.replace(entity.regex, entity.val);
+        }
+      }
+      val = val.replace(this.ampEntity.regex, this.ampEntity.val);
+      return val;
+    };
+    function saveTextToParentTag(textData, parentNode, jPath, isLeafNode) {
+      if (textData) {
+        if (isLeafNode === void 0) isLeafNode = parentNode.child.length === 0;
+        textData = this.parseTextData(
+          textData,
+          parentNode.tagname,
+          jPath,
+          false,
+          parentNode[":@"] ? Object.keys(parentNode[":@"]).length !== 0 : false,
+          isLeafNode
+        );
+        if (textData !== void 0 && textData !== "")
+          parentNode.add(this.options.textNodeName, textData);
+        textData = "";
+      }
+      return textData;
+    }
+    function isItStopNode(stopNodesExact, stopNodesWildcard, jPath, currentTagName) {
+      if (stopNodesWildcard && stopNodesWildcard.has(currentTagName)) return true;
+      if (stopNodesExact && stopNodesExact.has(jPath)) return true;
+      return false;
+    }
+    function tagExpWithClosingIndex(xmlData, i, closingChar = ">") {
+      let attrBoundary;
+      let tagExp = "";
+      for (let index = i; index < xmlData.length; index++) {
+        let ch = xmlData[index];
+        if (attrBoundary) {
+          if (ch === attrBoundary) attrBoundary = "";
+        } else if (ch === '"' || ch === "'") {
+          attrBoundary = ch;
+        } else if (ch === closingChar[0]) {
+          if (closingChar[1]) {
+            if (xmlData[index + 1] === closingChar[1]) {
+              return {
+                data: tagExp,
+                index
+              };
+            }
+          } else {
+            return {
+              data: tagExp,
+              index
+            };
+          }
+        } else if (ch === "	") {
+          ch = " ";
+        }
+        tagExp += ch;
+      }
+    }
+    function findClosingIndex(xmlData, str2, i, errMsg) {
+      const closingIndex = xmlData.indexOf(str2, i);
+      if (closingIndex === -1) {
+        throw new Error(errMsg);
+      } else {
+        return closingIndex + str2.length - 1;
+      }
+    }
+    function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") {
+      const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);
+      if (!result) return;
+      let tagExp = result.data;
+      const closeIndex = result.index;
+      const separatorIndex = tagExp.search(/\s/);
+      let tagName = tagExp;
+      let attrExpPresent = true;
+      if (separatorIndex !== -1) {
+        tagName = tagExp.substring(0, separatorIndex);
+        tagExp = tagExp.substring(separatorIndex + 1).trimStart();
+      }
+      const rawTagName = tagName;
+      if (removeNSPrefix) {
+        const colonIndex = tagName.indexOf(":");
+        if (colonIndex !== -1) {
+          tagName = tagName.substr(colonIndex + 1);
+          attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
+        }
+      }
+      return {
+        tagName,
+        tagExp,
+        closeIndex,
+        attrExpPresent,
+        rawTagName
+      };
+    }
+    function readStopNodeData(xmlData, tagName, i) {
+      const startIndex = i;
+      let openTagCount = 1;
+      for (; i < xmlData.length; i++) {
+        if (xmlData[i] === "<") {
+          if (xmlData[i + 1] === "/") {
+            const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`);
+            let closeTagName = xmlData.substring(i + 2, closeIndex).trim();
+            if (closeTagName === tagName) {
+              openTagCount--;
+              if (openTagCount === 0) {
+                return {
+                  tagContent: xmlData.substring(startIndex, i),
+                  i: closeIndex
+                };
+              }
+            }
+            i = closeIndex;
+          } else if (xmlData[i + 1] === "?") {
+            const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed.");
+            i = closeIndex;
+          } else if (xmlData.substr(i + 1, 3) === "!--") {
+            const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed.");
+            i = closeIndex;
+          } else if (xmlData.substr(i + 1, 2) === "![") {
+            const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2;
+            i = closeIndex;
+          } else {
+            const tagData = readTagExp(xmlData, i, ">");
+            if (tagData) {
+              const openTagName = tagData && tagData.tagName;
+              if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") {
+                openTagCount++;
+              }
+              i = tagData.closeIndex;
+            }
+          }
+        }
+      }
+    }
+    function parseValue(val, shouldParse, options) {
+      if (shouldParse && typeof val === "string") {
+        const newval = val.trim();
+        if (newval === "true") return true;
+        else if (newval === "false") return false;
+        else return toNumber(val, options);
+      } else {
+        if (util.isExist(val)) {
+          return val;
+        } else {
+          return "";
+        }
+      }
+    }
+    function fromCodePoint(str2, base, prefix) {
+      const codePoint = Number.parseInt(str2, base);
+      if (codePoint >= 0 && codePoint <= 1114111) {
+        return String.fromCodePoint(codePoint);
+      } else {
+        return prefix + str2 + ";";
+      }
+    }
+    function sanitizeName(name, options) {
+      if (util.criticalProperties.includes(name)) {
+        throw new Error(`[SECURITY] Invalid name: "${name}" is a reserved JavaScript keyword that could cause prototype pollution`);
+      } else if (util.DANGEROUS_PROPERTY_NAMES.includes(name)) {
+        return options.onDangerousProperty(name);
+      }
+      return name;
+    }
+    module.exports = OrderedObjParser;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/node2json.js
+var require_node2json = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/node2json.js"(exports) {
+    function prettify(node, options) {
+      return compress(node, options);
+    }
+    function compress(arr, options, jPath) {
+      let text2;
+      const compressedObj = {};
+      for (let i = 0; i < arr.length; i++) {
+        const tagObj = arr[i];
+        const property = propName(tagObj);
+        let newJpath = "";
+        if (jPath === void 0) newJpath = property;
+        else newJpath = jPath + "." + property;
+        if (property === options.textNodeName) {
+          if (text2 === void 0) text2 = tagObj[property];
+          else text2 += "" + tagObj[property];
+        } else if (property === void 0) {
+          continue;
+        } else if (tagObj[property]) {
+          let val = compress(tagObj[property], options, newJpath);
+          const isLeaf = isLeafTag(val, options);
+          if (tagObj[":@"]) {
+            assignAttributes(val, tagObj[":@"], newJpath, options);
+          } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) {
+            val = val[options.textNodeName];
+          } else if (Object.keys(val).length === 0) {
+            if (options.alwaysCreateTextNode) val[options.textNodeName] = "";
+            else val = "";
+          }
+          if (compressedObj[property] !== void 0 && compressedObj.hasOwnProperty(property)) {
+            if (!Array.isArray(compressedObj[property])) {
+              compressedObj[property] = [compressedObj[property]];
+            }
+            compressedObj[property].push(val);
+          } else {
+            if (options.isArray(property, newJpath, isLeaf)) {
+              compressedObj[property] = [val];
+            } else {
+              compressedObj[property] = val;
+            }
+          }
+        }
+      }
+      if (typeof text2 === "string") {
+        if (text2.length > 0) compressedObj[options.textNodeName] = text2;
+      } else if (text2 !== void 0) compressedObj[options.textNodeName] = text2;
+      return compressedObj;
+    }
+    function propName(obj) {
+      const keys = Object.keys(obj);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (key !== ":@") return key;
+      }
+    }
+    function assignAttributes(obj, attrMap, jpath, options) {
+      if (attrMap) {
+        const keys = Object.keys(attrMap);
+        const len = keys.length;
+        for (let i = 0; i < len; i++) {
+          const atrrName = keys[i];
+          if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
+            obj[atrrName] = [attrMap[atrrName]];
+          } else {
+            obj[atrrName] = attrMap[atrrName];
+          }
+        }
+      }
+    }
+    function isLeafTag(obj, options) {
+      const { textNodeName } = options;
+      const propCount = Object.keys(obj).length;
+      if (propCount === 0) {
+        return true;
+      }
+      if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) {
+        return true;
+      }
+      return false;
+    }
+    exports.prettify = prettify;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
+var require_XMLParser = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js"(exports, module) {
+    var { buildOptions } = require_OptionsBuilder();
+    var OrderedObjParser = require_OrderedObjParser();
+    var { prettify } = require_node2json();
+    var validator = require_validator();
+    var XMLParser2 = class {
+      constructor(options) {
+        this.externalEntities = {};
+        this.options = buildOptions(options);
+      }
+      /**
+       * Parse XML dats to JS object 
+       * @param {string|Buffer} xmlData 
+       * @param {boolean|Object} validationOption 
+       */
+      parse(xmlData, validationOption) {
+        if (typeof xmlData === "string") ; else if (xmlData.toString) {
+          xmlData = xmlData.toString();
+        } else {
+          throw new Error("XML data is accepted in String or Bytes[] form.");
+        }
+        if (validationOption) {
+          if (validationOption === true) validationOption = {};
+          const result = validator.validate(xmlData, validationOption);
+          if (result !== true) {
+            throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
+          }
+        }
+        const orderedObjParser = new OrderedObjParser(this.options);
+        orderedObjParser.addExternalEntities(this.externalEntities);
+        const orderedResult = orderedObjParser.parseXml(xmlData);
+        if (this.options.preserveOrder || orderedResult === void 0) return orderedResult;
+        else return prettify(orderedResult, this.options);
+      }
+      /**
+       * Add Entity which is not by default supported by this library
+       * @param {string} key 
+       * @param {string} value 
+       */
+      addEntity(key, value) {
+        if (value.indexOf("&") !== -1) {
+          throw new Error("Entity value can't have '&'");
+        } else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) {
+          throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
+        } else if (value === "&") {
+          throw new Error("An entity with value '&' is not permitted");
+        } else {
+          this.externalEntities[key] = value;
+        }
+      }
+    };
+    module.exports = XMLParser2;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js
+var require_orderedJs2Xml = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js"(exports, module) {
+    var EOL = "\n";
+    function toXml(jArray, options) {
+      let indentation = "";
+      if (options.format && options.indentBy.length > 0) {
+        indentation = EOL;
+      }
+      return arrToStr(jArray, options, "", indentation);
+    }
+    function arrToStr(arr, options, jPath, indentation) {
+      let xmlStr = "";
+      let isPreviousElementTag = false;
+      if (!Array.isArray(arr)) {
+        if (arr !== void 0 && arr !== null) {
+          let text2 = arr.toString();
+          text2 = replaceEntitiesValue(text2, options);
+          return text2;
+        }
+        return "";
+      }
+      for (let i = 0; i < arr.length; i++) {
+        const tagObj = arr[i];
+        const tagName = propName(tagObj);
+        if (tagName === void 0) continue;
+        let newJPath = "";
+        if (jPath.length === 0) newJPath = tagName;
+        else newJPath = `${jPath}.${tagName}`;
+        if (tagName === options.textNodeName) {
+          let tagText = tagObj[tagName];
+          if (!isStopNode(newJPath, options)) {
+            tagText = options.tagValueProcessor(tagName, tagText);
+            tagText = replaceEntitiesValue(tagText, options);
+          }
+          if (isPreviousElementTag) {
+            xmlStr += indentation;
+          }
+          xmlStr += tagText;
+          isPreviousElementTag = false;
+          continue;
+        } else if (tagName === options.cdataPropName) {
+          if (isPreviousElementTag) {
+            xmlStr += indentation;
+          }
+          xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
+          isPreviousElementTag = false;
+          continue;
+        } else if (tagName === options.commentPropName) {
+          xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
+          isPreviousElementTag = true;
+          continue;
+        } else if (tagName[0] === "?") {
+          const attStr2 = attr_to_str(tagObj[":@"], options);
+          const tempInd = tagName === "?xml" ? "" : indentation;
+          let piTextNodeName = tagObj[tagName][0][options.textNodeName];
+          piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : "";
+          xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr2}?>`;
+          isPreviousElementTag = true;
+          continue;
+        }
+        let newIdentation = indentation;
+        if (newIdentation !== "") {
+          newIdentation += options.indentBy;
+        }
+        const attStr = attr_to_str(tagObj[":@"], options);
+        const tagStart = indentation + `<${tagName}${attStr}`;
+        const tagValue = arrToStr(tagObj[tagName], options, newJPath, newIdentation);
+        if (options.unpairedTags.indexOf(tagName) !== -1) {
+          if (options.suppressUnpairedNode) xmlStr += tagStart + ">";
+          else xmlStr += tagStart + "/>";
+        } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {
+          xmlStr += tagStart + "/>";
+        } else if (tagValue && tagValue.endsWith(">")) {
+          xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;
+        } else {
+          xmlStr += tagStart + ">";
+          if (tagValue && indentation !== "" && (tagValue.includes("/>") || tagValue.includes("</"))) {
+            xmlStr += indentation + options.indentBy + tagValue + indentation;
+          } else {
+            xmlStr += tagValue;
+          }
+          xmlStr += `</${tagName}>`;
+        }
+        isPreviousElementTag = true;
+      }
+      return xmlStr;
+    }
+    function propName(obj) {
+      const keys = Object.keys(obj);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+        if (key !== ":@") return key;
+      }
+    }
+    function attr_to_str(attrMap, options) {
+      let attrStr = "";
+      if (attrMap && !options.ignoreAttributes) {
+        for (let attr3 in attrMap) {
+          if (!Object.prototype.hasOwnProperty.call(attrMap, attr3)) continue;
+          let attrVal = options.attributeValueProcessor(attr3, attrMap[attr3]);
+          attrVal = replaceEntitiesValue(attrVal, options);
+          if (attrVal === true && options.suppressBooleanAttributes) {
+            attrStr += ` ${attr3.substr(options.attributeNamePrefix.length)}`;
+          } else {
+            attrStr += ` ${attr3.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
+          }
+        }
+      }
+      return attrStr;
+    }
+    function isStopNode(jPath, options) {
+      jPath = jPath.substr(0, jPath.length - options.textNodeName.length - 1);
+      let tagName = jPath.substr(jPath.lastIndexOf(".") + 1);
+      for (let index in options.stopNodes) {
+        if (options.stopNodes[index] === jPath || options.stopNodes[index] === "*." + tagName) return true;
+      }
+      return false;
+    }
+    function replaceEntitiesValue(textValue, options) {
+      if (textValue && textValue.length > 0 && options.processEntities) {
+        for (let i = 0; i < options.entities.length; i++) {
+          const entity = options.entities[i];
+          textValue = textValue.replace(entity.regex, entity.val);
+        }
+      }
+      return textValue;
+    }
+    module.exports = toXml;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js
+var require_json2xml = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js"(exports, module) {
+    var buildFromOrderedJs = require_orderedJs2Xml();
+    var getIgnoreAttributesFn = require_ignoreAttributes();
+    var defaultOptions = {
+      attributeNamePrefix: "@_",
+      attributesGroupName: false,
+      textNodeName: "#text",
+      ignoreAttributes: true,
+      cdataPropName: false,
+      format: false,
+      indentBy: "  ",
+      suppressEmptyNode: false,
+      suppressUnpairedNode: true,
+      suppressBooleanAttributes: true,
+      tagValueProcessor: function(key, a) {
+        return a;
+      },
+      attributeValueProcessor: function(attrName, a) {
+        return a;
+      },
+      preserveOrder: false,
+      commentPropName: false,
+      unpairedTags: [],
+      entities: [
+        { regex: new RegExp("&", "g"), val: "&amp;" },
+        //it must be on top
+        { regex: new RegExp(">", "g"), val: "&gt;" },
+        { regex: new RegExp("<", "g"), val: "&lt;" },
+        { regex: new RegExp("'", "g"), val: "&apos;" },
+        { regex: new RegExp('"', "g"), val: "&quot;" }
+      ],
+      processEntities: true,
+      stopNodes: [],
+      // transformTagName: false,
+      // transformAttributeName: false,
+      oneListGroup: false
+    };
+    function Builder(options) {
+      this.options = Object.assign({}, defaultOptions, options);
+      if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {
+        this.isAttribute = function() {
+          return false;
+        };
+      } else {
+        this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes);
+        this.attrPrefixLen = this.options.attributeNamePrefix.length;
+        this.isAttribute = isAttribute;
+      }
+      this.processTextOrObjNode = processTextOrObjNode;
+      if (this.options.format) {
+        this.indentate = indentate;
+        this.tagEndChar = ">\n";
+        this.newLine = "\n";
+      } else {
+        this.indentate = function() {
+          return "";
+        };
+        this.tagEndChar = ">";
+        this.newLine = "";
+      }
+    }
+    Builder.prototype.build = function(jObj) {
+      if (this.options.preserveOrder) {
+        return buildFromOrderedJs(jObj, this.options);
+      } else {
+        if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {
+          jObj = {
+            [this.options.arrayNodeName]: jObj
+          };
+        }
+        return this.j2x(jObj, 0, []).val;
+      }
+    };
+    Builder.prototype.j2x = function(jObj, level, ajPath) {
+      let attrStr = "";
+      let val = "";
+      const jPath = ajPath.join(".");
+      for (let key in jObj) {
+        if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
+        if (typeof jObj[key] === "undefined") {
+          if (this.isAttribute(key)) {
+            val += "";
+          }
+        } else if (jObj[key] === null) {
+          if (this.isAttribute(key)) {
+            val += "";
+          } else if (key === this.options.cdataPropName) {
+            val += "";
+          } else if (key[0] === "?") {
+            val += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
+          } else {
+            val += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
+          }
+        } else if (jObj[key] instanceof Date) {
+          val += this.buildTextValNode(jObj[key], key, "", level);
+        } else if (typeof jObj[key] !== "object") {
+          const attr3 = this.isAttribute(key);
+          if (attr3 && !this.ignoreAttributesFn(attr3, jPath)) {
+            attrStr += this.buildAttrPairStr(attr3, "" + jObj[key]);
+          } else if (!attr3) {
+            if (key === this.options.textNodeName) {
+              let newval = this.options.tagValueProcessor(key, "" + jObj[key]);
+              val += this.replaceEntitiesValue(newval);
+            } else {
+              val += this.buildTextValNode(jObj[key], key, "", level);
+            }
+          }
+        } else if (Array.isArray(jObj[key])) {
+          const arrLen = jObj[key].length;
+          let listTagVal = "";
+          let listTagAttr = "";
+          for (let j = 0; j < arrLen; j++) {
+            const item = jObj[key][j];
+            if (typeof item === "undefined") ; else if (item === null) {
+              if (key[0] === "?") val += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
+              else val += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
+            } else if (typeof item === "object") {
+              if (this.options.oneListGroup) {
+                const result = this.j2x(item, level + 1, ajPath.concat(key));
+                listTagVal += result.val;
+                if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {
+                  listTagAttr += result.attrStr;
+                }
+              } else {
+                listTagVal += this.processTextOrObjNode(item, key, level, ajPath);
+              }
+            } else {
+              if (this.options.oneListGroup) {
+                let textValue = this.options.tagValueProcessor(key, item);
+                textValue = this.replaceEntitiesValue(textValue);
+                listTagVal += textValue;
+              } else {
+                listTagVal += this.buildTextValNode(item, key, "", level);
+              }
+            }
+          }
+          if (this.options.oneListGroup) {
+            listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);
+          }
+          val += listTagVal;
+        } else {
+          if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
+            const Ks = Object.keys(jObj[key]);
+            const L = Ks.length;
+            for (let j = 0; j < L; j++) {
+              attrStr += this.buildAttrPairStr(Ks[j], "" + jObj[key][Ks[j]]);
+            }
+          } else {
+            val += this.processTextOrObjNode(jObj[key], key, level, ajPath);
+          }
+        }
+      }
+      return { attrStr, val };
+    };
+    Builder.prototype.buildAttrPairStr = function(attrName, val) {
+      val = this.options.attributeValueProcessor(attrName, "" + val);
+      val = this.replaceEntitiesValue(val);
+      if (this.options.suppressBooleanAttributes && val === "true") {
+        return " " + attrName;
+      } else return " " + attrName + '="' + val + '"';
+    };
+    function processTextOrObjNode(object, key, level, ajPath) {
+      const result = this.j2x(object, level + 1, ajPath.concat(key));
+      if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) {
+        return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level);
+      } else {
+        return this.buildObjectNode(result.val, key, result.attrStr, level);
+      }
+    }
+    Builder.prototype.buildObjectNode = function(val, key, attrStr, level) {
+      if (val === "") {
+        if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
+        else {
+          return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
+        }
+      } else {
+        let tagEndExp = "</" + key + this.tagEndChar;
+        let piClosingChar = "";
+        if (key[0] === "?") {
+          piClosingChar = "?";
+          tagEndExp = "";
+        }
+        if ((attrStr || attrStr === "") && val.indexOf("<") === -1) {
+          return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val + tagEndExp;
+        } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
+          return this.indentate(level) + `<!--${val}-->` + this.newLine;
+        } else {
+          return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val + this.indentate(level) + tagEndExp;
+        }
+      }
+    };
+    Builder.prototype.closeTag = function(key) {
+      let closeTag = "";
+      if (this.options.unpairedTags.indexOf(key) !== -1) {
+        if (!this.options.suppressUnpairedNode) closeTag = "/";
+      } else if (this.options.suppressEmptyNode) {
+        closeTag = "/";
+      } else {
+        closeTag = `></${key}`;
+      }
+      return closeTag;
+    };
+    Builder.prototype.buildTextValNode = function(val, key, attrStr, level) {
+      if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
+        return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;
+      } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
+        return this.indentate(level) + `<!--${val}-->` + this.newLine;
+      } else if (key[0] === "?") {
+        return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
+      } else {
+        let textValue = this.options.tagValueProcessor(key, val);
+        textValue = this.replaceEntitiesValue(textValue);
+        if (textValue === "") {
+          return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
+        } else {
+          return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
+        }
+      }
+    };
+    Builder.prototype.replaceEntitiesValue = function(textValue) {
+      if (textValue && textValue.length > 0 && this.options.processEntities) {
+        for (let i = 0; i < this.options.entities.length; i++) {
+          const entity = this.options.entities[i];
+          textValue = textValue.replace(entity.regex, entity.val);
+        }
+      }
+      return textValue;
+    };
+    function indentate(level) {
+      return this.options.indentBy.repeat(level);
+    }
+    function isAttribute(name) {
+      if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {
+        return name.substr(this.attrPrefixLen);
+      } else {
+        return false;
+      }
+    }
+    module.exports = Builder;
+  }
+});
+
+// ../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/fxp.js
+var require_fxp = __commonJS({
+  "../../node_modules/.pnpm/fast-xml-parser@4.5.6/node_modules/fast-xml-parser/src/fxp.js"(exports, module) {
+    var validator = require_validator();
+    var XMLParser2 = require_XMLParser();
+    var XMLBuilder2 = require_json2xml();
+    module.exports = {
+      XMLParser: XMLParser2,
+      XMLValidator: validator,
+      XMLBuilder: XMLBuilder2
+    };
+  }
+});
+
+// ../core/dist/index.js
+var import_fast_xml_parser = __toESM(require_fxp(), 1);
+function allRequirements(doc) {
+  return [...doc.packages.flatMap((p) => p.requirements), ...doc.looseRequirements];
+}
+function declaredElements(doc) {
+  const out = [];
+  const push = (id, kind) => {
+    if (id !== void 0) out.push({ id, kind });
+  };
+  for (const p of doc.meta.profiles ?? []) push(p.id, "profile");
+  const c = doc.catalogs;
+  if (c) {
+    for (const t of c.glossary ?? []) push(t.id, "term");
+    for (const a of c.actors ?? []) push(a.id, "actor");
+    for (const s of c.stakeholders ?? []) push(s.id, "stakeholder");
+    for (const x of c.constraints ?? []) push(x.id, "constraint");
+    for (const x of c.policies ?? []) push(x.id, "policy");
+    for (const x of c.decisions ?? []) push(x.id, "decision");
+    for (const x of c.risks ?? []) push(x.id, "risk");
+  }
+  const d = doc.domain;
+  if (d) {
+    for (const e of d.entities ?? []) {
+      push(e.id, "entity");
+      for (const a of e.attrs ?? []) push(a.id, "attr");
+    }
+    for (const r of d.businessRules ?? []) push(r.id, "rule");
+  }
+  const g = doc.goals;
+  if (g) {
+    for (const x of g.goals ?? []) push(x.id, "goal");
+    for (const x of g.qualityGoals ?? []) push(x.id, "qgoal");
+    for (const x of g.obstacles ?? []) push(x.id, "obstacle");
+    for (const x of g.goalLinks ?? []) push(x.id, "goalLink");
+  }
+  const sc = doc.scenarios;
+  if (sc) {
+    for (const x of sc.scenarios ?? []) push(x.id, "scenario");
+    for (const x of sc.misuseCases ?? []) push(x.id, "misuseCase");
+    for (const x of sc.edgeCases ?? []) push(x.id, "edgeCase");
+  }
+  for (const p of doc.packages) {
+    push(p.id, "reqPackage");
+    for (const r of p.requirements) {
+      push(r.id, "req");
+      for (const cr of r.acceptance) push(cr.id, "criterion");
+    }
+  }
+  for (const r of doc.looseRequirements) {
+    push(r.id, "req");
+    for (const cr of r.acceptance) push(cr.id, "criterion");
+  }
+  const b = doc.behavior;
+  if (b) {
+    for (const sm of b.stateMachines ?? []) {
+      push(sm.id, "stateMachine");
+      for (const st of sm.states) push(st.id, "state");
+      for (const tr of sm.transitions ?? []) push(tr.id, "transition");
+    }
+  }
+  const it = doc.interfaces;
+  if (it) {
+    for (const api of it.apis ?? []) {
+      push(api.id, "api");
+      for (const ep of api.endpoints ?? []) push(ep.id, "endpoint");
+    }
+    for (const ev of it.events ?? []) push(ev.id, "event");
+  }
+  const v = doc.verification;
+  if (v) {
+    for (const ts of v.testSuites ?? []) push(ts.id, "testSuite");
+    for (const tc of v.testCases ?? []) push(tc.id, "testCase");
+  }
+  for (const e of doc.trace) push(e.id, "edge");
+  const gv = doc.governance;
+  if (gv) {
+    for (const x of gv.issues ?? []) push(x.id, "issue");
+    for (const x of gv.approvals ?? []) push(x.id, "approval");
+  }
+  return out;
+}
+var rawSections = /* @__PURE__ */ new WeakMap();
+function setRawSections(doc, sections) {
+  rawSections.set(doc, sections);
+}
+var ATTR_PREFIX = "@_";
+var ARRAY_TAGS = /* @__PURE__ */ new Set([
+  "author",
+  "profile",
+  "term",
+  "synonym",
+  "actor",
+  "stakeholder",
+  "constraint",
+  "policy",
+  "risk",
+  "ref",
+  "entity",
+  "attr",
+  "rule",
+  "goal",
+  "qgoal",
+  "obstacle",
+  "goalLink",
+  "scenario",
+  "misuseCase",
+  "edgeCase",
+  "stateMachine",
+  "state",
+  "transition",
+  "api",
+  "endpoint",
+  "event",
+  "testSuite",
+  "testCase",
+  "reqPackage",
+  "req",
+  "criterion",
+  "edge",
+  "traceEdge",
+  "issue",
+  "approval"
+]);
+var MODELED_SECTIONS = /* @__PURE__ */ new Set([
+  "meta",
+  "catalogs",
+  "domain",
+  "goals",
+  "scenarios",
+  "requirements",
+  "behavior",
+  "interfaces",
+  "verification",
+  "trace",
+  "governance"
+]);
+var KNOWN_ROOT_ATTRS = /* @__PURE__ */ new Set([
+  "@_xmlns",
+  "@_xmlns:xsi",
+  "@_xsi:schemaLocation",
+  "@_version",
+  "@_docId",
+  "@_status"
+]);
+var parser = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: ATTR_PREFIX,
+  parseAttributeValue: false,
+  parseTagValue: false,
+  trimValues: true,
+  isArray: (name) => ARRAY_TAGS.has(name)
+});
+function isNode(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function child(node, name) {
+  return isNode(node) ? node[name] : void 0;
+}
+function attr(node, name) {
+  if (!isNode(node)) return void 0;
+  const v = node[ATTR_PREFIX + name];
+  return v == null ? void 0 : String(v);
+}
+function numAttr(node, name) {
+  const v = attr(node, name);
+  return v === void 0 ? void 0 : Number(v);
+}
+function boolAttr(node, name) {
+  const v = attr(node, name);
+  if (v === void 0) return void 0;
+  if (v === "true" || v === "1") return true;
+  if (v === "false" || v === "0") return false;
+  return void 0;
+}
+function text(node) {
+  if (node == null) return void 0;
+  if (typeof node === "string") return node;
+  if (typeof node === "number" || typeof node === "boolean") return String(node);
+  if (isNode(node)) {
+    const t = node["#text"];
+    return t == null ? void 0 : String(t);
+  }
+  return void 0;
+}
+function asArray(v) {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+function collect(container, childName) {
+  return asArray(container).flatMap((c) => asArray(child(c, childName)));
+}
+function parseAuthor(node) {
+  const a = { name: text(child(node, "name")) ?? "" };
+  const role = text(child(node, "role"));
+  const org = text(child(node, "org"));
+  const contact = text(child(node, "contact"));
+  if (role !== void 0) a.role = role;
+  if (org !== void 0) a.org = org;
+  if (contact !== void 0) a.contact = contact;
+  return a;
+}
+function parseProfile(node) {
+  const p = {
+    id: attr(node, "id") ?? "",
+    type: attr(node, "type") ?? ""
+  };
+  const description = text(child(node, "description"));
+  if (description !== void 0) p.description = description;
+  return p;
+}
+function parseMeta(node) {
+  const meta = {
+    title: text(child(node, "title")) ?? "",
+    system: text(child(node, "system")) ?? "",
+    authors: []
+  };
+  const summary = text(child(node, "summary"));
+  if (summary !== void 0) meta.summary = summary;
+  meta.authors = asArray(child(child(node, "authors"), "author")).map(parseAuthor);
+  const datesNode = child(node, "dates");
+  if (isNode(datesNode)) {
+    const dates = {};
+    const created = text(datesNode.created);
+    const updated = text(datesNode.updated);
+    const targetRelease = text(datesNode.targetRelease);
+    if (created !== void 0) dates.created = created;
+    if (updated !== void 0) dates.updated = updated;
+    if (targetRelease !== void 0) dates.targetRelease = targetRelease;
+    if (Object.keys(dates).length > 0) meta.dates = dates;
+  }
+  const convNode = child(node, "conventions");
+  if (isNode(convNode)) {
+    const conv = {};
+    const nk = text(convNode.normativeKeywords);
+    const ic = text(convNode.idConventions);
+    if (nk !== void 0) conv.normativeKeywords = nk;
+    if (ic !== void 0) conv.idConventions = ic;
+    if (Object.keys(conv).length > 0) meta.conventions = conv;
+  }
+  const profiles = asArray(child(child(node, "profiles"), "profile")).map(parseProfile);
+  if (profiles.length > 0) meta.profiles = profiles;
+  return meta;
+}
+function parseTerm(node) {
+  const t = {
+    id: attr(node, "id") ?? "",
+    name: text(child(node, "name")) ?? "",
+    definition: text(child(node, "definition")) ?? ""
+  };
+  const synonyms = asArray(child(child(node, "synonyms"), "synonym")).map(
+    (s) => text(s) ?? ""
+  );
+  if (synonyms.length > 0) t.synonyms = synonyms;
+  return t;
+}
+function parseActor(node) {
+  const a = { id: attr(node, "id") ?? "", name: attr(node, "name") ?? "" };
+  const type = attr(node, "type");
+  const description = text(child(node, "description"));
+  if (type !== void 0) a.type = type;
+  if (description !== void 0) a.description = description;
+  const refs = asArray(child(child(node, "goals"), "ref")).map(
+    (r) => attr(r, "ref") ?? ""
+  );
+  if (refs.length > 0) a.goalRefs = refs;
+  return a;
+}
+function parseStakeholder(node) {
+  const s = {
+    id: attr(node, "id") ?? "",
+    name: attr(node, "name") ?? ""
+  };
+  const org = attr(node, "org");
+  const concerns = text(child(node, "concerns"));
+  if (org !== void 0) s.org = org;
+  if (concerns !== void 0) s.concerns = concerns;
+  return s;
+}
+function parseConstraint(node) {
+  const c = {
+    id: attr(node, "id") ?? "",
+    statement: text(child(node, "statement")) ?? ""
+  };
+  const severity = attr(node, "severity");
+  const source = text(child(node, "source"));
+  if (severity !== void 0) c.severity = severity;
+  if (source !== void 0) c.source = source;
+  return c;
+}
+function parsePolicy(node) {
+  const p = {
+    id: attr(node, "id") ?? "",
+    obligation: text(child(node, "obligation")) ?? ""
+  };
+  const source = attr(node, "source");
+  const evidence = text(child(node, "evidence"));
+  if (source !== void 0) p.source = source;
+  if (evidence !== void 0) p.evidence = evidence;
+  return p;
+}
+function parseDecision(node) {
+  const d = {
+    id: attr(node, "id") ?? "",
+    context: text(child(node, "context")) ?? "",
+    decision: text(child(node, "decision")) ?? ""
+  };
+  const status = attr(node, "status");
+  const alternatives = text(child(node, "alternatives"));
+  const consequences = text(child(node, "consequences"));
+  if (status !== void 0) d.status = status;
+  if (alternatives !== void 0) d.alternatives = alternatives;
+  if (consequences !== void 0) d.consequences = consequences;
+  return d;
+}
+function parseRisk(node) {
+  const r = {
+    id: attr(node, "id") ?? "",
+    statement: text(child(node, "statement")) ?? ""
+  };
+  const severity = attr(node, "severity");
+  const mitigation = text(child(node, "mitigation"));
+  if (severity !== void 0) r.severity = severity;
+  if (mitigation !== void 0) r.mitigation = mitigation;
+  return r;
+}
+function parseCatalogs(node) {
+  if (!isNode(node)) return void 0;
+  const c = {};
+  const glossary = collect(node.glossary, "term").map(parseTerm);
+  const actors = collect(node.actors, "actor").map(parseActor);
+  const stakeholders = collect(node.stakeholders, "stakeholder").map(parseStakeholder);
+  const constraints = collect(node.constraints, "constraint").map(parseConstraint);
+  const policies = collect(node.policies, "policy").map(parsePolicy);
+  const decisions = collect(node.decisions, "decision").map(parseDecision);
+  const risks = collect(node.risks, "risk").map(parseRisk);
+  if (glossary.length > 0) c.glossary = glossary;
+  if (actors.length > 0) c.actors = actors;
+  if (stakeholders.length > 0) c.stakeholders = stakeholders;
+  if (constraints.length > 0) c.constraints = constraints;
+  if (policies.length > 0) c.policies = policies;
+  if (decisions.length > 0) c.decisions = decisions;
+  if (risks.length > 0) c.risks = risks;
+  return Object.keys(c).length > 0 ? c : void 0;
+}
+function parseAttribute(node) {
+  const a = {
+    id: attr(node, "id") ?? "",
+    name: attr(node, "name") ?? "",
+    type: attr(node, "type") ?? ""
+  };
+  const required = boolAttr(node, "required");
+  const description = text(child(node, "description"));
+  const constraints = text(child(node, "constraints"));
+  if (required !== void 0) a.required = required;
+  if (description !== void 0) a.description = description;
+  if (constraints !== void 0) a.constraints = constraints;
+  return a;
+}
+function parseEntity(node) {
+  const e = { id: attr(node, "id") ?? "", name: attr(node, "name") ?? "" };
+  const description = text(child(node, "description"));
+  if (description !== void 0) e.description = description;
+  const attrs = asArray(child(node, "attr")).map(parseAttribute);
+  if (attrs.length > 0) e.attrs = attrs;
+  return e;
+}
+function parseBusinessRule(node) {
+  const r = {
+    id: attr(node, "id") ?? "",
+    statement: text(child(node, "statement")) ?? ""
+  };
+  const examples = text(child(node, "examples"));
+  if (examples !== void 0) r.examples = examples;
+  return r;
+}
+function parseDomain(node) {
+  if (!isNode(node)) return void 0;
+  const d = {};
+  const overview = text(child(node, "overview"));
+  if (overview !== void 0) d.overview = overview;
+  const entities = collect(node.entities, "entity").map(parseEntity);
+  const rules = collect(node.businessRules, "rule").map(parseBusinessRule);
+  if (entities.length > 0) d.entities = entities;
+  if (rules.length > 0) d.businessRules = rules;
+  return Object.keys(d).length > 0 ? d : void 0;
+}
+function parseGoal(node) {
+  const g = {
+    id: attr(node, "id") ?? "",
+    title: attr(node, "title") ?? "",
+    statement: text(child(node, "statement")) ?? ""
+  };
+  const priority = attr(node, "priority");
+  const status = attr(node, "status");
+  const ownerRef = attr(node, "ownerRef");
+  const rationale = text(child(node, "rationale"));
+  if (priority !== void 0) g.priority = priority;
+  if (status !== void 0) g.status = status;
+  if (ownerRef !== void 0) g.ownerRef = ownerRef;
+  if (rationale !== void 0) g.rationale = rationale;
+  return g;
+}
+function parseQualityGoal(node) {
+  const q = {
+    id: attr(node, "id") ?? "",
+    title: attr(node, "title") ?? "",
+    statement: text(child(node, "statement")) ?? ""
+  };
+  const priority = attr(node, "priority");
+  const status = attr(node, "status");
+  const metric = text(child(node, "metric"));
+  if (priority !== void 0) q.priority = priority;
+  if (status !== void 0) q.status = status;
+  if (metric !== void 0) q.metric = metric;
+  return q;
+}
+function parseObstacle(node) {
+  const o = {
+    id: attr(node, "id") ?? "",
+    title: attr(node, "title") ?? "",
+    statement: text(child(node, "statement")) ?? ""
+  };
+  const likelihood = attr(node, "likelihood");
+  const severity = attr(node, "severity");
+  const mitigation = text(child(node, "mitigation"));
+  if (likelihood !== void 0) o.likelihood = likelihood;
+  if (severity !== void 0) o.severity = severity;
+  if (mitigation !== void 0) o.mitigation = mitigation;
+  return o;
+}
+function parseGoalLink(node) {
+  const gl = {
+    id: attr(node, "id") ?? "",
+    from: attr(node, "from") ?? "",
+    to: attr(node, "to") ?? "",
+    type: attr(node, "type") ?? "refines"
+  };
+  const confidence = numAttr(node, "confidence");
+  if (confidence !== void 0) gl.confidence = confidence;
+  return gl;
+}
+function parseGoals(node) {
+  if (!isNode(node)) return void 0;
+  const g = {};
+  const goals = asArray(node.goal).map(parseGoal);
+  const qgoals = asArray(node.qgoal).map(parseQualityGoal);
+  const obstacles = asArray(node.obstacle).map(parseObstacle);
+  const goalLinks = asArray(node.goalLink).map(parseGoalLink);
+  if (goals.length > 0) g.goals = goals;
+  if (qgoals.length > 0) g.qualityGoals = qgoals;
+  if (obstacles.length > 0) g.obstacles = obstacles;
+  if (goalLinks.length > 0) g.goalLinks = goalLinks;
+  return Object.keys(g).length > 0 ? g : void 0;
+}
+function parseScenario(node) {
+  const s = {
+    id: attr(node, "id") ?? "",
+    title: attr(node, "title") ?? "",
+    narrative: text(child(node, "narrative")) ?? ""
+  };
+  const actorRef = attr(node, "actorRef");
+  if (actorRef !== void 0) s.actorRef = actorRef;
+  return s;
+}
+function parseScenarios(node) {
+  if (!isNode(node)) return void 0;
+  const s = {};
+  const scenarios = asArray(node.scenario).map(parseScenario);
+  const misuseCases = asArray(node.misuseCase).map(parseScenario);
+  const edgeCases = asArray(node.edgeCase).map(parseScenario);
+  if (scenarios.length > 0) s.scenarios = scenarios;
+  if (misuseCases.length > 0) s.misuseCases = misuseCases;
+  if (edgeCases.length > 0) s.edgeCases = edgeCases;
+  return Object.keys(s).length > 0 ? s : void 0;
+}
+function parseCriterion(node) {
+  const crit = { then: text(child(node, "then")) ?? "" };
+  const id = attr(node, "id");
+  const given = text(child(node, "given"));
+  const when = text(child(node, "when"));
+  if (id !== void 0) crit.id = id;
+  if (given !== void 0) crit.given = given;
+  if (when !== void 0) crit.when = when;
+  return crit;
+}
+function parseRequirement(node) {
+  const req = {
+    id: attr(node, "id") ?? "",
+    type: attr(node, "type") ?? "FR",
+    title: attr(node, "title") ?? "",
+    statement: text(child(node, "statement")) ?? "",
+    acceptance: []
+  };
+  const status = attr(node, "status");
+  const priority = attr(node, "priority");
+  const ownerRef = attr(node, "ownerRef");
+  const appliesTo = attr(node, "appliesTo");
+  const rationale = text(child(node, "rationale"));
+  const notes = text(child(node, "notes"));
+  if (status !== void 0) req.status = status;
+  if (priority !== void 0) req.priority = priority;
+  if (ownerRef !== void 0) req.ownerRef = ownerRef;
+  if (appliesTo !== void 0) req.appliesTo = appliesTo;
+  if (rationale !== void 0) req.rationale = rationale;
+  if (notes !== void 0) req.notes = notes;
+  req.acceptance = asArray(child(child(node, "acceptance"), "criterion")).map(
+    parseCriterion
+  );
+  return req;
+}
+function parsePackage(node) {
+  const pkg = {
+    id: attr(node, "id") ?? "",
+    title: attr(node, "title") ?? "",
+    requirements: asArray(child(node, "req")).map(parseRequirement)
+  };
+  const ownerRef = attr(node, "ownerRef");
+  const description = text(child(node, "description"));
+  if (ownerRef !== void 0) pkg.ownerRef = ownerRef;
+  if (description !== void 0) pkg.description = description;
+  return pkg;
+}
+function parseState(node) {
+  const st = { id: attr(node, "id") ?? "", name: attr(node, "name") ?? "" };
+  const type = attr(node, "type");
+  const description = text(child(node, "description"));
+  const onEntry = text(child(node, "onEntry"));
+  const onExit = text(child(node, "onExit"));
+  const invariant = text(child(node, "invariant"));
+  if (type !== void 0) st.type = type;
+  if (description !== void 0) st.description = description;
+  if (onEntry !== void 0) st.onEntry = onEntry;
+  if (onExit !== void 0) st.onExit = onExit;
+  if (invariant !== void 0) st.invariant = invariant;
+  return st;
+}
+function parseTransition(node) {
+  const tr = {
+    id: attr(node, "id") ?? "",
+    from: attr(node, "from") ?? "",
+    to: attr(node, "to") ?? ""
+  };
+  const event = attr(node, "event");
+  const description = text(child(node, "description"));
+  const trigger = text(child(node, "trigger"));
+  const guard = text(child(node, "guard"));
+  const action = text(child(node, "action"));
+  if (event !== void 0) tr.event = event;
+  if (description !== void 0) tr.description = description;
+  if (trigger !== void 0) tr.trigger = trigger;
+  if (guard !== void 0) tr.guard = guard;
+  if (action !== void 0) tr.action = action;
+  return tr;
+}
+function parseStateMachine(node) {
+  const sm = {
+    id: attr(node, "id") ?? "",
+    name: attr(node, "name") ?? "",
+    initial: attr(node, "initial") ?? "",
+    states: asArray(child(node, "state")).map(parseState)
+  };
+  const entityRef = attr(node, "entityRef");
+  const description = text(child(node, "description"));
+  if (entityRef !== void 0) sm.entityRef = entityRef;
+  if (description !== void 0) sm.description = description;
+  const transitions = asArray(child(node, "transition")).map(parseTransition);
+  if (transitions.length > 0) sm.transitions = transitions;
+  return sm;
+}
+function parseBehavior(node) {
+  if (!isNode(node)) return void 0;
+  const stateMachines = asArray(node.stateMachine).map(parseStateMachine);
+  return stateMachines.length > 0 ? { stateMachines } : void 0;
+}
+function parseEndpoint(node) {
+  const ep = {
+    id: attr(node, "id") ?? "",
+    method: attr(node, "method") ?? "",
+    path: attr(node, "path") ?? ""
+  };
+  const summary = text(child(node, "summary"));
+  const request = text(child(node, "request"));
+  const response = text(child(node, "response"));
+  const errors = text(child(node, "errors"));
+  if (summary !== void 0) ep.summary = summary;
+  if (request !== void 0) ep.request = request;
+  if (response !== void 0) ep.response = response;
+  if (errors !== void 0) ep.errors = errors;
+  return ep;
+}
+function parseApi(node) {
+  const api = { id: attr(node, "id") ?? "", name: attr(node, "name") ?? "" };
+  const protocol = attr(node, "protocol");
+  const auth = attr(node, "auth");
+  const description = text(child(node, "description"));
+  if (protocol !== void 0) api.protocol = protocol;
+  if (auth !== void 0) api.auth = auth;
+  if (description !== void 0) api.description = description;
+  const endpoints = asArray(child(node, "endpoint")).map(parseEndpoint);
+  if (endpoints.length > 0) api.endpoints = endpoints;
+  return api;
+}
+function parseEvent(node) {
+  const ev = { id: attr(node, "id") ?? "", name: attr(node, "name") ?? "" };
+  const description = text(child(node, "description"));
+  const payload = text(child(node, "payload"));
+  if (description !== void 0) ev.description = description;
+  if (payload !== void 0) ev.payload = payload;
+  return ev;
+}
+function parseInterfaces(node) {
+  if (!isNode(node)) return void 0;
+  const i = {};
+  const apis = asArray(node.api).map(parseApi);
+  const events = asArray(node.event).map(parseEvent);
+  if (apis.length > 0) i.apis = apis;
+  if (events.length > 0) i.events = events;
+  return Object.keys(i).length > 0 ? i : void 0;
+}
+function parseTestSuite(node) {
+  const ts = {
+    id: attr(node, "id") ?? "",
+    title: attr(node, "title") ?? ""
+  };
+  const description = text(child(node, "description"));
+  if (description !== void 0) ts.description = description;
+  return ts;
+}
+function parseTestCase(node) {
+  const tc = {
+    id: attr(node, "id") ?? "",
+    type: attr(node, "type") ?? "acceptance",
+    title: attr(node, "title") ?? ""
+  };
+  const purpose = text(child(node, "purpose"));
+  const steps = text(child(node, "steps"));
+  const expected = text(child(node, "expected"));
+  if (purpose !== void 0) tc.purpose = purpose;
+  if (steps !== void 0) tc.steps = steps;
+  if (expected !== void 0) tc.expected = expected;
+  return tc;
+}
+function parseVerification(node) {
+  if (!isNode(node)) return void 0;
+  const v = {};
+  const testSuites = asArray(node.testSuite).map(parseTestSuite);
+  const testCases = asArray(node.testCase).map(parseTestCase);
+  if (testSuites.length > 0) v.testSuites = testSuites;
+  if (testCases.length > 0) v.testCases = testCases;
+  return Object.keys(v).length > 0 ? v : void 0;
+}
+function parseLocator(parent) {
+  const loc = child(parent, "locator");
+  if (!isNode(loc)) return void 0;
+  if (isNode(loc.local)) {
+    const out = { kind: "local", id: attr(loc.local, "id") ?? "" };
+    const hintKind = attr(loc.local, "kind");
+    const title = attr(loc.local, "title");
+    if (hintKind !== void 0) out.hintKind = hintKind;
+    if (title !== void 0) out.title = title;
+    return out;
+  }
+  if (isNode(loc.doc)) {
+    const out = {
+      kind: "doc",
+      uri: attr(loc.doc, "uri") ?? "",
+      id: attr(loc.doc, "id") ?? ""
+    };
+    const docId = attr(loc.doc, "docId");
+    const version = attr(loc.doc, "version");
+    const git = attr(loc.doc, "git");
+    const hintKind = attr(loc.doc, "kind");
+    const title = attr(loc.doc, "title");
+    if (docId !== void 0) out.docId = docId;
+    if (version !== void 0) out.version = version;
+    if (git !== void 0) out.git = git;
+    if (hintKind !== void 0) out.hintKind = hintKind;
+    if (title !== void 0) out.title = title;
+    return out;
+  }
+  if (isNode(loc.external)) {
+    const out = {
+      kind: "external",
+      uri: attr(loc.external, "uri") ?? ""
+    };
+    const hintKind = attr(loc.external, "kind");
+    const title = attr(loc.external, "title");
+    if (hintKind !== void 0) out.hintKind = hintKind;
+    if (title !== void 0) out.title = title;
+    return out;
+  }
+  return void 0;
+}
+function applyEdgeMeta(edge, node) {
+  const confidence = numAttr(node, "confidence");
+  const status = attr(node, "status");
+  const createdBy = attr(node, "createdBy");
+  const createdAt = attr(node, "createdAt");
+  const tags = attr(node, "tags");
+  const notes = text(child(node, "notes"));
+  if (confidence !== void 0) edge.confidence = confidence;
+  if (status !== void 0) edge.status = status;
+  if (createdBy !== void 0) edge.createdBy = createdBy;
+  if (createdAt !== void 0) edge.createdAt = createdAt;
+  if (tags !== void 0) {
+    const arr = tags.split(/\s+/).filter((t) => t.length > 0);
+    if (arr.length > 0) edge.tags = arr;
+  }
+  if (notes !== void 0) edge.notes = notes;
+}
+function parseEdge(node) {
+  const from = parseLocator(child(node, "from"));
+  const to = parseLocator(child(node, "to"));
+  if (!from || !to) return void 0;
+  const edge = {
+    id: attr(node, "id") ?? "",
+    type: attr(node, "type") ?? "satisfies",
+    from,
+    to
+  };
+  applyEdgeMeta(edge, node);
+  return edge;
+}
+function parseFlatEdge(node) {
+  const fromId = attr(node, "from");
+  const toId = attr(node, "to");
+  const fromUri = attr(node, "fromUri");
+  const toUri = attr(node, "toUri");
+  let from;
+  let to;
+  if (fromId !== void 0) from = { kind: "local", id: fromId };
+  else if (fromUri !== void 0) from = { kind: "external", uri: fromUri };
+  if (toId !== void 0) to = { kind: "local", id: toId };
+  else if (toUri !== void 0) to = { kind: "external", uri: toUri };
+  if (!from || !to) return void 0;
+  const edge = {
+    id: attr(node, "id") ?? "",
+    type: attr(node, "type") ?? "satisfies",
+    from,
+    to
+  };
+  applyEdgeMeta(edge, node);
+  return edge;
+}
+function parseTrace(root) {
+  const traceNode = child(root, "trace");
+  if (!isNode(traceNode)) return [];
+  const edges = [];
+  for (const e of asArray(traceNode.edge)) {
+    const parsed = parseEdge(e);
+    if (parsed) edges.push(parsed);
+  }
+  for (const e of asArray(traceNode.traceEdge)) {
+    const parsed = parseFlatEdge(e);
+    if (parsed) edges.push(parsed);
+  }
+  return edges;
+}
+function parseIssue(node) {
+  const iss = {
+    id: attr(node, "id") ?? "",
+    statement: text(child(node, "statement")) ?? ""
+  };
+  const status = attr(node, "status");
+  const owner = attr(node, "owner");
+  const notes = text(child(node, "notes"));
+  if (status !== void 0) iss.status = status;
+  if (owner !== void 0) iss.owner = owner;
+  if (notes !== void 0) iss.notes = notes;
+  return iss;
+}
+function parseApproval(node) {
+  const ap = { id: attr(node, "id") ?? "", role: attr(node, "role") ?? "" };
+  const status = attr(node, "status");
+  const description = text(child(node, "description"));
+  if (status !== void 0) ap.status = status;
+  if (description !== void 0) ap.description = description;
+  return ap;
+}
+function parseGovernance(node) {
+  if (!isNode(node)) return void 0;
+  const g = {};
+  const issues = asArray(node.issue).map(parseIssue);
+  const approvals = asArray(node.approval).map(parseApproval);
+  if (issues.length > 0) g.issues = issues;
+  if (approvals.length > 0) g.approvals = approvals;
+  return Object.keys(g).length > 0 ? g : void 0;
+}
+function parse(xml) {
+  const wellFormed = import_fast_xml_parser.XMLValidator.validate(xml, { allowBooleanAttributes: true });
+  if (wellFormed !== true) {
+    const err = wellFormed.err;
+    const diag = {
+      source: "parse",
+      severity: "error",
+      message: err.msg
+    };
+    if (typeof err.line === "number") diag.line = err.line;
+    if (typeof err.col === "number") diag.column = err.col;
+    return { ok: false, error: diag };
+  }
+  let obj;
+  try {
+    obj = parser.parse(xml);
+  } catch (e) {
+    return {
+      ok: false,
+      error: {
+        source: "parse",
+        severity: "error",
+        message: e instanceof Error ? e.message : String(e)
+      }
+    };
+  }
+  const root = obj.rqml;
+  if (!isNode(root)) {
+    return {
+      ok: false,
+      error: {
+        source: "parse",
+        severity: "error",
+        message: "Missing root <rqml> element."
+      }
+    };
+  }
+  const requirements = isNode(root.requirements) ? root.requirements : {};
+  const document = {
+    version: attr(root, "version") ?? "",
+    docId: attr(root, "docId") ?? "",
+    status: attr(root, "status") ?? "draft",
+    meta: parseMeta(root.meta),
+    packages: asArray(requirements.reqPackage).map(parsePackage),
+    looseRequirements: asArray(requirements.req).map(parseRequirement),
+    trace: parseTrace(root)
+  };
+  const catalogs = parseCatalogs(root.catalogs);
+  if (catalogs) document.catalogs = catalogs;
+  const domain = parseDomain(root.domain);
+  if (domain) document.domain = domain;
+  const goals = parseGoals(root.goals);
+  if (goals) document.goals = goals;
+  const scenarios = parseScenarios(root.scenarios);
+  if (scenarios) document.scenarios = scenarios;
+  const behavior = parseBehavior(root.behavior);
+  if (behavior) document.behavior = behavior;
+  const interfaces = parseInterfaces(root.interfaces);
+  if (interfaces) document.interfaces = interfaces;
+  const verification = parseVerification(root.verification);
+  if (verification) document.verification = verification;
+  const governance = parseGovernance(root.governance);
+  if (governance) document.governance = governance;
+  const raw = {};
+  for (const [key, value] of Object.entries(root)) {
+    if (key.startsWith(ATTR_PREFIX)) {
+      if (!KNOWN_ROOT_ATTRS.has(key)) raw[key] = value;
+    } else if (!MODELED_SECTIONS.has(key)) {
+      raw[key] = value;
+    }
+  }
+  setRawSections(document, raw);
+  return { ok: true, document };
+}
+var ATTR_PREFIX2 = "@_";
+new import_fast_xml_parser.XMLBuilder({
+  ignoreAttributes: false,
+  attributeNamePrefix: ATTR_PREFIX2,
+  format: true,
+  suppressEmptyNode: true,
+  // Keep value="true" attributes intact; otherwise XMLBuilder collapses them to
+  // valueless attributes (e.g. `required`), which the parser then drops.
+  suppressBooleanAttributes: false
+});
+function scaleSeverity(nominal, strictness) {
+  const ladder = ["info", "warning", "error"];
+  const base = ladder.indexOf(nominal);
+  const shift = 0;
+  const next = base + shift;
+  if (next < 0) return void 0;
+  return ladder[Math.min(next, ladder.length - 1)];
+}
+function missingAcceptance(doc, strictness) {
+  const severity = scaleSeverity("warning");
+  if (severity === void 0) return [];
+  return allRequirements(doc).filter((req) => req.acceptance.length === 0).map((req) => ({
+    source: "lint",
+    severity,
+    rule: "missing-acceptance",
+    message: `Requirement "${req.id}" has no acceptance criteria.`
+  }));
+}
+function lint(doc, options) {
+  return [...missingAcceptance(doc)];
+}
+function requirementIndex(doc) {
+  const index = /* @__PURE__ */ new Map();
+  for (const req of allRequirements(doc)) index.set(req.id, req);
+  return index;
+}
+function declaredIdIndex(doc) {
+  const index = /* @__PURE__ */ new Map();
+  for (const ref of declaredElements(doc)) {
+    if (!index.has(ref.id)) index.set(ref.id, ref);
+  }
+  return index;
+}
+function resolveTrace(doc) {
+  const idIndex = declaredIdIndex(doc);
+  const reqIndex = requirementIndex(doc);
+  const diagnostics = [];
+  const resolveEndpoint = (locator, edge, side) => {
+    if (locator.kind !== "local") return { locator };
+    const target = idIndex.get(locator.id);
+    if (target === void 0) {
+      diagnostics.push({
+        source: "trace",
+        severity: "error",
+        rule: "unresolved-local-ref",
+        message: `Trace edge "${edge.id}" (${side}) references unknown local id "${locator.id}".`
+      });
+      return { locator };
+    }
+    const resolved = { locator, target };
+    const requirement = reqIndex.get(locator.id);
+    if (requirement !== void 0) resolved.requirement = requirement;
+    return resolved;
+  };
+  const edges = doc.trace.map((edge) => ({
+    edge,
+    from: resolveEndpoint(edge.from, edge, "from"),
+    to: resolveEndpoint(edge.to, edge, "to")
+  }));
+  return { edges, diagnostics };
+}
+var ATTR_PREFIX3 = "@_";
+var REFERENCE_ELEMENTS = /* @__PURE__ */ new Set(["local", "doc"]);
+var parser2 = new import_fast_xml_parser.XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: ATTR_PREFIX3,
+  parseAttributeValue: false,
+  parseTagValue: false,
+  trimValues: true
+});
+function isNode2(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asArray2(v) {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+function str(v) {
+  return v == null ? void 0 : String(v);
+}
+function attr2(node, name) {
+  return str(node[ATTR_PREFIX3 + name]);
+}
+function nestedRefs(edge, out) {
+  const edgeId = attr2(edge, "id") ?? "";
+  for (const side of ["from", "to"]) {
+    const endpoint = edge[side];
+    const locator = isNode2(endpoint) ? endpoint.locator : void 0;
+    const local = isNode2(locator) ? locator.local : void 0;
+    const refId = isNode2(local) ? attr2(local, "id") : void 0;
+    if (refId !== void 0) out.push({ refId, edgeId, side, flat: false });
+  }
+}
+function flatRefs(edge, out) {
+  const edgeId = attr2(edge, "id") ?? "";
+  const from = attr2(edge, "from");
+  const to = attr2(edge, "to");
+  if (from !== void 0) out.push({ refId: from, edgeId, side: "from", flat: true });
+  if (to !== void 0) out.push({ refId: to, edgeId, side: "to", flat: true });
+}
+function walk(node, declared, refs) {
+  for (const [key, value] of Object.entries(node)) {
+    if (key.startsWith(ATTR_PREFIX3) || key === "#text") continue;
+    for (const item of asArray2(value)) {
+      if (!isNode2(item)) continue;
+      const id = attr2(item, "id");
+      if (id !== void 0 && !REFERENCE_ELEMENTS.has(key)) declared.push(id);
+      if (key === "edge") nestedRefs(item, refs);
+      else if (key === "traceEdge") flatRefs(item, refs);
+      walk(item, declared, refs);
+    }
+  }
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function lineStarts(xml) {
+  const starts = [0];
+  for (let i = 0; i < xml.length; i++) if (xml[i] === "\n") starts.push(i + 1);
+  return starts;
+}
+function lineAtOffset(starts, offset) {
+  let lo = 0;
+  let hi = starts.length - 1;
+  let ans = 0;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    const start = starts[mid];
+    if (start !== void 0 && start <= offset) {
+      ans = mid;
+      lo = mid + 1;
+    } else {
+      hi = mid - 1;
+    }
+  }
+  return ans + 1;
+}
+function matchLines(xml, starts, re) {
+  const lines = [];
+  re.lastIndex = 0;
+  let m;
+  while ((m = re.exec(xml)) !== null) {
+    lines.push(lineAtOffset(starts, m.index));
+    if (m.index === re.lastIndex) re.lastIndex++;
+  }
+  return lines;
+}
+function checkIntegrity(xml) {
+  let root;
+  try {
+    const obj = parser2.parse(xml);
+    root = isNode2(obj.rqml) ? obj.rqml : void 0;
+  } catch {
+    return [];
+  }
+  if (!root) return [];
+  const declared = [];
+  const refs = [];
+  walk(root, declared, refs);
+  const starts = lineStarts(xml);
+  const diagnostics = [];
+  const counts = /* @__PURE__ */ new Map();
+  for (const id of declared) counts.set(id, (counts.get(id) ?? 0) + 1);
+  for (const [id, count] of counts) {
+    if (id === "" || count < 2) continue;
+    const re = new RegExp(
+      `<(?!local\\b|doc\\b)[A-Za-z][\\w.:-]*\\b[^>]*?\\sid\\s*=\\s*"${escapeRegExp(id)}"`,
+      "g"
+    );
+    const lines = matchLines(xml, starts, re);
+    const redeclLines = lines.length >= 2 ? lines.slice(1) : [void 0];
+    for (const line of redeclLines) {
+      const diag = {
+        source: "validate",
+        severity: "error",
+        rule: "duplicate-id",
+        message: `Duplicate id "${id}": this id is already declared elsewhere in the document.`
+      };
+      if (typeof line === "number") diag.line = line;
+      diagnostics.push(diag);
+    }
+  }
+  const declaredSet = new Set(declared);
+  for (const ref of refs) {
+    if (ref.refId === "" || declaredSet.has(ref.refId)) continue;
+    const re = ref.flat ? new RegExp(
+      `<traceEdge\\b[^>]*?\\s${ref.side}\\s*=\\s*"${escapeRegExp(ref.refId)}"`,
+      "g"
+    ) : new RegExp(`<local\\b[^>]*?\\sid\\s*=\\s*"${escapeRegExp(ref.refId)}"`, "g");
+    const lines = matchLines(xml, starts, re);
+    const diag = {
+      source: "trace",
+      severity: "error",
+      rule: "unresolved-local-ref",
+      message: `Trace edge "${ref.edgeId}" (${ref.side}) references unknown id "${ref.refId}".`
+    };
+    if (lines.length > 0) diag.line = lines[0];
+    diagnostics.push(diag);
+  }
+  return diagnostics;
+}
+var UPWARD_TARGET_KINDS = /* @__PURE__ */ new Set([
+  "goal",
+  "qgoal",
+  "scenario",
+  "misuseCase",
+  "edgeCase"
+]);
+function add(group, type, edgeId) {
+  const existing = group[type];
+  if (existing) {
+    existing.push(edgeId);
+  } else {
+    group[type] = [edgeId];
+  }
+}
+function sortGroups(group) {
+  for (const key of Object.keys(group)) {
+    group[key] = [...new Set(group[key])].sort();
+  }
+}
+function computeCoverage(doc) {
+  const idIndex = declaredIdIndex(doc);
+  const reqs = allRequirements(doc);
+  const reqIds = new Set(reqs.map((r) => r.id));
+  const outgoing = /* @__PURE__ */ new Map();
+  const incoming = /* @__PURE__ */ new Map();
+  const ensure = (m, id) => {
+    let g = m.get(id);
+    if (g === void 0) {
+      g = {};
+      m.set(id, g);
+    }
+    return g;
+  };
+  for (const edge of doc.trace) {
+    if (edge.from.kind === "local")
+      add(ensure(outgoing, edge.from.id), edge.type, edge.id);
+    if (edge.to.kind === "local") add(ensure(incoming, edge.to.id), edge.type, edge.id);
+  }
+  const requirements = [...reqIds].sort().map((id) => {
+    const out = outgoing.get(id) ?? {};
+    const inc = incoming.get(id) ?? {};
+    sortGroups(out);
+    sortGroups(inc);
+    return { id, outgoing: out, incoming: inc };
+  });
+  const uncoveredGoals = [];
+  for (const [id, ref] of idIndex) {
+    if (ref.kind !== "goal" && ref.kind !== "qgoal") continue;
+    if (!(incoming.get(id)?.satisfies?.length ?? 0)) uncoveredGoals.push(id);
+  }
+  uncoveredGoals.sort();
+  const unverifiedRequirements = [];
+  const unimplementedRequirements = [];
+  const orphanRequirements = [];
+  for (const id of [...reqIds].sort()) {
+    const out = outgoing.get(id) ?? {};
+    const inc = incoming.get(id) ?? {};
+    const verified = (out.verifiedBy?.length ?? 0) > 0 || (inc.covers?.length ?? 0) > 0;
+    if (!verified) unverifiedRequirements.push(id);
+    if (!(inc.implements?.length ?? 0)) unimplementedRequirements.push(id);
+    const satisfiesUpward = (out.satisfies ?? []).some((edgeId) => {
+      const edge = doc.trace.find((e) => e.id === edgeId);
+      const to = edge?.to;
+      if (to?.kind !== "local") return false;
+      const target = idIndex.get(to.id);
+      return target !== void 0 && UPWARD_TARGET_KINDS.has(target.kind);
+    });
+    if (!satisfiesUpward) orphanRequirements.push(id);
+  }
+  const diagnostics = [];
+  for (const id of uncoveredGoals)
+    diagnostics.push(
+      finding(
+        "coverage",
+        "uncovered-goal",
+        `Goal "${id}" has no satisfying requirement.`
+      )
+    );
+  for (const id of unverifiedRequirements)
+    diagnostics.push(
+      finding(
+        "coverage",
+        "unverified-requirement",
+        `Requirement "${id}" has no verification edge.`
+      )
+    );
+  for (const id of unimplementedRequirements)
+    diagnostics.push(
+      finding(
+        "coverage",
+        "unimplemented-requirement",
+        `Requirement "${id}" has no implementation link.`
+      )
+    );
+  for (const id of orphanRequirements)
+    diagnostics.push(
+      finding(
+        "coverage",
+        "orphan-requirement",
+        `Requirement "${id}" satisfies no goal or scenario.`
+      )
+    );
+  diagnostics.push(...resolveTrace(doc).diagnostics);
+  return {
+    requirements,
+    uncoveredGoals,
+    unverifiedRequirements,
+    unimplementedRequirements,
+    orphanRequirements,
+    diagnostics
+  };
+}
+function finding(source, rule, message) {
+  return { source, severity: "warning", rule, message };
+}
+function implementsLinks(doc) {
+  const out = [];
+  for (const edge of doc.trace) {
+    if (edge.type !== "implements") continue;
+    const external = edge.from.kind === "external" ? edge.from : edge.to.kind === "external" ? edge.to : void 0;
+    if (external === void 0) continue;
+    const local = edge.from.kind === "local" ? edge.from.id : edge.to.kind === "local" ? edge.to.id : void 0;
+    const link = { edgeId: edge.id, uri: external.uri };
+    if (local !== void 0) link.requirementId = local;
+    out.push(link);
+  }
+  return out.sort((a, b) => a.edgeId.localeCompare(b.edgeId));
+}
+function filePathFromUri(uri, baseDir) {
+  const noFragment = uri.split("#")[0] ?? uri;
+  if (noFragment.startsWith("file://")) return fileURLToPath(noFragment);
+  if (noFragment.startsWith("file:")) {
+    const path = noFragment.slice("file:".length);
+    return isAbsolute(path) ? path : resolve(baseDir, path);
+  }
+  if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(noFragment)) {
+    return isAbsolute(noFragment) ? noFragment : resolve(baseDir, noFragment);
+  }
+  return void 0;
+}
+function filesystemResolver(baseDir) {
+  return (link) => {
+    const filePath = filePathFromUri(link.uri, baseDir);
+    if (filePath === void 0) return "present";
+    return existsSync(filePath) ? "present" : "missing";
+  };
+}
+function detectDrift(doc, options = {}) {
+  const baseDir = options.baseDir ?? process.cwd();
+  const resolve4 = options.resolve ?? filesystemResolver(baseDir);
+  const links = implementsLinks(doc);
+  const drifted = [];
+  const diagnostics = [];
+  for (const link of links) {
+    const status = resolve4(link);
+    if (status === "present") continue;
+    drifted.push({ ...link, status });
+    diagnostics.push({
+      source: "drift",
+      severity: "error",
+      rule: status === "missing" ? "missing-implementation" : "changed-implementation",
+      message: status === "missing" ? `implements edge "${link.edgeId}" points at "${link.uri}", which does not exist.` : `implements edge "${link.edgeId}" points at "${link.uri}", which has changed since approval.`
+    });
+  }
+  return { links, drifted, diagnostics };
+}
+
+// src/report.ts
+function formatDiagnostic(d) {
+  const loc = d.line !== void 0 ? `:${d.line}${d.column !== void 0 ? `:${d.column}` : ""}` : "";
+  const rule = d.rule !== void 0 ? ` [${d.rule}]` : "";
+  return `  ${d.severity}${loc} (${d.source})${rule}: ${d.message}`;
+}
+function printDiagnostics(diags) {
+  for (const d of diags) process.stdout.write(`${formatDiagnostic(d)}
+`);
+}
+var EXIT = {
+  OK: 0,
+  /** The document is not well-formed, schema-invalid, or fails integrity. */
+  VALIDATION: 1,
+  /** The check gate failed on blocking drift or coverage. */
+  CHECK: 2,
+  /** The command was invoked incorrectly. */
+  USAGE: 64
+};
+var UsageError = class extends Error {
+};
+var STRICTNESS = /* @__PURE__ */ new Set(["relaxed", "standard", "strict", "certified"]);
+function parseArgs(rest) {
+  const positionals = [];
+  const flags = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq >= 0) {
+        flags.set(a.slice(2, eq), a.slice(eq + 1));
+      } else {
+        const next = rest[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          flags.set(a.slice(2), next);
+          i++;
+        } else {
+          flags.set(a.slice(2), true);
+        }
+      }
+    } else {
+      positionals.push(a);
+    }
+  }
+  const strictness = String(flags.get("strictness") ?? "standard");
+  if (!STRICTNESS.has(strictness)) {
+    throw new UsageError(
+      `unknown strictness "${strictness}" (relaxed|standard|strict|certified)`
+    );
+  }
+  return {
+    positionals,
+    json: flags.get("json") === true || flags.get("json") === "true",
+    strictness,
+    baseDir: resolve(String(flags.get("base-dir") ?? process.cwd()))
+  };
+}
+function resolveSpecPath(args) {
+  const explicit = args.positionals[0];
+  if (explicit !== void 0) {
+    const p = resolve(args.baseDir, explicit);
+    if (!existsSync(p)) throw new UsageError(`spec file not found: ${explicit}`);
+    return p;
+  }
+  const candidates = readdirSync(args.baseDir).filter((f) => f.endsWith(".rqml")).sort();
+  if (candidates.length === 0) {
+    throw new UsageError("no .rqml document found in this directory; pass a path");
+  }
+  const preferred = candidates.includes("requirements.rqml") ? "requirements.rqml" : candidates[0];
+  return resolve(args.baseDir, preferred);
+}
+function readSpec(args) {
+  const path = resolveSpecPath(args);
+  return { path, xml: readFileSync(path, "utf8") };
+}
+
+// src/commands/check.ts
+function coverageBlocks(strictness) {
+  return strictness === "strict" || strictness === "certified";
+}
+async function runCheck(rest) {
+  const args = parseArgs(rest);
+  const { path, xml } = readSpec(args);
+  const { validate } = await import('./validate-O3LLP44J.js');
+  const validation = validate(xml);
+  const integrity = validation.valid ? checkIntegrity(xml) : [];
+  const parsed = parse(xml);
+  const coverage = parsed.ok ? computeCoverage(parsed.document) : void 0;
+  const drift = parsed.ok ? detectDrift(parsed.document, { baseDir: args.baseDir }) : void 0;
+  const validationFailed = !validation.valid || integrity.length > 0;
+  const driftFailed = (drift?.drifted.length ?? 0) > 0;
+  const coverageProblemCount = (coverage?.uncoveredGoals.length ?? 0) + (coverage?.unverifiedRequirements.length ?? 0) + (coverage?.orphanRequirements.length ?? 0);
+  const coverageFailed = coverageBlocks(args.strictness) && coverageProblemCount > 0;
+  const verdict = validationFailed || driftFailed || coverageFailed ? "fail" : "pass";
+  const diagnostics = [
+    ...validation.diagnostics,
+    ...integrity,
+    ...drift?.diagnostics ?? [],
+    ...coverageFailed ? coverage?.diagnostics ?? [] : []
+  ];
+  const report = {
+    path,
+    verdict,
+    strictness: args.strictness,
+    schemaVersion: validation.schemaVersion,
+    valid: !validationFailed,
+    drift: drift?.drifted ?? [],
+    coverage: coverage ? {
+      uncoveredGoals: coverage.uncoveredGoals,
+      unverifiedRequirements: coverage.unverifiedRequirements,
+      unimplementedRequirements: coverage.unimplementedRequirements,
+      orphanRequirements: coverage.orphanRequirements
+    } : null,
+    diagnostics
+  };
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+  } else {
+    if (diagnostics.length > 0) printDiagnostics(diagnostics);
+    process.stdout.write(
+      `${verdict === "pass" ? "\u2713" : "\u2717"} check ${verdict} (${args.strictness}) \u2014 ${path}
+`
+    );
+  }
+  if (validationFailed) return EXIT.VALIDATION;
+  if (driftFailed || coverageFailed) return EXIT.CHECK;
+  return EXIT.OK;
+}
+
+// ../schema/dist/index.js
+var AGENTS_default = "# RQML Agent Guidelines\n\n## Strictness: `standard`\n\n| Level | Description |\n|-------|-------------|\n| `relaxed` | Prototyping. Spec is advisory. Quick iteration allowed. |\n| `standard` | Production default. Spec-first for features. Core traces. |\n| `strict` | Full traceability. All behavior specified. No ghost features. |\n| `certified` | Regulated/safety-critical. Audit-grade traces with metadata. |\n\n---\n\nThis project uses **RQML** as the single source of truth for system intent. Familiarize yourself with the documentation at https://rqml.org/docs/user-guide/\n\n**Specification file:** Specification lives in a single .rqml file in the root of the project - convention is `requirements.rqml`. Multiple .rqml files may be employed in multirepo projects, in such cases a .rqml spec applies to everything that is higher in the project tree, unless overridden by another .rqml file.\n\n**Schema file:**\nThe RQML XSD schema is at https://rqml.org/schema/rqml-2.1.0.xsd (insert correct version number). Make sure to adhere to the schema at all times and follow guidelines in schema comments. Use as much of the RQML tagset as is necessary to capture and describe high quality requirements.\n\n---\n\n## Core Principle: Spec-First Development\n\n```\n[Elicit] \u2192 [Specify] \u2192 [Implement] \u2192 [Verify] \u2192 [Trace]\n    \u2191____________________\u2190______________________|\n```\n\nCode follows specification, not the reverse. If code and spec diverge, the spec is authoritative\u2014update the code or negotiate a spec change with the developer.\n\n---\n\n## Workflow\n\n### 1. Elicit\nAsk clarifying questions until you understand the goal, scope, acceptance criteria, and constraints. Don't assume\u2014capture assumptions as `<notes>` or `<issue>` elements.\n\n### 2. Specify\n**Never implement unspecified behavior.** Update the `.rqml` file before coding:\n- Add a `<req>` with statement and acceptance criteria\n- Set appropriate `type`, `priority`, and `status=\"draft\"`\n- Get developer confirmation before proceeding\n\n### 3. Implement\nReference requirement IDs in code comments. If you discover missing requirements, stop and add them to the spec first.\n\n### 4. Verify\nAdd tests that reference requirement IDs. Update `<trace>` section with verification links.\n\n---\n\n## When Code and Spec Diverge\n\n1. **Spec gap** (code has behavior not in spec): Propose adding the requirement, mark as `status=\"review\"`\n2. **Code bug** (code doesn't match spec): Fix the code\n3. **Spec bug** (spec is wrong): Propose correction, wait for developer confirmation\n\n**Never silently change the spec to match code.**\n\n---\n\n## Strictness Reference\n\n| Aspect | relaxed | standard | strict | certified |\n|--------|---------|----------|--------|-----------|\n| Elicitation | Major features | Testable reqs | Edge cases | Formal |\n| Spec-first | Recommended | Required | Required | Approved first |\n| Code traces | Optional | New features | All changes | With metadata |\n| Test traces | Optional | New reqs | All reqs | Full matrix |\n| Ghost features | Allowed | Blocked | Blocked | Blocked |\n\n---\n\n## Change Summary Template\n\nFor PRs and commits:\n\n```\n## RQML Trace Summary\n\n**Requirements:** REQ-xxx (added/modified/implemented)\n**Implementation:** `path/to/file` \u2014 what changed\n**Verification:** `path/to/test` \u2014 what it verifies\n**Open items:** gaps, assumptions, follow-ups\n```\n\n---\n\n## Schema Validation\n\nThe `.rqml` file must remain valid XML conforming to the version of RQML referenced in the version attribute in the spec document.\n\n**To validate:** Try xmllint first (pre-installed on macOS/Linux):\n```bash\nxmllint --schema https://rqml.org/schema/rqml-2.1.0.xsd <rqml-file-name> --noout\n```\n\nIf xmllint is unavailable, use Python with lxml:\n```bash\npip install lxml\npython -c \"from lxml import etree; s=etree.XMLSchema(etree.parse('https://rqml.org/schema/rqml-2.1.0.xsd')); print('Valid' if s.validate(etree.parse('<rqml-file-name>')) else s.error_log)\"\n```\n\n**IDE validation:** If the `.rqml` file includes `xsi:schemaLocation`, XML-aware editors (VS Code with XML extension, IntelliJ) validate automatically.\n\nThe schema comments contain detailed guidance on document structure, ID conventions, and requirement quality criteria.\n\n**If unsure:** Ask the developer before making structural changes to the spec.\n";
+var AGENTS_TEMPLATE = AGENTS_default;
+
+// src/commands/init.ts
+var STARTER_SPEC = `<?xml version="1.0" encoding="UTF-8"?>
+<rqml xmlns="https://rqml.org/schema/2.1.0" version="2.1.0" docId="PROJECT-001" status="draft">
+  <meta>
+    <title>My Project</title>
+    <system>my-system</system>
+  </meta>
+  <requirements>
+    <req id="REQ-EXAMPLE" type="FR" title="Example requirement" priority="must" status="draft">
+      <statement>The system SHALL do something useful.</statement>
+    </req>
+  </requirements>
+</rqml>
+`;
+async function runInit(rest) {
+  const args = parseArgs(rest);
+  const specPath = resolve(args.baseDir, args.positionals[0] ?? "requirements.rqml");
+  const agentsPath = resolve(args.baseDir, "AGENTS.md");
+  let wrote = false;
+  if (existsSync(specPath)) {
+    process.stdout.write(`skip (exists) ${specPath}
+`);
+  } else {
+    writeFileSync(specPath, STARTER_SPEC);
+    process.stdout.write(`created ${specPath}
+`);
+    wrote = true;
+  }
+  if (existsSync(agentsPath)) {
+    process.stdout.write(`skip (exists) ${agentsPath}
+`);
+  } else {
+    writeFileSync(agentsPath, AGENTS_TEMPLATE);
+    process.stdout.write(`created ${agentsPath}
+`);
+    wrote = true;
+  }
+  if (!wrote) process.stdout.write("nothing to do; project already initialized\n");
+  return EXIT.OK;
+}
+
+// src/commands/status.ts
+async function runStatus(rest) {
+  const args = parseArgs(rest);
+  const { path, xml } = readSpec(args);
+  const parsed = parse(xml);
+  if (!parsed.ok) {
+    process.stderr.write(`\u2717 ${path}: ${parsed.error.message}
+`);
+    return EXIT.VALIDATION;
+  }
+  const doc = parsed.document;
+  const coverage = computeCoverage(doc);
+  const lintDiags = lint(doc);
+  const trace = resolveTrace(doc);
+  const reqCount = doc.packages.reduce((n, p) => n + p.requirements.length, 0) + doc.looseRequirements.length;
+  const summary = {
+    path,
+    docId: doc.docId,
+    version: doc.version,
+    status: doc.status,
+    requirements: reqCount,
+    edges: doc.trace.length,
+    uncoveredGoals: coverage.uncoveredGoals,
+    unverifiedRequirements: coverage.unverifiedRequirements,
+    unimplementedRequirements: coverage.unimplementedRequirements,
+    orphanRequirements: coverage.orphanRequirements,
+    danglingReferences: trace.diagnostics.length,
+    lintFindings: lintDiags.length
+  };
+  if (args.json) {
+    process.stdout.write(`${JSON.stringify(summary, null, 2)}
+`);
+  } else {
+    process.stdout.write(
+      `RQML status \u2014 ${doc.docId} (${doc.version}, ${doc.status})
+  spec: ${path}
+  requirements: ${reqCount}   trace edges: ${doc.trace.length}
+  uncovered goals: ${coverage.uncoveredGoals.length}
+  unverified reqs: ${coverage.unverifiedRequirements.length}
+  unimplemented reqs: ${coverage.unimplementedRequirements.length}
+  dangling refs: ${trace.diagnostics.length}   lint findings: ${lintDiags.length}
+`
+    );
+  }
+  return EXIT.OK;
+}
+
+// src/commands/validate.ts
+async function runValidate(rest) {
+  const args = parseArgs(rest);
+  const { path, xml } = readSpec(args);
+  const { validate } = await import('./validate-O3LLP44J.js');
+  const result = validate(xml);
+  const integrity = result.valid ? checkIntegrity(xml) : [];
+  const diagnostics = [...result.diagnostics, ...integrity];
+  const ok = result.valid && integrity.length === 0;
+  if (args.json) {
+    process.stdout.write(
+      `${JSON.stringify({ path, valid: ok, schemaVersion: result.schemaVersion, diagnostics }, null, 2)}
+`
+    );
+  } else {
+    if (diagnostics.length > 0) printDiagnostics(diagnostics);
+    process.stdout.write(
+      ok ? `\u2713 ${path} is valid (schema ${result.schemaVersion})
+` : `\u2717 ${path}: ${diagnostics.length} problem(s)
+`
+    );
+  }
+  return ok ? EXIT.OK : EXIT.VALIDATION;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var HELP = `rqml \u2014 RQML reference CLI (v${VERSION})
+
+Usage:
+  rqml <command> [spec.rqml] [options]
+
+Commands:
+  init [path]      Scaffold a starter spec and AGENTS.md project marker
+  validate [path]  Validate XML well-formedness, XSD, and referential integrity
+  status [path]    Show spec, coverage, and lint summary
+  check [path]     Deterministic enforcement gate (validation + coverage + drift)
+
+Options:
+  --json                 Emit machine-readable JSON (status, check, validate)
+  --strictness <level>   relaxed | standard | strict | certified (default: standard)
+  --base-dir <dir>       Directory to resolve the spec and code links against
+  -h, --help             Show this help
+  -v, --version          Show version
+
+Exit codes: 0 ok \xB7 1 validation failure \xB7 2 check (drift/coverage) failure \xB7 64 usage
+`;
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case "validate":
+      return runValidate(rest);
+    case "status":
+      return runStatus(rest);
+    case "check":
+      return runCheck(rest);
+    case "init":
+      return runInit(rest);
+    case "-v":
+    case "--version":
+      process.stdout.write(`${VERSION}
+`);
+      return EXIT.OK;
+    case void 0:
+    case "-h":
+    case "--help":
+      process.stdout.write(HELP);
+      return EXIT.OK;
+    default:
+      process.stderr.write(`rqml: unknown command "${cmd}"
+
+${HELP}`);
+      return EXIT.USAGE;
+  }
+}
+main(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+}).catch((err) => {
+  const isUsage = err instanceof UsageError;
+  process.stderr.write(`rqml: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exitCode = isUsage ? EXIT.USAGE : EXIT.VALIDATION;
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map