fast-xml-parser 5.5.3 → 5.5.5

package/lib/fxp.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"./lib/fxp.min.js","mappings":"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","sources":["webpack://fxp/webpack/universalModuleDefinition","webpack://fxp/webpack/bootstrap","webpack://fxp/webpack/runtime/define property getters","webpack://fxp/webpack/runtime/hasOwnProperty shorthand","webpack://fxp/webpack/runtime/make namespace object","webpack://fxp/./src/util.js","webpack://fxp/./src/validator.js","webpack://fxp/./src/xmlparser/OptionsBuilder.js","webpack://fxp/./src/xmlparser/xmlNode.js","webpack://fxp/./src/xmlparser/DocTypeReader.js","webpack://fxp/./node_modules/strnum/strnum.js","webpack://fxp/./node_modules/path-expression-matcher/src/Matcher.js","webpack://fxp/./node_modules/path-expression-matcher/src/Expression.js","webpack://fxp/./src/xmlparser/OrderedObjParser.js","webpack://fxp/./src/ignoreAttributes.js","webpack://fxp/./src/xmlparser/node2json.js","webpack://fxp/./src/xmlparser/XMLParser.js","webpack://fxp/./node_modules/fast-xml-builder/src/orderedJs2Xml.js","webpack://fxp/./node_modules/fast-xml-builder/src/fxb.js","webpack://fxp/./node_modules/fast-xml-builder/src/ignoreAttributes.js","webpack://fxp/./src/xmlbuilder/json2xml.js","webpack://fxp/./src/fxp.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"fxp\"] = factory();\n\telse\n\t\troot[\"fxp\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","'use strict';\n\nconst 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';\nconst nameChar = nameStartChar + '\\\\-.\\\\d\\\\u00B7\\\\u0300-\\\\u036F\\\\u203F-\\\\u2040';\nexport const nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*';\nconst regexName = new RegExp('^' + nameRegexp + '$');\n\nexport function getAllMatches(string, regex) {\n  const matches = [];\n  let match = regex.exec(string);\n  while (match) {\n    const allmatches = [];\n    allmatches.startIndex = regex.lastIndex - match[0].length;\n    const len = match.length;\n    for (let index = 0; index < len; index++) {\n      allmatches.push(match[index]);\n    }\n    matches.push(allmatches);\n    match = regex.exec(string);\n  }\n  return matches;\n}\n\nexport const isName = function (string) {\n  const match = regexName.exec(string);\n  return !(match === null || typeof match === 'undefined');\n}\n\nexport function isExist(v) {\n  return typeof v !== 'undefined';\n}\n\nexport function isEmptyObject(obj) {\n  return Object.keys(obj).length === 0;\n}\n\nexport function getValue(v) {\n  if (exports.isExist(v)) {\n    return v;\n  } else {\n    return '';\n  }\n}\n","'use strict';\n\nimport { getAllMatches, isName } from './util.js';\n\nconst defaultOptions = {\n  allowBooleanAttributes: false, //A tag can have attributes without any value\n  unpairedTags: []\n};\n\n//const tagsPattern = new RegExp(\"<\\\\/?([\\\\w:\\\\-_\\.]+)\\\\s*\\/?>\",\"g\");\nexport function validate(xmlData, options) {\n  options = Object.assign({}, defaultOptions, options);\n\n  //xmlData = xmlData.replace(/(\\r\\n|\\n|\\r)/gm,\"\");//make it single line\n  //xmlData = xmlData.replace(/(^\\s*<\\?xml.*?\\?>)/g,\"\");//Remove XML starting tag\n  //xmlData = xmlData.replace(/(<!DOCTYPE[\\s\\w\\\"\\.\\/\\-\\:]+(\\[.*\\])*\\s*>)/g,\"\");//Remove DOCTYPE\n  const tags = [];\n  let tagFound = false;\n\n  //indicates that the root tag has been closed (aka. depth 0 has been reached)\n  let reachedRoot = false;\n\n  if (xmlData[0] === '\\ufeff') {\n    // check for byte order mark (BOM)\n    xmlData = xmlData.substr(1);\n  }\n\n  for (let i = 0; i < xmlData.length; i++) {\n\n    if (xmlData[i] === '<' && xmlData[i + 1] === '?') {\n      i += 2;\n      i = readPI(xmlData, i);\n      if (i.err) return i;\n    } else if (xmlData[i] === '<') {\n      //starting of tag\n      //read until you reach to '>' avoiding any '>' in attribute value\n      let tagStartPos = i;\n      i++;\n\n      if (xmlData[i] === '!') {\n        i = readCommentAndCDATA(xmlData, i);\n        continue;\n      } else {\n        let closingTag = false;\n        if (xmlData[i] === '/') {\n          //closing tag\n          closingTag = true;\n          i++;\n        }\n        //read tagname\n        let tagName = '';\n        for (; i < xmlData.length &&\n          xmlData[i] !== '>' &&\n          xmlData[i] !== ' ' &&\n          xmlData[i] !== '\\t' &&\n          xmlData[i] !== '\\n' &&\n          xmlData[i] !== '\\r'; i++\n        ) {\n          tagName += xmlData[i];\n        }\n        tagName = tagName.trim();\n        //console.log(tagName);\n\n        if (tagName[tagName.length - 1] === '/') {\n          //self closing tag without attributes\n          tagName = tagName.substring(0, tagName.length - 1);\n          //continue;\n          i--;\n        }\n        if (!validateTagName(tagName)) {\n          let msg;\n          if (tagName.trim().length === 0) {\n            msg = \"Invalid space after '<'.\";\n          } else {\n            msg = \"Tag '\" + tagName + \"' is an invalid name.\";\n          }\n          return getErrorObject('InvalidTag', msg, getLineNumberForPosition(xmlData, i));\n        }\n\n        const result = readAttributeStr(xmlData, i);\n        if (result === false) {\n          return getErrorObject('InvalidAttr', \"Attributes for '\" + tagName + \"' have open quote.\", getLineNumberForPosition(xmlData, i));\n        }\n        let attrStr = result.value;\n        i = result.index;\n\n        if (attrStr[attrStr.length - 1] === '/') {\n          //self closing tag\n          const attrStrStart = i - attrStr.length;\n          attrStr = attrStr.substring(0, attrStr.length - 1);\n          const isValid = validateAttributeString(attrStr, options);\n          if (isValid === true) {\n            tagFound = true;\n            //continue; //text may presents after self closing tag\n          } else {\n            //the result from the nested function returns the position of the error within the attribute\n            //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute\n            //this gives us the absolute index in the entire xml, which we can use to find the line at last\n            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));\n          }\n        } else if (closingTag) {\n          if (!result.tagClosed) {\n            return getErrorObject('InvalidTag', \"Closing tag '\" + tagName + \"' doesn't have proper closing.\", getLineNumberForPosition(xmlData, i));\n          } else if (attrStr.trim().length > 0) {\n            return getErrorObject('InvalidTag', \"Closing tag '\" + tagName + \"' can't have attributes or invalid starting.\", getLineNumberForPosition(xmlData, tagStartPos));\n          } else if (tags.length === 0) {\n            return getErrorObject('InvalidTag', \"Closing tag '\" + tagName + \"' has not been opened.\", getLineNumberForPosition(xmlData, tagStartPos));\n          } else {\n            const otg = tags.pop();\n            if (tagName !== otg.tagName) {\n              let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);\n              return getErrorObject('InvalidTag',\n                \"Expected closing tag '\" + otg.tagName + \"' (opened in line \" + openPos.line + \", col \" + openPos.col + \") instead of closing tag '\" + tagName + \"'.\",\n                getLineNumberForPosition(xmlData, tagStartPos));\n            }\n\n            //when there are no more tags, we reached the root level.\n            if (tags.length == 0) {\n              reachedRoot = true;\n            }\n          }\n        } else {\n          const isValid = validateAttributeString(attrStr, options);\n          if (isValid !== true) {\n            //the result from the nested function returns the position of the error within the attribute\n            //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute\n            //this gives us the absolute index in the entire xml, which we can use to find the line at last\n            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));\n          }\n\n          //if the root level has been reached before ...\n          if (reachedRoot === true) {\n            return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));\n          } else if (options.unpairedTags.indexOf(tagName) !== -1) {\n            //don't push into stack\n          } else {\n            tags.push({ tagName, tagStartPos });\n          }\n          tagFound = true;\n        }\n\n        //skip tag text value\n        //It may include comments and CDATA value\n        for (i++; i < xmlData.length; i++) {\n          if (xmlData[i] === '<') {\n            if (xmlData[i + 1] === '!') {\n              //comment or CADATA\n              i++;\n              i = readCommentAndCDATA(xmlData, i);\n              continue;\n            } else if (xmlData[i + 1] === '?') {\n              i = readPI(xmlData, ++i);\n              if (i.err) return i;\n            } else {\n              break;\n            }\n          } else if (xmlData[i] === '&') {\n            const afterAmp = validateAmpersand(xmlData, i);\n            if (afterAmp == -1)\n              return getErrorObject('InvalidChar', \"char '&' is not expected.\", getLineNumberForPosition(xmlData, i));\n            i = afterAmp;\n          } else {\n            if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {\n              return getErrorObject('InvalidXml', \"Extra text at the end\", getLineNumberForPosition(xmlData, i));\n            }\n          }\n        } //end of reading tag text value\n        if (xmlData[i] === '<') {\n          i--;\n        }\n      }\n    } else {\n      if (isWhiteSpace(xmlData[i])) {\n        continue;\n      }\n      return getErrorObject('InvalidChar', \"char '\" + xmlData[i] + \"' is not expected.\", getLineNumberForPosition(xmlData, i));\n    }\n  }\n\n  if (!tagFound) {\n    return getErrorObject('InvalidXml', 'Start tag expected.', 1);\n  } else if (tags.length == 1) {\n    return getErrorObject('InvalidTag', \"Unclosed tag '\" + tags[0].tagName + \"'.\", getLineNumberForPosition(xmlData, tags[0].tagStartPos));\n  } else if (tags.length > 0) {\n    return getErrorObject('InvalidXml', \"Invalid '\" +\n      JSON.stringify(tags.map(t => t.tagName), null, 4).replace(/\\r?\\n/g, '') +\n      \"' found.\", { line: 1, col: 1 });\n  }\n\n  return true;\n};\n\nfunction isWhiteSpace(char) {\n  return char === ' ' || char === '\\t' || char === '\\n' || char === '\\r';\n}\n/**\n * Read Processing insstructions and skip\n * @param {*} xmlData\n * @param {*} i\n */\nfunction readPI(xmlData, i) {\n  const start = i;\n  for (; i < xmlData.length; i++) {\n    if (xmlData[i] == '?' || xmlData[i] == ' ') {\n      //tagname\n      const tagname = xmlData.substr(start, i - start);\n      if (i > 5 && tagname === 'xml') {\n        return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i));\n      } else if (xmlData[i] == '?' && xmlData[i + 1] == '>') {\n        //check if valid attribut string\n        i++;\n        break;\n      } else {\n        continue;\n      }\n    }\n  }\n  return i;\n}\n\nfunction readCommentAndCDATA(xmlData, i) {\n  if (xmlData.length > i + 5 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') {\n    //comment\n    for (i += 3; i < xmlData.length; i++) {\n      if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') {\n        i += 2;\n        break;\n      }\n    }\n  } else if (\n    xmlData.length > i + 8 &&\n    xmlData[i + 1] === 'D' &&\n    xmlData[i + 2] === 'O' &&\n    xmlData[i + 3] === 'C' &&\n    xmlData[i + 4] === 'T' &&\n    xmlData[i + 5] === 'Y' &&\n    xmlData[i + 6] === 'P' &&\n    xmlData[i + 7] === 'E'\n  ) {\n    let angleBracketsCount = 1;\n    for (i += 8; i < xmlData.length; i++) {\n      if (xmlData[i] === '<') {\n        angleBracketsCount++;\n      } else if (xmlData[i] === '>') {\n        angleBracketsCount--;\n        if (angleBracketsCount === 0) {\n          break;\n        }\n      }\n    }\n  } else if (\n    xmlData.length > i + 9 &&\n    xmlData[i + 1] === '[' &&\n    xmlData[i + 2] === 'C' &&\n    xmlData[i + 3] === 'D' &&\n    xmlData[i + 4] === 'A' &&\n    xmlData[i + 5] === 'T' &&\n    xmlData[i + 6] === 'A' &&\n    xmlData[i + 7] === '['\n  ) {\n    for (i += 8; i < xmlData.length; i++) {\n      if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') {\n        i += 2;\n        break;\n      }\n    }\n  }\n\n  return i;\n}\n\nconst doubleQuote = '\"';\nconst singleQuote = \"'\";\n\n/**\n * Keep reading xmlData until '<' is found outside the attribute value.\n * @param {string} xmlData\n * @param {number} i\n */\nfunction readAttributeStr(xmlData, i) {\n  let attrStr = '';\n  let startChar = '';\n  let tagClosed = false;\n  for (; i < xmlData.length; i++) {\n    if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {\n      if (startChar === '') {\n        startChar = xmlData[i];\n      } else if (startChar !== xmlData[i]) {\n        //if vaue is enclosed with double quote then single quotes are allowed inside the value and vice versa\n      } else {\n        startChar = '';\n      }\n    } else if (xmlData[i] === '>') {\n      if (startChar === '') {\n        tagClosed = true;\n        break;\n      }\n    }\n    attrStr += xmlData[i];\n  }\n  if (startChar !== '') {\n    return false;\n  }\n\n  return {\n    value: attrStr,\n    index: i,\n    tagClosed: tagClosed\n  };\n}\n\n/**\n * Select all the attributes whether valid or invalid.\n */\nconst validAttrStrRegxp = new RegExp('(\\\\s*)([^\\\\s=]+)(\\\\s*=)?(\\\\s*([\\'\"])(([\\\\s\\\\S])*?)\\\\5)?', 'g');\n\n//attr, =\"sd\", a=\"amit's\", a=\"sd\"b=\"saf\", ab  cd=\"\"\n\nfunction validateAttributeString(attrStr, options) {\n  //console.log(\"start:\"+attrStr+\":end\");\n\n  //if(attrStr.trim().length === 0) return true; //empty string\n\n  const matches = getAllMatches(attrStr, validAttrStrRegxp);\n  const attrNames = {};\n\n  for (let i = 0; i < matches.length; i++) {\n    if (matches[i][1].length === 0) {\n      //nospace before attribute name: a=\"sd\"b=\"saf\"\n      return getErrorObject('InvalidAttr', \"Attribute '\" + matches[i][2] + \"' has no space in starting.\", getPositionFromMatch(matches[i]))\n    } else if (matches[i][3] !== undefined && matches[i][4] === undefined) {\n      return getErrorObject('InvalidAttr', \"Attribute '\" + matches[i][2] + \"' is without value.\", getPositionFromMatch(matches[i]));\n    } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {\n      //independent attribute: ab\n      return getErrorObject('InvalidAttr', \"boolean attribute '\" + matches[i][2] + \"' is not allowed.\", getPositionFromMatch(matches[i]));\n    }\n    /* else if(matches[i][6] === undefined){//attribute without value: ab=\n                    return { err: { code:\"InvalidAttr\",msg:\"attribute \" + matches[i][2] + \" has no value assigned.\"}};\n                } */\n    const attrName = matches[i][2];\n    if (!validateAttrName(attrName)) {\n      return getErrorObject('InvalidAttr', \"Attribute '\" + attrName + \"' is an invalid name.\", getPositionFromMatch(matches[i]));\n    }\n    if (!Object.prototype.hasOwnProperty.call(attrNames, attrName)) {\n      //check for duplicate attribute.\n      attrNames[attrName] = 1;\n    } else {\n      return getErrorObject('InvalidAttr', \"Attribute '\" + attrName + \"' is repeated.\", getPositionFromMatch(matches[i]));\n    }\n  }\n\n  return true;\n}\n\nfunction validateNumberAmpersand(xmlData, i) {\n  let re = /\\d/;\n  if (xmlData[i] === 'x') {\n    i++;\n    re = /[\\da-fA-F]/;\n  }\n  for (; i < xmlData.length; i++) {\n    if (xmlData[i] === ';')\n      return i;\n    if (!xmlData[i].match(re))\n      break;\n  }\n  return -1;\n}\n\nfunction validateAmpersand(xmlData, i) {\n  // https://www.w3.org/TR/xml/#dt-charref\n  i++;\n  if (xmlData[i] === ';')\n    return -1;\n  if (xmlData[i] === '#') {\n    i++;\n    return validateNumberAmpersand(xmlData, i);\n  }\n  let count = 0;\n  for (; i < xmlData.length; i++, count++) {\n    if (xmlData[i].match(/\\w/) && count < 20)\n      continue;\n    if (xmlData[i] === ';')\n      break;\n    return -1;\n  }\n  return i;\n}\n\nfunction getErrorObject(code, message, lineNumber) {\n  return {\n    err: {\n      code: code,\n      msg: message,\n      line: lineNumber.line || lineNumber,\n      col: lineNumber.col,\n    },\n  };\n}\n\nfunction validateAttrName(attrName) {\n  return isName(attrName);\n}\n\n// const startsWithXML = /^xml/i;\n\nfunction validateTagName(tagname) {\n  return isName(tagname) /* && !tagname.match(startsWithXML) */;\n}\n\n//this function returns the line number for the character at the given index\nfunction getLineNumberForPosition(xmlData, index) {\n  const lines = xmlData.substring(0, index).split(/\\r?\\n/);\n  return {\n    line: lines.length,\n\n    // column number is last line's length + 1, because column numbering starts at 1:\n    col: lines[lines.length - 1].length + 1\n  };\n}\n\n//this function returns the position of the first character of match within attrStr\nfunction getPositionFromMatch(match) {\n  return match.startIndex + match[1].length;\n}\n","export const defaultOptions = {\n  preserveOrder: false,\n  attributeNamePrefix: '@_',\n  attributesGroupName: false,\n  textNodeName: '#text',\n  ignoreAttributes: true,\n  removeNSPrefix: false, // remove NS from tag name or attribute name if true\n  allowBooleanAttributes: false, //a tag can have attributes without any value\n  //ignoreRootElement : false,\n  parseTagValue: true,\n  parseAttributeValue: false,\n  trimValues: true, //Trim string values of tag and attributes\n  cdataPropName: false,\n  numberParseOptions: {\n    hex: true,\n    leadingZeros: true,\n    eNotation: true\n  },\n  tagValueProcessor: function (tagName, val) {\n    return val;\n  },\n  attributeValueProcessor: function (attrName, val) {\n    return val;\n  },\n  stopNodes: [], //nested tags will not be parsed even for errors\n  alwaysCreateTextNode: false,\n  isArray: () => false,\n  commentPropName: false,\n  unpairedTags: [],\n  processEntities: true,\n  htmlEntities: false,\n  ignoreDeclaration: false,\n  ignorePiTags: false,\n  transformTagName: false,\n  transformAttributeName: false,\n  updateTag: function (tagName, jPath, attrs) {\n    return tagName\n  },\n  // skipEmptyListItem: false\n  captureMetaData: false,\n  maxNestedTags: 100,\n  strictReservedNames: true,\n  jPath: true, // if true, pass jPath string to callbacks; if false, pass matcher instance\n};\n\n/**\n * Normalizes processEntities option for backward compatibility\n * @param {boolean|object} value \n * @returns {object} Always returns normalized object\n */\nfunction normalizeProcessEntities(value) {\n  // Boolean backward compatibility\n  if (typeof value === 'boolean') {\n    return {\n      enabled: value, // true or false\n      maxEntitySize: 10000,\n      maxExpansionDepth: 10,\n      maxTotalExpansions: 1000,\n      maxExpandedLength: 100000,\n      maxEntityCount: 100,\n      allowedTags: null,\n      tagFilter: null\n    };\n  }\n\n  // Object config - merge with defaults\n  if (typeof value === 'object' && value !== null) {\n    return {\n      enabled: value.enabled !== false, // default true if not specified\n      maxEntitySize: value.maxEntitySize ?? 10000,\n      maxExpansionDepth: value.maxExpansionDepth ?? 10,\n      maxTotalExpansions: value.maxTotalExpansions ?? 1000,\n      maxExpandedLength: value.maxExpandedLength ?? 100000,\n      maxEntityCount: value.maxEntityCount ?? 100,\n      allowedTags: value.allowedTags ?? null,\n      tagFilter: value.tagFilter ?? null\n    };\n  }\n\n  // Default to enabled with limits\n  return normalizeProcessEntities(true);\n}\n\nexport const buildOptions = function (options) {\n  const built = Object.assign({}, defaultOptions, options);\n\n  // Always normalize processEntities for backward compatibility and validation\n  built.processEntities = normalizeProcessEntities(built.processEntities);\n\n  // Convert old-style stopNodes for backward compatibility\n  if (built.stopNodes && Array.isArray(built.stopNodes)) {\n    built.stopNodes = built.stopNodes.map(node => {\n      if (typeof node === 'string' && node.startsWith('*.')) {\n        // Old syntax: *.tagname meant \"tagname anywhere\"\n        // Convert to new syntax: ..tagname\n        return '..' + node.substring(2);\n      }\n      return node;\n    });\n  }\n  //console.debug(built.processEntities)\n  return built;\n};","'use strict';\n\nlet METADATA_SYMBOL;\n\nif (typeof Symbol !== \"function\") {\n  METADATA_SYMBOL = \"@@xmlMetadata\";\n} else {\n  METADATA_SYMBOL = Symbol(\"XML Node Metadata\");\n}\n\nexport default class XmlNode {\n  constructor(tagname) {\n    this.tagname = tagname;\n    this.child = []; //nested tags, text, cdata, comments in order\n    this[\":@\"] = Object.create(null); //attributes map\n  }\n  add(key, val) {\n    // this.child.push( {name : key, val: val, isCdata: isCdata });\n    if (key === \"__proto__\") key = \"#__proto__\";\n    this.child.push({ [key]: val });\n  }\n  addChild(node, startIndex) {\n    if (node.tagname === \"__proto__\") node.tagname = \"#__proto__\";\n    if (node[\":@\"] && Object.keys(node[\":@\"]).length > 0) {\n      this.child.push({ [node.tagname]: node.child, [\":@\"]: node[\":@\"] });\n    } else {\n      this.child.push({ [node.tagname]: node.child });\n    }\n    // if requested, add the startIndex\n    if (startIndex !== undefined) {\n      // Note: for now we just overwrite the metadata. If we had more complex metadata,\n      // we might need to do an object append here:  metadata = { ...metadata, startIndex }\n      this.child[this.child.length - 1][METADATA_SYMBOL] = { startIndex };\n    }\n  }\n  /** symbol used for metadata */\n  static getMetaDataSymbol() {\n    return METADATA_SYMBOL;\n  }\n}\n","import { isName } from '../util.js';\n\nexport default class DocTypeReader {\n    constructor(options) {\n        this.suppressValidationErr = !options;\n        this.options = options;\n    }\n\n    readDocType(xmlData, i) {\n        const entities = Object.create(null);\n        let entityCount = 0;\n\n        if (xmlData[i + 3] === 'O' &&\n            xmlData[i + 4] === 'C' &&\n            xmlData[i + 5] === 'T' &&\n            xmlData[i + 6] === 'Y' &&\n            xmlData[i + 7] === 'P' &&\n            xmlData[i + 8] === 'E') {\n            i = i + 9;\n            let angleBracketsCount = 1;\n            let hasBody = false, comment = false;\n            let exp = \"\";\n            for (; i < xmlData.length; i++) {\n                if (xmlData[i] === '<' && !comment) { //Determine the tag type\n                    if (hasBody && hasSeq(xmlData, \"!ENTITY\", i)) {\n                        i += 7;\n                        let entityName, val;\n                        [entityName, val, i] = this.readEntityExp(xmlData, i + 1, this.suppressValidationErr);\n                        if (val.indexOf(\"&\") === -1) { //Parameter entities are not supported\n                            if (this.options.enabled !== false &&\n                                this.options.maxEntityCount &&\n                                entityCount >= this.options.maxEntityCount) {\n                                throw new Error(\n                                    `Entity count (${entityCount + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`\n                                );\n                            }\n                            const escaped = entityName.replace(/[.\\-+*:]/g, '\\\\.');\n                            entities[entityName] = {\n                                regx: RegExp(`&${escaped};`, \"g\"),\n                                val: val\n                            };\n                            entityCount++;\n                        }\n                    }\n                    else if (hasBody && hasSeq(xmlData, \"!ELEMENT\", i)) {\n                        i += 8;//Not supported\n                        const { index } = this.readElementExp(xmlData, i + 1);\n                        i = index;\n                    } else if (hasBody && hasSeq(xmlData, \"!ATTLIST\", i)) {\n                        i += 8;//Not supported\n                        // const {index} = this.readAttlistExp(xmlData,i+1);\n                        // i = index;\n                    } else if (hasBody && hasSeq(xmlData, \"!NOTATION\", i)) {\n                        i += 9;//Not supported\n                        const { index } = this.readNotationExp(xmlData, i + 1, this.suppressValidationErr);\n                        i = index;\n                    } else if (hasSeq(xmlData, \"!--\", i)) comment = true;\n                    else throw new Error(`Invalid DOCTYPE`);\n\n                    angleBracketsCount++;\n                    exp = \"\";\n                } else if (xmlData[i] === '>') { //Read tag content\n                    if (comment) {\n                        if (xmlData[i - 1] === \"-\" && xmlData[i - 2] === \"-\") {\n                            comment = false;\n                            angleBracketsCount--;\n                        }\n                    } else {\n                        angleBracketsCount--;\n                    }\n                    if (angleBracketsCount === 0) {\n                        break;\n                    }\n                } else if (xmlData[i] === '[') {\n                    hasBody = true;\n                } else {\n                    exp += xmlData[i];\n                }\n            }\n            if (angleBracketsCount !== 0) {\n                throw new Error(`Unclosed DOCTYPE`);\n            }\n        } else {\n            throw new Error(`Invalid Tag instead of DOCTYPE`);\n        }\n        return { entities, i };\n    }\n    readEntityExp(xmlData, i) {\n        //External entities are not supported\n        //    <!ENTITY ext SYSTEM \"http://normal-website.com\" >\n\n        //Parameter entities are not supported\n        //    <!ENTITY entityname \"&anotherElement;\">\n\n        //Internal entities are supported\n        //    <!ENTITY entityname \"replacement text\">\n\n        // Skip leading whitespace after <!ENTITY\n        i = skipWhitespace(xmlData, i);\n\n        // Read entity name\n        let entityName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i]) && xmlData[i] !== '\"' && xmlData[i] !== \"'\") {\n            entityName += xmlData[i];\n            i++;\n        }\n        validateEntityName(entityName);\n\n        // Skip whitespace after entity name\n        i = skipWhitespace(xmlData, i);\n\n        // Check for unsupported constructs (external entities or parameter entities)\n        if (!this.suppressValidationErr) {\n            if (xmlData.substring(i, i + 6).toUpperCase() === \"SYSTEM\") {\n                throw new Error(\"External entities are not supported\");\n            } else if (xmlData[i] === \"%\") {\n                throw new Error(\"Parameter entities are not supported\");\n            }\n        }\n\n        // Read entity value (internal entity)\n        let entityValue = \"\";\n        [i, entityValue] = this.readIdentifierVal(xmlData, i, \"entity\");\n\n        // Validate entity size\n        if (this.options.enabled !== false &&\n            this.options.maxEntitySize &&\n            entityValue.length > this.options.maxEntitySize) {\n            throw new Error(\n                `Entity \"${entityName}\" size (${entityValue.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`\n            );\n        }\n\n        i--;\n        return [entityName, entityValue, i];\n    }\n\n    readNotationExp(xmlData, i) {\n        // Skip leading whitespace after <!NOTATION\n        i = skipWhitespace(xmlData, i);\n\n        // Read notation name\n        let notationName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            notationName += xmlData[i];\n            i++;\n        }\n        !this.suppressValidationErr && validateEntityName(notationName);\n\n        // Skip whitespace after notation name\n        i = skipWhitespace(xmlData, i);\n\n        // Check identifier type (SYSTEM or PUBLIC)\n        const identifierType = xmlData.substring(i, i + 6).toUpperCase();\n        if (!this.suppressValidationErr && identifierType !== \"SYSTEM\" && identifierType !== \"PUBLIC\") {\n            throw new Error(`Expected SYSTEM or PUBLIC, found \"${identifierType}\"`);\n        }\n        i += identifierType.length;\n\n        // Skip whitespace after identifier type\n        i = skipWhitespace(xmlData, i);\n\n        // Read public identifier (if PUBLIC)\n        let publicIdentifier = null;\n        let systemIdentifier = null;\n\n        if (identifierType === \"PUBLIC\") {\n            [i, publicIdentifier] = this.readIdentifierVal(xmlData, i, \"publicIdentifier\");\n\n            // Skip whitespace after public identifier\n            i = skipWhitespace(xmlData, i);\n\n            // Optionally read system identifier\n            if (xmlData[i] === '\"' || xmlData[i] === \"'\") {\n                [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, \"systemIdentifier\");\n            }\n        } else if (identifierType === \"SYSTEM\") {\n            // Read system identifier (mandatory for SYSTEM)\n            [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, \"systemIdentifier\");\n\n            if (!this.suppressValidationErr && !systemIdentifier) {\n                throw new Error(\"Missing mandatory system identifier for SYSTEM notation\");\n            }\n        }\n\n        return { notationName, publicIdentifier, systemIdentifier, index: --i };\n    }\n\n    readIdentifierVal(xmlData, i, type) {\n        let identifierVal = \"\";\n        const startChar = xmlData[i];\n        if (startChar !== '\"' && startChar !== \"'\") {\n            throw new Error(`Expected quoted string, found \"${startChar}\"`);\n        }\n        i++;\n\n        while (i < xmlData.length && xmlData[i] !== startChar) {\n            identifierVal += xmlData[i];\n            i++;\n        }\n\n        if (xmlData[i] !== startChar) {\n            throw new Error(`Unterminated ${type} value`);\n        }\n        i++;\n        return [i, identifierVal];\n    }\n\n    readElementExp(xmlData, i) {\n        // <!ELEMENT br EMPTY>\n        // <!ELEMENT div ANY>\n        // <!ELEMENT title (#PCDATA)>\n        // <!ELEMENT book (title, author+)>\n        // <!ELEMENT name (content-model)>\n\n        // Skip leading whitespace after <!ELEMENT\n        i = skipWhitespace(xmlData, i);\n\n        // Read element name\n        let elementName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            elementName += xmlData[i];\n            i++;\n        }\n\n        // Validate element name\n        if (!this.suppressValidationErr && !isName(elementName)) {\n            throw new Error(`Invalid element name: \"${elementName}\"`);\n        }\n\n        // Skip whitespace after element name\n        i = skipWhitespace(xmlData, i);\n        let contentModel = \"\";\n        // Expect '(' to start content model\n        if (xmlData[i] === \"E\" && hasSeq(xmlData, \"MPTY\", i)) i += 4;\n        else if (xmlData[i] === \"A\" && hasSeq(xmlData, \"NY\", i)) i += 2;\n        else if (xmlData[i] === \"(\") {\n            i++; // Move past '('\n\n            // Read content model\n            while (i < xmlData.length && xmlData[i] !== \")\") {\n                contentModel += xmlData[i];\n                i++;\n            }\n            if (xmlData[i] !== \")\") {\n                throw new Error(\"Unterminated content model\");\n            }\n\n        } else if (!this.suppressValidationErr) {\n            throw new Error(`Invalid Element Expression, found \"${xmlData[i]}\"`);\n        }\n\n        return {\n            elementName,\n            contentModel: contentModel.trim(),\n            index: i\n        };\n    }\n\n    readAttlistExp(xmlData, i) {\n        // Skip leading whitespace after <!ATTLIST\n        i = skipWhitespace(xmlData, i);\n\n        // Read element name\n        let elementName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            elementName += xmlData[i];\n            i++;\n        }\n\n        // Validate element name\n        validateEntityName(elementName)\n\n        // Skip whitespace after element name\n        i = skipWhitespace(xmlData, i);\n\n        // Read attribute name\n        let attributeName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            attributeName += xmlData[i];\n            i++;\n        }\n\n        // Validate attribute name\n        if (!validateEntityName(attributeName)) {\n            throw new Error(`Invalid attribute name: \"${attributeName}\"`);\n        }\n\n        // Skip whitespace after attribute name\n        i = skipWhitespace(xmlData, i);\n\n        // Read attribute type\n        let attributeType = \"\";\n        if (xmlData.substring(i, i + 8).toUpperCase() === \"NOTATION\") {\n            attributeType = \"NOTATION\";\n            i += 8; // Move past \"NOTATION\"\n\n            // Skip whitespace after \"NOTATION\"\n            i = skipWhitespace(xmlData, i);\n\n            // Expect '(' to start the list of notations\n            if (xmlData[i] !== \"(\") {\n                throw new Error(`Expected '(', found \"${xmlData[i]}\"`);\n            }\n            i++; // Move past '('\n\n            // Read the list of allowed notations\n            let allowedNotations = [];\n            while (i < xmlData.length && xmlData[i] !== \")\") {\n                let notation = \"\";\n                while (i < xmlData.length && xmlData[i] !== \"|\" && xmlData[i] !== \")\") {\n                    notation += xmlData[i];\n                    i++;\n                }\n\n                // Validate notation name\n                notation = notation.trim();\n                if (!validateEntityName(notation)) {\n                    throw new Error(`Invalid notation name: \"${notation}\"`);\n                }\n\n                allowedNotations.push(notation);\n\n                // Skip '|' separator or exit loop\n                if (xmlData[i] === \"|\") {\n                    i++; // Move past '|'\n                    i = skipWhitespace(xmlData, i); // Skip optional whitespace after '|'\n                }\n            }\n\n            if (xmlData[i] !== \")\") {\n                throw new Error(\"Unterminated list of notations\");\n            }\n            i++; // Move past ')'\n\n            // Store the allowed notations as part of the attribute type\n            attributeType += \" (\" + allowedNotations.join(\"|\") + \")\";\n        } else {\n            // Handle simple types (e.g., CDATA, ID, IDREF, etc.)\n            while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n                attributeType += xmlData[i];\n                i++;\n            }\n\n            // Validate simple attribute type\n            const validTypes = [\"CDATA\", \"ID\", \"IDREF\", \"IDREFS\", \"ENTITY\", \"ENTITIES\", \"NMTOKEN\", \"NMTOKENS\"];\n            if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {\n                throw new Error(`Invalid attribute type: \"${attributeType}\"`);\n            }\n        }\n\n        // Skip whitespace after attribute type\n        i = skipWhitespace(xmlData, i);\n\n        // Read default value\n        let defaultValue = \"\";\n        if (xmlData.substring(i, i + 8).toUpperCase() === \"#REQUIRED\") {\n            defaultValue = \"#REQUIRED\";\n            i += 8;\n        } else if (xmlData.substring(i, i + 7).toUpperCase() === \"#IMPLIED\") {\n            defaultValue = \"#IMPLIED\";\n            i += 7;\n        } else {\n            [i, defaultValue] = this.readIdentifierVal(xmlData, i, \"ATTLIST\");\n        }\n\n        return {\n            elementName,\n            attributeName,\n            attributeType,\n            defaultValue,\n            index: i\n        }\n    }\n}\n\n\n\nconst skipWhitespace = (data, index) => {\n    while (index < data.length && /\\s/.test(data[index])) {\n        index++;\n    }\n    return index;\n};\n\n\n\nfunction hasSeq(data, seq, i) {\n    for (let j = 0; j < seq.length; j++) {\n        if (seq[j] !== data[i + j + 1]) return false;\n    }\n    return true;\n}\n\nfunction validateEntityName(name) {\n    if (isName(name))\n        return name;\n    else\n        throw new Error(`Invalid entity name ${name}`);\n}","const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;\nconst numRegex = /^([\\-\\+])?(0*)([0-9]*(\\.[0-9]*)?)$/;\n// const octRegex = /^0x[a-z0-9]+/;\n// const binRegex = /0x[a-z0-9]+/;\n\n \nconst consider = {\n    hex :  true,\n    // oct: false,\n    leadingZeros: true,\n    decimalPoint: \"\\.\",\n    eNotation: true,\n    //skipLike: /regex/\n};\n\nexport default function toNumber(str, options = {}){\n    options = Object.assign({}, consider, options );\n    if(!str || typeof str !== \"string\" ) return str;\n    \n    let trimmedStr  = str.trim();\n    \n    if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;\n    else if(str===\"0\") return 0;\n    else if (options.hex && hexRegex.test(trimmedStr)) {\n        return parse_int(trimmedStr, 16);\n    // }else if (options.oct && octRegex.test(str)) {\n    //     return Number.parseInt(val, 8);\n    }else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation\n        return resolveEnotation(str,trimmedStr,options);\n    // }else if (options.parseBin && binRegex.test(str)) {\n    //     return Number.parseInt(val, 2);\n    }else{\n        //separate negative sign, leading zeros, and rest number\n        const match = numRegex.exec(trimmedStr);\n        // +00.123 => [ , '+', '00', '.123', ..\n        if(match){\n            const sign = match[1] || \"\";\n            const leadingZeros = match[2];\n            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros\n            const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.\n                str[leadingZeros.length+1] === \".\" \n                : str[leadingZeros.length] === \".\";\n\n            //trim ending zeros for floating number\n            if(!options.leadingZeros //leading zeros are not allowed\n                && (leadingZeros.length > 1 \n                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))){\n                // 00, 00.3, +03.24, 03, 03.24\n                return str;\n            }\n            else{//no leading zeros or leading zeros are allowed\n                const num = Number(trimmedStr);\n                const parsedStr = String(num);\n\n                if( num === 0) return num;\n                if(parsedStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation\n                    if(options.eNotation) return num;\n                    else return str;\n                }else if(trimmedStr.indexOf(\".\") !== -1){ //floating number\n                    if(parsedStr === \"0\") return num; //0.0\n                    else if(parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000\n                    else if( parsedStr === `${sign}${numTrimmedByZeros}`) return num;\n                    else return str;\n                }\n                \n                let n = leadingZeros? numTrimmedByZeros : trimmedStr;\n                if(leadingZeros){\n                    // -009 => -9\n                    return (n === parsedStr) || (sign+n === parsedStr) ? num : str\n                }else  {\n                    // +9\n                    return (n === parsedStr) || (n === sign+parsedStr) ? num : str\n                }\n            }\n        }else{ //non-numeric string\n            return str;\n        }\n    }\n}\n\nconst eNotationRegx = /^([-+])?(0*)(\\d*(\\.\\d*)?[eE][-\\+]?\\d+)$/;\nfunction resolveEnotation(str,trimmedStr,options){\n    if(!options.eNotation) return str;\n    const notation = trimmedStr.match(eNotationRegx); \n    if(notation){\n        let sign = notation[1] || \"\";\n        const eChar = notation[3].indexOf(\"e\") === -1 ? \"E\" : \"e\";\n        const leadingZeros = notation[2];\n        const eAdjacentToLeadingZeros = sign ? // 0E.\n            str[leadingZeros.length+1] === eChar \n            : str[leadingZeros.length] === eChar;\n\n        if(leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;\n        else if(leadingZeros.length === 1 \n            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)){\n                return Number(trimmedStr);\n        }else if(options.leadingZeros && !eAdjacentToLeadingZeros){ //accept with leading zeros\n            //remove leading 0s\n            trimmedStr = (notation[1] || \"\") + notation[3];\n            return Number(trimmedStr);\n        }else return str;\n    }else{\n        return str;\n    }\n}\n\n/**\n * \n * @param {string} numStr without leading zeros\n * @returns \n */\nfunction trimZeros(numStr){\n    if(numStr && numStr.indexOf(\".\") !== -1){//float\n        numStr = numStr.replace(/0+$/, \"\"); //remove ending zeros\n        if(numStr === \".\")  numStr = \"0\";\n        else if(numStr[0] === \".\")  numStr = \"0\"+numStr;\n        else if(numStr[numStr.length-1] === \".\")  numStr = numStr.substring(0,numStr.length-1);\n        return numStr;\n    }\n    return numStr;\n}\n\nfunction parse_int(numStr, base){\n    //polyfill\n    if(parseInt) return parseInt(numStr, base);\n    else if(Number.parseInt) return Number.parseInt(numStr, base);\n    else if(window && window.parseInt) return window.parseInt(numStr, base);\n    else throw new Error(\"parseInt, Number.parseInt, window.parseInt are not supported\")\n}","/**\n * Matcher - Tracks current path in XML/JSON tree and matches against Expressions\n * \n * The matcher maintains a stack of nodes representing the current path from root to\n * current tag. It only stores attribute values for the current (top) node to minimize\n * memory usage. Sibling tracking is used to auto-calculate position and counter.\n * \n * @example\n * const matcher = new Matcher();\n * matcher.push(\"root\", {});\n * matcher.push(\"users\", {});\n * matcher.push(\"user\", { id: \"123\", type: \"admin\" });\n * \n * const expr = new Expression(\"root.users.user\");\n * matcher.matches(expr); // true\n */\nexport default class Matcher {\n  /**\n   * Create a new Matcher\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Default path separator (default: '.')\n   */\n  constructor(options = {}) {\n    this.separator = options.separator || '.';\n    this.path = [];\n    this.siblingStacks = [];\n    // Each path node: { tag: string, values: object, position: number, counter: number }\n    // values only present for current (last) node\n    // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n  }\n\n  /**\n   * Push a new tag onto the path\n   * @param {string} tagName - Name of the tag\n   * @param {Object} attrValues - Attribute key-value pairs for current node (optional)\n   * @param {string} namespace - Namespace for the tag (optional)\n   */\n  push(tagName, attrValues = null, namespace = null) {\n    // Remove values from previous current node (now becoming ancestor)\n    if (this.path.length > 0) {\n      const prev = this.path[this.path.length - 1];\n      prev.values = undefined;\n    }\n\n    // Get or create sibling tracking for current level\n    const currentLevel = this.path.length;\n    if (!this.siblingStacks[currentLevel]) {\n      this.siblingStacks[currentLevel] = new Map();\n    }\n\n    const siblings = this.siblingStacks[currentLevel];\n\n    // Create a unique key for sibling tracking that includes namespace\n    const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;\n\n    // Calculate counter (how many times this tag appeared at this level)\n    const counter = siblings.get(siblingKey) || 0;\n\n    // Calculate position (total children at this level so far)\n    let position = 0;\n    for (const count of siblings.values()) {\n      position += count;\n    }\n\n    // Update sibling count for this tag\n    siblings.set(siblingKey, counter + 1);\n\n    // Create new node\n    const node = {\n      tag: tagName,\n      position: position,\n      counter: counter\n    };\n\n    // Store namespace if provided\n    if (namespace !== null && namespace !== undefined) {\n      node.namespace = namespace;\n    }\n\n    // Store values only for current node\n    if (attrValues !== null && attrValues !== undefined) {\n      node.values = attrValues;\n    }\n\n    this.path.push(node);\n  }\n\n  /**\n   * Pop the last tag from the path\n   * @returns {Object|undefined} The popped node\n   */\n  pop() {\n    if (this.path.length === 0) {\n      return undefined;\n    }\n\n    const node = this.path.pop();\n\n    // Clean up sibling tracking for levels deeper than current\n    // After pop, path.length is the new depth\n    // We need to clean up siblingStacks[path.length + 1] and beyond\n    if (this.siblingStacks.length > this.path.length + 1) {\n      this.siblingStacks.length = this.path.length + 1;\n    }\n\n    return node;\n  }\n\n  /**\n   * Update current node's attribute values\n   * Useful when attributes are parsed after push\n   * @param {Object} attrValues - Attribute values\n   */\n  updateCurrent(attrValues) {\n    if (this.path.length > 0) {\n      const current = this.path[this.path.length - 1];\n      if (attrValues !== null && attrValues !== undefined) {\n        current.values = attrValues;\n      }\n    }\n  }\n\n  /**\n   * Get current tag name\n   * @returns {string|undefined}\n   */\n  getCurrentTag() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;\n  }\n\n  /**\n   * Get current namespace\n   * @returns {string|undefined}\n   */\n  getCurrentNamespace() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;\n  }\n\n  /**\n   * Get current node's attribute value\n   * @param {string} attrName - Attribute name\n   * @returns {*} Attribute value or undefined\n   */\n  getAttrValue(attrName) {\n    if (this.path.length === 0) return undefined;\n    const current = this.path[this.path.length - 1];\n    return current.values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute\n   * @param {string} attrName - Attribute name\n   * @returns {boolean}\n   */\n  hasAttr(attrName) {\n    if (this.path.length === 0) return false;\n    const current = this.path[this.path.length - 1];\n    return current.values !== undefined && attrName in current.values;\n  }\n\n  /**\n   * Get current node's sibling position (child index in parent)\n   * @returns {number}\n   */\n  getPosition() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].position ?? 0;\n  }\n\n  /**\n   * Get current node's repeat counter (occurrence count of this tag name)\n   * @returns {number}\n   */\n  getCounter() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].counter ?? 0;\n  }\n\n  /**\n   * Get current node's sibling index (alias for getPosition for backward compatibility)\n   * @returns {number}\n   * @deprecated Use getPosition() or getCounter() instead\n   */\n  getIndex() {\n    return this.getPosition();\n  }\n\n  /**\n   * Get current path depth\n   * @returns {number}\n   */\n  getDepth() {\n    return this.path.length;\n  }\n\n  /**\n   * Get path as string\n   * @param {string} separator - Optional separator (uses default if not provided)\n   * @param {boolean} includeNamespace - Whether to include namespace in output (default: true)\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    const sep = separator || this.separator;\n    return this.path.map(n => {\n      if (includeNamespace && n.namespace) {\n        return `${n.namespace}:${n.tag}`;\n      }\n      return n.tag;\n    }).join(sep);\n  }\n\n  /**\n   * Get path as array of tag names\n   * @returns {string[]}\n   */\n  toArray() {\n    return this.path.map(n => n.tag);\n  }\n\n  /**\n   * Reset the path to empty\n   */\n  reset() {\n    this.path = [];\n    this.siblingStacks = [];\n  }\n\n  /**\n   * Match current path against an Expression\n   * @param {Expression} expression - The expression to match against\n   * @returns {boolean} True if current path matches the expression\n   */\n  matches(expression) {\n    const segments = expression.segments;\n\n    if (segments.length === 0) {\n      return false;\n    }\n\n    // Handle deep wildcard patterns\n    if (expression.hasDeepWildcard()) {\n      return this._matchWithDeepWildcard(segments);\n    }\n\n    // Simple path matching (no deep wildcards)\n    return this._matchSimple(segments);\n  }\n\n  /**\n   * Match simple path (no deep wildcards)\n   * @private\n   */\n  _matchSimple(segments) {\n    // Path must be same length as segments\n    if (this.path.length !== segments.length) {\n      return false;\n    }\n\n    // Match each segment bottom-to-top\n    for (let i = 0; i < segments.length; i++) {\n      const segment = segments[i];\n      const node = this.path[i];\n      const isCurrentNode = (i === this.path.length - 1);\n\n      if (!this._matchSegment(segment, node, isCurrentNode)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Match path with deep wildcards\n   * @private\n   */\n  _matchWithDeepWildcard(segments) {\n    let pathIdx = this.path.length - 1;  // Start from current node (bottom)\n    let segIdx = segments.length - 1;     // Start from last segment\n\n    while (segIdx >= 0 && pathIdx >= 0) {\n      const segment = segments[segIdx];\n\n      if (segment.type === 'deep-wildcard') {\n        // \"..\" matches zero or more levels\n        segIdx--;\n\n        if (segIdx < 0) {\n          // Pattern ends with \"..\", always matches\n          return true;\n        }\n\n        // Find where next segment matches in the path\n        const nextSeg = segments[segIdx];\n        let found = false;\n\n        for (let i = pathIdx; i >= 0; i--) {\n          const isCurrentNode = (i === this.path.length - 1);\n          if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {\n            pathIdx = i - 1;\n            segIdx--;\n            found = true;\n            break;\n          }\n        }\n\n        if (!found) {\n          return false;\n        }\n      } else {\n        // Regular segment\n        const isCurrentNode = (pathIdx === this.path.length - 1);\n        if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {\n          return false;\n        }\n        pathIdx--;\n        segIdx--;\n      }\n    }\n\n    // All segments must be consumed\n    return segIdx < 0;\n  }\n\n  /**\n   * Match a single segment against a node\n   * @private\n   * @param {Object} segment - Segment from Expression\n   * @param {Object} node - Node from path\n   * @param {boolean} isCurrentNode - Whether this is the current (last) node\n   * @returns {boolean}\n   */\n  _matchSegment(segment, node, isCurrentNode) {\n    // Match tag name (* is wildcard)\n    if (segment.tag !== '*' && segment.tag !== node.tag) {\n      return false;\n    }\n\n    // Match namespace if specified in segment\n    if (segment.namespace !== undefined) {\n      // Segment has namespace - node must match it\n      if (segment.namespace !== '*' && segment.namespace !== node.namespace) {\n        return false;\n      }\n    }\n    // If segment has no namespace, it matches nodes with or without namespace\n\n    // Match attribute name (check if node has this attribute)\n    // Can only check for current node since ancestors don't have values\n    if (segment.attrName !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check attributes for ancestor nodes (values not stored)\n        return false;\n      }\n\n      if (!node.values || !(segment.attrName in node.values)) {\n        return false;\n      }\n\n      // Match attribute value (only possible for current node)\n      if (segment.attrValue !== undefined) {\n        const actualValue = node.values[segment.attrName];\n        // Both should be strings\n        if (String(actualValue) !== String(segment.attrValue)) {\n          return false;\n        }\n      }\n    }\n\n    // Match position (only for current node)\n    if (segment.position !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check position for ancestor nodes\n        return false;\n      }\n\n      const counter = node.counter ?? 0;\n\n      if (segment.position === 'first' && counter !== 0) {\n        return false;\n      } else if (segment.position === 'odd' && counter % 2 !== 1) {\n        return false;\n      } else if (segment.position === 'even' && counter % 2 !== 0) {\n        return false;\n      } else if (segment.position === 'nth') {\n        if (counter !== segment.positionValue) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Create a snapshot of current state\n   * @returns {Object} State snapshot\n   */\n  snapshot() {\n    return {\n      path: this.path.map(node => ({ ...node })),\n      siblingStacks: this.siblingStacks.map(map => new Map(map))\n    };\n  }\n\n  /**\n   * Restore state from snapshot\n   * @param {Object} snapshot - State snapshot\n   */\n  restore(snapshot) {\n    this.path = snapshot.path.map(node => ({ ...node }));\n    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));\n  }\n}","/**\n * Expression - Parses and stores a tag pattern expression\n * \n * Patterns are parsed once and stored in an optimized structure for fast matching.\n * \n * @example\n * const expr = new Expression(\"root.users.user\");\n * const expr2 = new Expression(\"..user[id]:first\");\n * const expr3 = new Expression(\"root/users/user\", { separator: '/' });\n */\nexport default class Expression {\n  /**\n   * Create a new Expression\n   * @param {string} pattern - Pattern string (e.g., \"root.users.user\", \"..user[id]\")\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Path separator (default: '.')\n   */\n  constructor(pattern, options = {}) {\n    this.pattern = pattern;\n    this.separator = options.separator || '.';\n    this.segments = this._parse(pattern);\n\n    // Cache expensive checks for performance (O(1) instead of O(n))\n    this._hasDeepWildcard = this.segments.some(seg => seg.type === 'deep-wildcard');\n    this._hasAttributeCondition = this.segments.some(seg => seg.attrName !== undefined);\n    this._hasPositionSelector = this.segments.some(seg => seg.position !== undefined);\n  }\n\n  /**\n   * Parse pattern string into segments\n   * @private\n   * @param {string} pattern - Pattern to parse\n   * @returns {Array} Array of segment objects\n   */\n  _parse(pattern) {\n    const segments = [];\n\n    // Split by separator but handle \"..\" specially\n    let i = 0;\n    let currentPart = '';\n\n    while (i < pattern.length) {\n      if (pattern[i] === this.separator) {\n        // Check if next char is also separator (deep wildcard)\n        if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {\n          // Flush current part if any\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n            currentPart = '';\n          }\n          // Add deep wildcard\n          segments.push({ type: 'deep-wildcard' });\n          i += 2; // Skip both separators\n        } else {\n          // Regular separator\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n          }\n          currentPart = '';\n          i++;\n        }\n      } else {\n        currentPart += pattern[i];\n        i++;\n      }\n    }\n\n    // Flush remaining part\n    if (currentPart.trim()) {\n      segments.push(this._parseSegment(currentPart.trim()));\n    }\n\n    return segments;\n  }\n\n  /**\n   * Parse a single segment\n   * @private\n   * @param {string} part - Segment string (e.g., \"user\", \"ns::user\", \"user[id]\", \"ns::user:first\")\n   * @returns {Object} Segment object\n   */\n  _parseSegment(part) {\n    const segment = { type: 'tag' };\n\n    // NEW NAMESPACE SYNTAX (v2.0):\n    // ============================\n    // Namespace uses DOUBLE colon (::)\n    // Position uses SINGLE colon (:)\n    // \n    // Examples:\n    //   \"user\"              → tag\n    //   \"user:first\"        → tag + position\n    //   \"user[id]\"          → tag + attribute\n    //   \"user[id]:first\"    → tag + attribute + position\n    //   \"ns::user\"          → namespace + tag\n    //   \"ns::user:first\"    → namespace + tag + position\n    //   \"ns::user[id]\"      → namespace + tag + attribute\n    //   \"ns::user[id]:first\" → namespace + tag + attribute + position\n    //   \"ns::first\"         → namespace + tag named \"first\" (NO ambiguity!)\n    //\n    // This eliminates all ambiguity:\n    //   :: = namespace separator\n    //   :  = position selector\n    //   [] = attributes\n\n    // Step 1: Extract brackets [attr] or [attr=value]\n    let bracketContent = null;\n    let withoutBrackets = part;\n\n    const bracketMatch = part.match(/^([^\\[]+)(\\[[^\\]]*\\])(.*)$/);\n    if (bracketMatch) {\n      withoutBrackets = bracketMatch[1] + bracketMatch[3];\n      if (bracketMatch[2]) {\n        const content = bracketMatch[2].slice(1, -1);\n        if (content) {\n          bracketContent = content;\n        }\n      }\n    }\n\n    // Step 2: Check for namespace (double colon ::)\n    let namespace = undefined;\n    let tagAndPosition = withoutBrackets;\n\n    if (withoutBrackets.includes('::')) {\n      const nsIndex = withoutBrackets.indexOf('::');\n      namespace = withoutBrackets.substring(0, nsIndex).trim();\n      tagAndPosition = withoutBrackets.substring(nsIndex + 2).trim(); // Skip ::\n\n      if (!namespace) {\n        throw new Error(`Invalid namespace in pattern: ${part}`);\n      }\n    }\n\n    // Step 3: Parse tag and position (single colon :)\n    let tag = undefined;\n    let positionMatch = null;\n\n    if (tagAndPosition.includes(':')) {\n      const colonIndex = tagAndPosition.lastIndexOf(':'); // Use last colon for position\n      const tagPart = tagAndPosition.substring(0, colonIndex).trim();\n      const posPart = tagAndPosition.substring(colonIndex + 1).trim();\n\n      // Verify position is a valid keyword\n      const isPositionKeyword = ['first', 'last', 'odd', 'even'].includes(posPart) ||\n        /^nth\\(\\d+\\)$/.test(posPart);\n\n      if (isPositionKeyword) {\n        tag = tagPart;\n        positionMatch = posPart;\n      } else {\n        // Not a valid position keyword, treat whole thing as tag\n        tag = tagAndPosition;\n      }\n    } else {\n      tag = tagAndPosition;\n    }\n\n    if (!tag) {\n      throw new Error(`Invalid segment pattern: ${part}`);\n    }\n\n    segment.tag = tag;\n    if (namespace) {\n      segment.namespace = namespace;\n    }\n\n    // Step 4: Parse attributes\n    if (bracketContent) {\n      if (bracketContent.includes('=')) {\n        const eqIndex = bracketContent.indexOf('=');\n        segment.attrName = bracketContent.substring(0, eqIndex).trim();\n        segment.attrValue = bracketContent.substring(eqIndex + 1).trim();\n      } else {\n        segment.attrName = bracketContent.trim();\n      }\n    }\n\n    // Step 5: Parse position selector\n    if (positionMatch) {\n      const nthMatch = positionMatch.match(/^nth\\((\\d+)\\)$/);\n      if (nthMatch) {\n        segment.position = 'nth';\n        segment.positionValue = parseInt(nthMatch[1], 10);\n      } else {\n        segment.position = positionMatch;\n      }\n    }\n\n    return segment;\n  }\n\n  /**\n   * Get the number of segments\n   * @returns {number}\n   */\n  get length() {\n    return this.segments.length;\n  }\n\n  /**\n   * Check if expression contains deep wildcard\n   * @returns {boolean}\n   */\n  hasDeepWildcard() {\n    return this._hasDeepWildcard;\n  }\n\n  /**\n   * Check if expression has attribute conditions\n   * @returns {boolean}\n   */\n  hasAttributeCondition() {\n    return this._hasAttributeCondition;\n  }\n\n  /**\n   * Check if expression has position selectors\n   * @returns {boolean}\n   */\n  hasPositionSelector() {\n    return this._hasPositionSelector;\n  }\n\n  /**\n   * Get string representation\n   * @returns {string}\n   */\n  toString() {\n    return this.pattern;\n  }\n}","'use strict';\n///@ts-check\n\nimport { getAllMatches, isExist } from '../util.js';\nimport xmlNode from './xmlNode.js';\nimport DocTypeReader from './DocTypeReader.js';\nimport toNumber from \"strnum\";\nimport getIgnoreAttributesFn from \"../ignoreAttributes.js\";\nimport { Expression, Matcher } from 'path-expression-matcher';\n\n\n// const regx =\n//   '<((!\\\\[CDATA\\\\[([\\\\s\\\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\\\/)(NAME)\\\\s*>))([^<]*)'\n//   .replace(/NAME/g, util.nameRegexp);\n\n//const tagsRegx = new RegExp(\"<(\\\\/?[\\\\w:\\\\-\\._]+)([^>]*)>(\\\\s*\"+cdataRegx+\")*([^<]+)?\",\"g\");\n//const tagsRegx = new RegExp(\"<(\\\\/?)((\\\\w*:)?([\\\\w:\\\\-\\._]+))([^>]*)>([^<]*)(\"+cdataRegx+\"([^<]*))*([^<]+)?\",\"g\");\n\n// Helper functions for attribute and namespace handling\n\n/**\n * Extract raw attributes (without prefix) from prefixed attribute map\n * @param {object} prefixedAttrs - Attributes with prefix from buildAttributesMap\n * @param {object} options - Parser options containing attributeNamePrefix\n * @returns {object} Raw attributes for matcher\n */\nfunction extractRawAttributes(prefixedAttrs, options) {\n  if (!prefixedAttrs) return {};\n\n  // Handle attributesGroupName option\n  const attrs = options.attributesGroupName\n    ? prefixedAttrs[options.attributesGroupName]\n    : prefixedAttrs;\n\n  if (!attrs) return {};\n\n  const rawAttrs = {};\n  for (const key in attrs) {\n    // Remove the attribute prefix to get raw name\n    if (key.startsWith(options.attributeNamePrefix)) {\n      const rawName = key.substring(options.attributeNamePrefix.length);\n      rawAttrs[rawName] = attrs[key];\n    } else {\n      // Attribute without prefix (shouldn't normally happen, but be safe)\n      rawAttrs[key] = attrs[key];\n    }\n  }\n  return rawAttrs;\n}\n\n/**\n * Extract namespace from raw tag name\n * @param {string} rawTagName - Tag name possibly with namespace (e.g., \"soap:Envelope\")\n * @returns {string|undefined} Namespace or undefined\n */\nfunction extractNamespace(rawTagName) {\n  if (!rawTagName || typeof rawTagName !== 'string') return undefined;\n\n  const colonIndex = rawTagName.indexOf(':');\n  if (colonIndex !== -1 && colonIndex > 0) {\n    const ns = rawTagName.substring(0, colonIndex);\n    // Don't treat xmlns as a namespace\n    if (ns !== 'xmlns') {\n      return ns;\n    }\n  }\n  return undefined;\n}\n\nexport default class OrderedObjParser {\n  constructor(options) {\n    this.options = options;\n    this.currentNode = null;\n    this.tagsNodeStack = [];\n    this.docTypeEntities = {};\n    this.lastEntities = {\n      \"apos\": { regex: /&(apos|#39|#x27);/g, val: \"'\" },\n      \"gt\": { regex: /&(gt|#62|#x3E);/g, val: \">\" },\n      \"lt\": { regex: /&(lt|#60|#x3C);/g, val: \"<\" },\n      \"quot\": { regex: /&(quot|#34|#x22);/g, val: \"\\\"\" },\n    };\n    this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: \"&\" };\n    this.htmlEntities = {\n      \"space\": { regex: /&(nbsp|#160);/g, val: \" \" },\n      // \"lt\" : { regex: /&(lt|#60);/g, val: \"<\" },\n      // \"gt\" : { regex: /&(gt|#62);/g, val: \">\" },\n      // \"amp\" : { regex: /&(amp|#38);/g, val: \"&\" },\n      // \"quot\" : { regex: /&(quot|#34);/g, val: \"\\\"\" },\n      // \"apos\" : { regex: /&(apos|#39);/g, val: \"'\" },\n      \"cent\": { regex: /&(cent|#162);/g, val: \"¢\" },\n      \"pound\": { regex: /&(pound|#163);/g, val: \"£\" },\n      \"yen\": { regex: /&(yen|#165);/g, val: \"¥\" },\n      \"euro\": { regex: /&(euro|#8364);/g, val: \"€\" },\n      \"copyright\": { regex: /&(copy|#169);/g, val: \"©\" },\n      \"reg\": { regex: /&(reg|#174);/g, val: \"®\" },\n      \"inr\": { regex: /&(inr|#8377);/g, val: \"₹\" },\n      \"num_dec\": { regex: /&#([0-9]{1,7});/g, val: (_, str) => fromCodePoint(str, 10, \"&#\") },\n      \"num_hex\": { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => fromCodePoint(str, 16, \"&#x\") },\n    };\n    this.addExternalEntities = addExternalEntities;\n    this.parseXml = parseXml;\n    this.parseTextData = parseTextData;\n    this.resolveNameSpace = resolveNameSpace;\n    this.buildAttributesMap = buildAttributesMap;\n    this.isItStopNode = isItStopNode;\n    this.replaceEntitiesValue = replaceEntitiesValue;\n    this.readStopNodeData = readStopNodeData;\n    this.saveTextToParentTag = saveTextToParentTag;\n    this.addChild = addChild;\n    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)\n    this.entityExpansionCount = 0;\n    this.currentExpandedLength = 0;\n\n    // Initialize path matcher for path-expression-matcher\n    this.matcher = new Matcher();\n\n    // Flag to track if current node is a stop node (optimization)\n    this.isCurrentNodeStopNode = false;\n\n    // Pre-compile stopNodes expressions\n    if (this.options.stopNodes && this.options.stopNodes.length > 0) {\n      this.stopNodeExpressions = [];\n      for (let i = 0; i < this.options.stopNodes.length; i++) {\n        const stopNodeExp = this.options.stopNodes[i];\n        if (typeof stopNodeExp === 'string') {\n          // Convert string to Expression object\n          this.stopNodeExpressions.push(new Expression(stopNodeExp));\n        } else if (stopNodeExp instanceof Expression) {\n          // Already an Expression object\n          this.stopNodeExpressions.push(stopNodeExp);\n        }\n      }\n    }\n  }\n\n}\n\nfunction addExternalEntities(externalEntities) {\n  const entKeys = Object.keys(externalEntities);\n  for (let i = 0; i < entKeys.length; i++) {\n    const ent = entKeys[i];\n    const escaped = ent.replace(/[.\\-+*:]/g, '\\\\.');\n    this.lastEntities[ent] = {\n      regex: new RegExp(\"&\" + escaped + \";\", \"g\"),\n      val: externalEntities[ent]\n    }\n  }\n}\n\n/**\n * @param {string} val\n * @param {string} tagName\n * @param {string|Matcher} jPath - jPath string or Matcher instance based on options.jPath\n * @param {boolean} dontTrim\n * @param {boolean} hasAttributes\n * @param {boolean} isLeafNode\n * @param {boolean} escapeEntities\n */\nfunction parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {\n  if (val !== undefined) {\n    if (this.options.trimValues && !dontTrim) {\n      val = val.trim();\n    }\n    if (val.length > 0) {\n      if (!escapeEntities) val = this.replaceEntitiesValue(val, tagName, jPath);\n\n      // Pass jPath string or matcher based on options.jPath setting\n      const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;\n      const newval = this.options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);\n      if (newval === null || newval === undefined) {\n        //don't parse\n        return val;\n      } else if (typeof newval !== typeof val || newval !== val) {\n        //overwrite\n        return newval;\n      } else if (this.options.trimValues) {\n        return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);\n      } else {\n        const trimmedVal = val.trim();\n        if (trimmedVal === val) {\n          return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);\n        } else {\n          return val;\n        }\n      }\n    }\n  }\n}\n\nfunction resolveNameSpace(tagname) {\n  if (this.options.removeNSPrefix) {\n    const tags = tagname.split(':');\n    const prefix = tagname.charAt(0) === '/' ? '/' : '';\n    if (tags[0] === 'xmlns') {\n      return '';\n    }\n    if (tags.length === 2) {\n      tagname = prefix + tags[1];\n    }\n  }\n  return tagname;\n}\n\n//TODO: change regex to capture NS\n//const attrsRegx = new RegExp(\"([\\\\w\\\\-\\\\.\\\\:]+)\\\\s*=\\\\s*(['\\\"])((.|\\n)*?)\\\\2\",\"gm\");\nconst attrsRegx = new RegExp('([^\\\\s=]+)\\\\s*(=\\\\s*([\\'\"])([\\\\s\\\\S]*?)\\\\3)?', 'gm');\n\nfunction buildAttributesMap(attrStr, jPath, tagName) {\n  if (this.options.ignoreAttributes !== true && typeof attrStr === 'string') {\n    // attrStr = attrStr.replace(/\\r?\\n/g, ' ');\n    //attrStr = attrStr || attrStr.trim();\n\n    const matches = getAllMatches(attrStr, attrsRegx);\n    const len = matches.length; //don't make it inline\n    const attrs = {};\n\n    // First pass: parse all attributes and update matcher with raw values\n    // This ensures the matcher has all attribute values when processors run\n    const rawAttrsForMatcher = {};\n    for (let i = 0; i < len; i++) {\n      const attrName = this.resolveNameSpace(matches[i][1]);\n      const oldVal = matches[i][4];\n\n      if (attrName.length && oldVal !== undefined) {\n        let parsedVal = oldVal;\n        if (this.options.trimValues) {\n          parsedVal = parsedVal.trim();\n        }\n        parsedVal = this.replaceEntitiesValue(parsedVal, tagName, jPath);\n        rawAttrsForMatcher[attrName] = parsedVal;\n      }\n    }\n\n    // Update matcher with raw attribute values BEFORE running processors\n    if (Object.keys(rawAttrsForMatcher).length > 0 && typeof jPath === 'object' && jPath.updateCurrent) {\n      jPath.updateCurrent(rawAttrsForMatcher);\n    }\n\n    // Second pass: now process attributes with matcher having full attribute context\n    for (let i = 0; i < len; i++) {\n      const attrName = this.resolveNameSpace(matches[i][1]);\n\n      // Convert jPath to string if needed for ignoreAttributesFn\n      const jPathStr = this.options.jPath ? jPath.toString() : jPath;\n      if (this.ignoreAttributesFn(attrName, jPathStr)) {\n        continue\n      }\n\n      let oldVal = matches[i][4];\n      let aName = this.options.attributeNamePrefix + attrName;\n\n      if (attrName.length) {\n        if (this.options.transformAttributeName) {\n          aName = this.options.transformAttributeName(aName);\n        }\n        if (aName === \"__proto__\") aName = \"#__proto__\";\n\n        if (oldVal !== undefined) {\n          if (this.options.trimValues) {\n            oldVal = oldVal.trim();\n          }\n          oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);\n\n          // Pass jPath string or matcher based on options.jPath setting\n          const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;\n          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPathOrMatcher);\n          if (newVal === null || newVal === undefined) {\n            //don't parse\n            attrs[aName] = oldVal;\n          } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {\n            //overwrite\n            attrs[aName] = newVal;\n          } else {\n            //parse\n            attrs[aName] = parseValue(\n              oldVal,\n              this.options.parseAttributeValue,\n              this.options.numberParseOptions\n            );\n          }\n        } else if (this.options.allowBooleanAttributes) {\n          attrs[aName] = true;\n        }\n      }\n    }\n\n    if (!Object.keys(attrs).length) {\n      return;\n    }\n    if (this.options.attributesGroupName) {\n      const attrCollection = {};\n      attrCollection[this.options.attributesGroupName] = attrs;\n      return attrCollection;\n    }\n    return attrs\n  }\n}\n\nconst parseXml = function (xmlData) {\n  xmlData = xmlData.replace(/\\r\\n?/g, \"\\n\"); //TODO: remove this line\n  const xmlObj = new xmlNode('!xml');\n  let currentNode = xmlObj;\n  let textData = \"\";\n\n  // Reset matcher for new document\n  this.matcher.reset();\n\n  // Reset entity expansion counters for this document\n  this.entityExpansionCount = 0;\n  this.currentExpandedLength = 0;\n\n  const docTypeReader = new DocTypeReader(this.options.processEntities);\n  for (let i = 0; i < xmlData.length; i++) {//for each char in XML data\n    const ch = xmlData[i];\n    if (ch === '<') {\n      // const nextIndex = i+1;\n      // const _2ndChar = xmlData[nextIndex];\n      if (xmlData[i + 1] === '/') {//Closing Tag\n        const closeIndex = findClosingIndex(xmlData, \">\", i, \"Closing Tag is not closed.\")\n        let tagName = xmlData.substring(i + 2, closeIndex).trim();\n\n        if (this.options.removeNSPrefix) {\n          const colonIndex = tagName.indexOf(\":\");\n          if (colonIndex !== -1) {\n            tagName = tagName.substr(colonIndex + 1);\n          }\n        }\n\n        if (this.options.transformTagName) {\n          tagName = this.options.transformTagName(tagName);\n        }\n\n        if (currentNode) {\n          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);\n        }\n\n        //check if last tag of nested tag was unpaired tag\n        const lastTagName = this.matcher.getCurrentTag();\n        if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {\n          throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);\n        }\n        if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {\n          // Pop the unpaired tag\n          this.matcher.pop();\n          this.tagsNodeStack.pop();\n        }\n        // Pop the closing tag\n        this.matcher.pop();\n        this.isCurrentNodeStopNode = false; // Reset flag when closing tag\n\n        currentNode = this.tagsNodeStack.pop();//avoid recursion, set the parent tag scope\n        textData = \"\";\n        i = closeIndex;\n      } else if (xmlData[i + 1] === '?') {\n\n        let tagData = readTagExp(xmlData, i, false, \"?>\");\n        if (!tagData) throw new Error(\"Pi Tag is not closed.\");\n\n        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);\n        if ((this.options.ignoreDeclaration && tagData.tagName === \"?xml\") || this.options.ignorePiTags) {\n          //do nothing\n        } else {\n\n          const childNode = new xmlNode(tagData.tagName);\n          childNode.add(this.options.textNodeName, \"\");\n\n          if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {\n            childNode[\":@\"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);\n          }\n          this.addChild(currentNode, childNode, this.matcher, i);\n        }\n\n\n        i = tagData.closeIndex + 1;\n      } else if (xmlData.substr(i + 1, 3) === '!--') {\n        const endIndex = findClosingIndex(xmlData, \"-->\", i + 4, \"Comment is not closed.\")\n        if (this.options.commentPropName) {\n          const comment = xmlData.substring(i + 4, endIndex - 2);\n\n          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);\n\n          currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);\n        }\n        i = endIndex;\n      } else if (xmlData.substr(i + 1, 2) === '!D') {\n        const result = docTypeReader.readDocType(xmlData, i);\n        this.docTypeEntities = result.entities;\n        i = result.i;\n      } else if (xmlData.substr(i + 1, 2) === '![') {\n        const closeIndex = findClosingIndex(xmlData, \"]]>\", i, \"CDATA is not closed.\") - 2;\n        const tagExp = xmlData.substring(i + 9, closeIndex);\n\n        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);\n\n        let val = this.parseTextData(tagExp, currentNode.tagname, this.matcher, true, false, true, true);\n        if (val == undefined) val = \"\";\n\n        //cdata should be set even if it is 0 length string\n        if (this.options.cdataPropName) {\n          currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);\n        } else {\n          currentNode.add(this.options.textNodeName, val);\n        }\n\n        i = closeIndex + 2;\n      } else {//Opening tag\n        let result = readTagExp(xmlData, i, this.options.removeNSPrefix);\n\n        // Safety check: readTagExp can return undefined\n        if (!result) {\n          // Log context for debugging\n          const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlData.length, i + 50));\n          throw new Error(`readTagExp returned undefined at position ${i}. Context: \"${context}\"`);\n        }\n\n        let tagName = result.tagName;\n        const rawTagName = result.rawTagName;\n        let tagExp = result.tagExp;\n        let attrExpPresent = result.attrExpPresent;\n        let closeIndex = result.closeIndex;\n\n        if (this.options.transformTagName) {\n          //console.log(tagExp, tagName)\n          const newTagName = this.options.transformTagName(tagName);\n          if (tagExp === tagName) {\n            tagExp = newTagName\n          }\n          tagName = newTagName;\n        }\n\n        if (this.options.strictReservedNames &&\n          (tagName === this.options.commentPropName\n            || tagName === this.options.cdataPropName\n          )) {\n          throw new Error(`Invalid tag name: ${tagName}`);\n        }\n\n        //save text as child node\n        if (currentNode && textData) {\n          if (currentNode.tagname !== '!xml') {\n            //when nested tag is found\n            textData = this.saveTextToParentTag(textData, currentNode, this.matcher, false);\n          }\n        }\n\n        //check if last tag was unpaired tag\n        const lastTag = currentNode;\n        if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {\n          currentNode = this.tagsNodeStack.pop();\n          this.matcher.pop();\n        }\n\n        // Clean up self-closing syntax BEFORE processing attributes\n        // This is where tagExp gets the trailing / removed\n        let isSelfClosing = false;\n        if (tagExp.length > 0 && tagExp.lastIndexOf(\"/\") === tagExp.length - 1) {\n          isSelfClosing = true;\n          if (tagName[tagName.length - 1] === \"/\") {\n            tagName = tagName.substr(0, tagName.length - 1);\n            tagExp = tagName;\n          } else {\n            tagExp = tagExp.substr(0, tagExp.length - 1);\n          }\n\n          // Re-check attrExpPresent after cleaning\n          attrExpPresent = (tagName !== tagExp);\n        }\n\n        // Now process attributes with CLEAN tagExp (no trailing /)\n        let prefixedAttrs = null;\n        let rawAttrs = {};\n        let namespace = undefined;\n\n        // Extract namespace from rawTagName\n        namespace = extractNamespace(rawTagName);\n\n        // Push tag to matcher FIRST (with empty attrs for now) so callbacks see correct path\n        if (tagName !== xmlObj.tagname) {\n          this.matcher.push(tagName, {}, namespace);\n        }\n\n        // Now build attributes - callbacks will see correct matcher state\n        if (tagName !== tagExp && attrExpPresent) {\n          // Build attributes (returns prefixed attributes for the tree)\n          // Note: buildAttributesMap now internally updates the matcher with raw attributes\n          prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);\n\n          if (prefixedAttrs) {\n            // Extract raw attributes (without prefix) for our use\n            rawAttrs = extractRawAttributes(prefixedAttrs, this.options);\n          }\n        }\n\n        // Now check if this is a stop node (after attributes are set)\n        if (tagName !== xmlObj.tagname) {\n          this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher);\n        }\n\n        const startIndex = i;\n        if (this.isCurrentNodeStopNode) {\n          let tagContent = \"\";\n\n          // For self-closing tags, content is empty\n          if (isSelfClosing) {\n            i = result.closeIndex;\n          }\n          //unpaired tag\n          else if (this.options.unpairedTags.indexOf(tagName) !== -1) {\n            i = result.closeIndex;\n          }\n          //normal tag\n          else {\n            //read until closing tag is found\n            const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);\n            if (!result) throw new Error(`Unexpected end of ${rawTagName}`);\n            i = result.i;\n            tagContent = result.tagContent;\n          }\n\n          const childNode = new xmlNode(tagName);\n\n          if (prefixedAttrs) {\n            childNode[\":@\"] = prefixedAttrs;\n          }\n\n          // For stop nodes, store raw content as-is without any processing\n          childNode.add(this.options.textNodeName, tagContent);\n\n          this.matcher.pop(); // Pop the stop node tag\n          this.isCurrentNodeStopNode = false; // Reset flag\n\n          this.addChild(currentNode, childNode, this.matcher, startIndex);\n        } else {\n          //selfClosing tag\n          if (isSelfClosing) {\n            if (this.options.transformTagName) {\n              const newTagName = this.options.transformTagName(tagName);\n              if (tagExp === tagName) {\n                tagExp = newTagName\n              }\n              tagName = newTagName;\n            }\n\n            const childNode = new xmlNode(tagName);\n            if (prefixedAttrs) {\n              childNode[\":@\"] = prefixedAttrs;\n            }\n            this.addChild(currentNode, childNode, this.matcher, startIndex);\n            this.matcher.pop(); // Pop self-closing tag\n            this.isCurrentNodeStopNode = false; // Reset flag\n          }\n          else if (this.options.unpairedTags.indexOf(tagName) !== -1) {//unpaired tag\n            const childNode = new xmlNode(tagName);\n            if (prefixedAttrs) {\n              childNode[\":@\"] = prefixedAttrs;\n            }\n            this.addChild(currentNode, childNode, this.matcher, startIndex);\n            this.matcher.pop(); // Pop unpaired tag\n            this.isCurrentNodeStopNode = false; // Reset flag\n            i = result.closeIndex;\n            // Continue to next iteration without changing currentNode\n            continue;\n          }\n          //opening tag\n          else {\n            const childNode = new xmlNode(tagName);\n            if (this.tagsNodeStack.length > this.options.maxNestedTags) {\n              throw new Error(\"Maximum nested tags exceeded\");\n            }\n            this.tagsNodeStack.push(currentNode);\n\n            if (prefixedAttrs) {\n              childNode[\":@\"] = prefixedAttrs;\n            }\n            this.addChild(currentNode, childNode, this.matcher, startIndex);\n            currentNode = childNode;\n          }\n          textData = \"\";\n          i = closeIndex;\n        }\n      }\n    } else {\n      textData += xmlData[i];\n    }\n  }\n  return xmlObj.child;\n}\n\nfunction addChild(currentNode, childNode, matcher, startIndex) {\n  // unset startIndex if not requested\n  if (!this.options.captureMetaData) startIndex = undefined;\n\n  // Pass jPath string or matcher based on options.jPath setting\n  const jPathOrMatcher = this.options.jPath ? matcher.toString() : matcher;\n  const result = this.options.updateTag(childNode.tagname, jPathOrMatcher, childNode[\":@\"])\n  if (result === false) {\n    //do nothing\n  } else if (typeof result === \"string\") {\n    childNode.tagname = result\n    currentNode.addChild(childNode, startIndex);\n  } else {\n    currentNode.addChild(childNode, startIndex);\n  }\n}\n\n/**\n * @param {object} val - Entity object with regex and val properties\n * @param {string} tagName - Tag name\n * @param {string|Matcher} jPath - jPath string or Matcher instance based on options.jPath\n */\nfunction replaceEntitiesValue(val, tagName, jPath) {\n  const entityConfig = this.options.processEntities;\n\n  if (!entityConfig || !entityConfig.enabled) {\n    return val;\n  }\n\n  // Check if tag is allowed to contain entities\n  if (entityConfig.allowedTags) {\n    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;\n    const allowed = Array.isArray(entityConfig.allowedTags)\n      ? entityConfig.allowedTags.includes(tagName)\n      : entityConfig.allowedTags(tagName, jPathOrMatcher);\n\n    if (!allowed) {\n      return val;\n    }\n  }\n\n  // Apply custom tag filter if provided\n  if (entityConfig.tagFilter) {\n    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;\n    if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) {\n      return val; // Skip based on custom filter\n    }\n  }\n\n  // Replace DOCTYPE entities\n  for (let entityName in this.docTypeEntities) {\n    const entity = this.docTypeEntities[entityName];\n    const matches = val.match(entity.regx);\n\n    if (matches) {\n      // Track expansions\n      this.entityExpansionCount += matches.length;\n\n      // Check expansion limit\n      if (entityConfig.maxTotalExpansions &&\n        this.entityExpansionCount > entityConfig.maxTotalExpansions) {\n        throw new Error(\n          `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`\n        );\n      }\n\n      // Store length before replacement\n      const lengthBefore = val.length;\n      val = val.replace(entity.regx, entity.val);\n\n      // Check expanded length immediately after replacement\n      if (entityConfig.maxExpandedLength) {\n        this.currentExpandedLength += (val.length - lengthBefore);\n\n        if (this.currentExpandedLength > entityConfig.maxExpandedLength) {\n          throw new Error(\n            `Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`\n          );\n        }\n      }\n    }\n  }\n  if (val.indexOf('&') === -1) return val;  // Early exit\n\n  // Replace standard entities\n  for (let entityName in this.lastEntities) {\n    const entity = this.lastEntities[entityName];\n    val = val.replace(entity.regex, entity.val);\n  }\n  if (val.indexOf('&') === -1) return val;  // Early exit\n\n  // Replace HTML entities if enabled\n  if (this.options.htmlEntities) {\n    for (let entityName in this.htmlEntities) {\n      const entity = this.htmlEntities[entityName];\n      val = val.replace(entity.regex, entity.val);\n    }\n  }\n\n  // Replace ampersand entity last\n  val = val.replace(this.ampEntity.regex, this.ampEntity.val);\n\n  return val;\n}\n\n\nfunction saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {\n  if (textData) { //store previously collected data as textNode\n    if (isLeafNode === undefined) isLeafNode = parentNode.child.length === 0\n\n    textData = this.parseTextData(textData,\n      parentNode.tagname,\n      matcher,\n      false,\n      parentNode[\":@\"] ? Object.keys(parentNode[\":@\"]).length !== 0 : false,\n      isLeafNode);\n\n    if (textData !== undefined && textData !== \"\")\n      parentNode.add(this.options.textNodeName, textData);\n    textData = \"\";\n  }\n  return textData;\n}\n\n//TODO: use jPath to simplify the logic\n/**\n * @param {Array<Expression>} stopNodeExpressions - Array of compiled Expression objects\n * @param {Matcher} matcher - Current path matcher\n */\nfunction isItStopNode(stopNodeExpressions, matcher) {\n  if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;\n\n  for (let i = 0; i < stopNodeExpressions.length; i++) {\n    if (matcher.matches(stopNodeExpressions[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Returns the tag Expression and where it is ending handling single-double quotes situation\n * @param {string} xmlData \n * @param {number} i starting index\n * @returns \n */\nfunction tagExpWithClosingIndex(xmlData, i, closingChar = \">\") {\n  let attrBoundary;\n  let tagExp = \"\";\n  for (let index = i; index < xmlData.length; index++) {\n    let ch = xmlData[index];\n    if (attrBoundary) {\n      if (ch === attrBoundary) attrBoundary = \"\";//reset\n    } else if (ch === '\"' || ch === \"'\") {\n      attrBoundary = ch;\n    } else if (ch === closingChar[0]) {\n      if (closingChar[1]) {\n        if (xmlData[index + 1] === closingChar[1]) {\n          return {\n            data: tagExp,\n            index: index\n          }\n        }\n      } else {\n        return {\n          data: tagExp,\n          index: index\n        }\n      }\n    } else if (ch === '\\t') {\n      ch = \" \"\n    }\n    tagExp += ch;\n  }\n}\n\nfunction findClosingIndex(xmlData, str, i, errMsg) {\n  const closingIndex = xmlData.indexOf(str, i);\n  if (closingIndex === -1) {\n    throw new Error(errMsg)\n  } else {\n    return closingIndex + str.length - 1;\n  }\n}\n\nfunction readTagExp(xmlData, i, removeNSPrefix, closingChar = \">\") {\n  const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);\n  if (!result) return;\n  let tagExp = result.data;\n  const closeIndex = result.index;\n  const separatorIndex = tagExp.search(/\\s/);\n  let tagName = tagExp;\n  let attrExpPresent = true;\n  if (separatorIndex !== -1) {//separate tag name and attributes expression\n    tagName = tagExp.substring(0, separatorIndex);\n    tagExp = tagExp.substring(separatorIndex + 1).trimStart();\n  }\n\n  const rawTagName = tagName;\n  if (removeNSPrefix) {\n    const colonIndex = tagName.indexOf(\":\");\n    if (colonIndex !== -1) {\n      tagName = tagName.substr(colonIndex + 1);\n      attrExpPresent = tagName !== result.data.substr(colonIndex + 1);\n    }\n  }\n\n  return {\n    tagName: tagName,\n    tagExp: tagExp,\n    closeIndex: closeIndex,\n    attrExpPresent: attrExpPresent,\n    rawTagName: rawTagName,\n  }\n}\n/**\n * find paired tag for a stop node\n * @param {string} xmlData \n * @param {string} tagName \n * @param {number} i \n */\nfunction readStopNodeData(xmlData, tagName, i) {\n  const startIndex = i;\n  // Starting at 1 since we already have an open tag\n  let openTagCount = 1;\n\n  for (; i < xmlData.length; i++) {\n    if (xmlData[i] === \"<\") {\n      if (xmlData[i + 1] === \"/\") {//close tag\n        const closeIndex = findClosingIndex(xmlData, \">\", i, `${tagName} is not closed`);\n        let closeTagName = xmlData.substring(i + 2, closeIndex).trim();\n        if (closeTagName === tagName) {\n          openTagCount--;\n          if (openTagCount === 0) {\n            return {\n              tagContent: xmlData.substring(startIndex, i),\n              i: closeIndex\n            }\n          }\n        }\n        i = closeIndex;\n      } else if (xmlData[i + 1] === '?') {\n        const closeIndex = findClosingIndex(xmlData, \"?>\", i + 1, \"StopNode is not closed.\")\n        i = closeIndex;\n      } else if (xmlData.substr(i + 1, 3) === '!--') {\n        const closeIndex = findClosingIndex(xmlData, \"-->\", i + 3, \"StopNode is not closed.\")\n        i = closeIndex;\n      } else if (xmlData.substr(i + 1, 2) === '![') {\n        const closeIndex = findClosingIndex(xmlData, \"]]>\", i, \"StopNode is not closed.\") - 2;\n        i = closeIndex;\n      } else {\n        const tagData = readTagExp(xmlData, i, '>')\n\n        if (tagData) {\n          const openTagName = tagData && tagData.tagName;\n          if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== \"/\") {\n            openTagCount++;\n          }\n          i = tagData.closeIndex;\n        }\n      }\n    }\n  }//end for loop\n}\n\nfunction parseValue(val, shouldParse, options) {\n  if (shouldParse && typeof val === 'string') {\n    //console.log(options)\n    const newval = val.trim();\n    if (newval === 'true') return true;\n    else if (newval === 'false') return false;\n    else return toNumber(val, options);\n  } else {\n    if (isExist(val)) {\n      return val;\n    } else {\n      return '';\n    }\n  }\n}\n\nfunction fromCodePoint(str, base, prefix) {\n  const codePoint = Number.parseInt(str, base);\n\n  if (codePoint >= 0 && codePoint <= 0x10FFFF) {\n    return String.fromCodePoint(codePoint);\n  } else {\n    return prefix + str + \";\";\n  }\n}","export default function getIgnoreAttributesFn(ignoreAttributes) {\n    if (typeof ignoreAttributes === 'function') {\n        return ignoreAttributes\n    }\n    if (Array.isArray(ignoreAttributes)) {\n        return (attrName) => {\n            for (const pattern of ignoreAttributes) {\n                if (typeof pattern === 'string' && attrName === pattern) {\n                    return true\n                }\n                if (pattern instanceof RegExp && pattern.test(attrName)) {\n                    return true\n                }\n            }\n        }\n    }\n    return () => false\n}","'use strict';\n\nimport XmlNode from './xmlNode.js';\nimport { Matcher } from 'path-expression-matcher';\n\nconst METADATA_SYMBOL = XmlNode.getMetaDataSymbol();\n\n/**\n * Helper function to strip attribute prefix from attribute map\n * @param {object} attrs - Attributes with prefix (e.g., {\"@_class\": \"code\"})\n * @param {string} prefix - Attribute prefix to remove (e.g., \"@_\")\n * @returns {object} Attributes without prefix (e.g., {\"class\": \"code\"})\n */\nfunction stripAttributePrefix(attrs, prefix) {\n  if (!attrs || typeof attrs !== 'object') return {};\n  if (!prefix) return attrs;\n\n  const rawAttrs = {};\n  for (const key in attrs) {\n    if (key.startsWith(prefix)) {\n      const rawName = key.substring(prefix.length);\n      rawAttrs[rawName] = attrs[key];\n    } else {\n      // Attribute without prefix (shouldn't normally happen, but be safe)\n      rawAttrs[key] = attrs[key];\n    }\n  }\n  return rawAttrs;\n}\n\n/**\n * \n * @param {array} node \n * @param {any} options \n * @param {Matcher} matcher - Path matcher instance\n * @returns \n */\nexport default function prettify(node, options, matcher) {\n  return compress(node, options, matcher);\n}\n\n/**\n * \n * @param {array} arr \n * @param {object} options \n * @param {Matcher} matcher - Path matcher instance\n * @returns object\n */\nfunction compress(arr, options, matcher) {\n  let text;\n  const compressedObj = {}; //This is intended to be a plain object\n  for (let i = 0; i < arr.length; i++) {\n    const tagObj = arr[i];\n    const property = propName(tagObj);\n\n    // Push current property to matcher WITH RAW ATTRIBUTES (no prefix)\n    if (property !== undefined && property !== options.textNodeName) {\n      const rawAttrs = stripAttributePrefix(\n        tagObj[\":@\"] || {},\n        options.attributeNamePrefix\n      );\n      matcher.push(property, rawAttrs);\n    }\n\n    if (property === options.textNodeName) {\n      if (text === undefined) text = tagObj[property];\n      else text += \"\" + tagObj[property];\n    } else if (property === undefined) {\n      continue;\n    } else if (tagObj[property]) {\n\n      let val = compress(tagObj[property], options, matcher);\n      const isLeaf = isLeafTag(val, options);\n\n      if (tagObj[\":@\"]) {\n        assignAttributes(val, tagObj[\":@\"], matcher, options);\n      } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {\n        val = val[options.textNodeName];\n      } else if (Object.keys(val).length === 0) {\n        if (options.alwaysCreateTextNode) val[options.textNodeName] = \"\";\n        else val = \"\";\n      }\n\n      if (tagObj[METADATA_SYMBOL] !== undefined && typeof val === \"object\" && val !== null) {\n        val[METADATA_SYMBOL] = tagObj[METADATA_SYMBOL]; // copy over metadata\n      }\n\n\n      if (compressedObj[property] !== undefined && Object.prototype.hasOwnProperty.call(compressedObj, property)) {\n        if (!Array.isArray(compressedObj[property])) {\n          compressedObj[property] = [compressedObj[property]];\n        }\n        compressedObj[property].push(val);\n      } else {\n        //TODO: if a node is not an array, then check if it should be an array\n        //also determine if it is a leaf node\n\n        // Pass jPath string or matcher based on options.jPath setting\n        const jPathOrMatcher = options.jPath ? matcher.toString() : matcher;\n        if (options.isArray(property, jPathOrMatcher, isLeaf)) {\n          compressedObj[property] = [val];\n        } else {\n          compressedObj[property] = val;\n        }\n      }\n\n      // Pop property from matcher after processing\n      if (property !== undefined && property !== options.textNodeName) {\n        matcher.pop();\n      }\n    }\n\n  }\n  // if(text && text.length > 0) compressedObj[options.textNodeName] = text;\n  if (typeof text === \"string\") {\n    if (text.length > 0) compressedObj[options.textNodeName] = text;\n  } else if (text !== undefined) compressedObj[options.textNodeName] = text;\n\n\n  return compressedObj;\n}\n\nfunction propName(obj) {\n  const keys = Object.keys(obj);\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n    if (key !== \":@\") return key;\n  }\n}\n\nfunction assignAttributes(obj, attrMap, matcher, options) {\n  if (attrMap) {\n    const keys = Object.keys(attrMap);\n    const len = keys.length; //don't make it inline\n    for (let i = 0; i < len; i++) {\n      const atrrName = keys[i];  // This is the PREFIXED name (e.g., \"@_class\")\n\n      // Strip prefix for matcher path (for isArray callback)\n      const rawAttrName = atrrName.startsWith(options.attributeNamePrefix)\n        ? atrrName.substring(options.attributeNamePrefix.length)\n        : atrrName;\n\n      // For attributes, we need to create a temporary path\n      // Pass jPath string or matcher based on options.jPath setting\n      const jPathOrMatcher = options.jPath\n        ? matcher.toString() + \".\" + rawAttrName\n        : matcher;\n\n      if (options.isArray(atrrName, jPathOrMatcher, true, true)) {\n        obj[atrrName] = [attrMap[atrrName]];\n      } else {\n        obj[atrrName] = attrMap[atrrName];\n      }\n    }\n  }\n}\n\nfunction isLeafTag(obj, options) {\n  const { textNodeName } = options;\n  const propCount = Object.keys(obj).length;\n\n  if (propCount === 0) {\n    return true;\n  }\n\n  if (\n    propCount === 1 &&\n    (obj[textNodeName] || typeof obj[textNodeName] === \"boolean\" || obj[textNodeName] === 0)\n  ) {\n    return true;\n  }\n\n  return false;\n}","import { buildOptions } from './OptionsBuilder.js';\nimport OrderedObjParser from './OrderedObjParser.js';\nimport prettify from './node2json.js';\nimport { validate } from \"../validator.js\";\nimport XmlNode from './xmlNode.js';\n\nexport default class XMLParser {\n\n    constructor(options) {\n        this.externalEntities = {};\n        this.options = buildOptions(options);\n\n    }\n    /**\n     * Parse XML dats to JS object \n     * @param {string|Uint8Array} xmlData \n     * @param {boolean|Object} validationOption \n     */\n    parse(xmlData, validationOption) {\n        if (typeof xmlData !== \"string\" && xmlData.toString) {\n            xmlData = xmlData.toString();\n        } else if (typeof xmlData !== \"string\") {\n            throw new Error(\"XML data is accepted in String or Bytes[] form.\")\n        }\n\n        if (validationOption) {\n            if (validationOption === true) validationOption = {}; //validate with default options\n\n            const result = validate(xmlData, validationOption);\n            if (result !== true) {\n                throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`)\n            }\n        }\n        const orderedObjParser = new OrderedObjParser(this.options);\n        orderedObjParser.addExternalEntities(this.externalEntities);\n        const orderedResult = orderedObjParser.parseXml(xmlData);\n        if (this.options.preserveOrder || orderedResult === undefined) return orderedResult;\n        else return prettify(orderedResult, this.options, orderedObjParser.matcher);\n    }\n\n    /**\n     * Add Entity which is not by default supported by this library\n     * @param {string} key \n     * @param {string} value \n     */\n    addEntity(key, value) {\n        if (value.indexOf(\"&\") !== -1) {\n            throw new Error(\"Entity value can't have '&'\")\n        } else if (key.indexOf(\"&\") !== -1 || key.indexOf(\";\") !== -1) {\n            throw new Error(\"An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'\")\n        } else if (value === \"&\") {\n            throw new Error(\"An entity with value '&' is not permitted\");\n        } else {\n            this.externalEntities[key] = value;\n        }\n    }\n\n    /**\n     * Returns a Symbol that can be used to access the metadata\n     * property on a node.\n     * \n     * If Symbol is not available in the environment, an ordinary property is used\n     * and the name of the property is here returned.\n     * \n     * The XMLMetaData property is only present when `captureMetaData`\n     * is true in the options.\n     */\n    static getMetaDataSymbol() {\n        return XmlNode.getMetaDataSymbol();\n    }\n}\n","import { Expression, Matcher } from 'path-expression-matcher';\n\nconst EOL = \"\\n\";\n\n/**\n * \n * @param {array} jArray \n * @param {any} options \n * @returns \n */\nexport default function toXml(jArray, options) {\n    let indentation = \"\";\n    if (options.format && options.indentBy.length > 0) {\n        indentation = EOL;\n    }\n\n    // Pre-compile stopNode expressions for pattern matching\n    const stopNodeExpressions = [];\n    if (options.stopNodes && Array.isArray(options.stopNodes)) {\n        for (let i = 0; i < options.stopNodes.length; i++) {\n            const node = options.stopNodes[i];\n            if (typeof node === 'string') {\n                stopNodeExpressions.push(new Expression(node));\n            } else if (node instanceof Expression) {\n                stopNodeExpressions.push(node);\n            }\n        }\n    }\n\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n\n    return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions);\n}\n\nfunction arrToStr(arr, options, indentation, matcher, stopNodeExpressions) {\n    let xmlStr = \"\";\n    let isPreviousElementTag = false;\n\n\n    if (!Array.isArray(arr)) {\n        // Non-array values (e.g. string tag values) should be treated as text content\n        if (arr !== undefined && arr !== null) {\n            let text = arr.toString();\n            text = replaceEntitiesValue(text, options);\n            return text;\n        }\n        return \"\";\n    }\n\n    for (let i = 0; i < arr.length; i++) {\n        const tagObj = arr[i];\n        const tagName = propName(tagObj);\n        if (tagName === undefined) continue;\n\n        // Extract attributes from \":@\" property\n        const attrValues = extractAttributeValues(tagObj[\":@\"], options);\n\n        // Push tag to matcher WITH attributes\n        matcher.push(tagName, attrValues);\n\n        // Check if this is a stop node using Expression matching\n        const isStopNode = checkStopNode(matcher, stopNodeExpressions);\n\n        if (tagName === options.textNodeName) {\n            let tagText = tagObj[tagName];\n            if (!isStopNode) {\n                tagText = options.tagValueProcessor(tagName, tagText);\n                tagText = replaceEntitiesValue(tagText, options);\n            }\n            if (isPreviousElementTag) {\n                xmlStr += indentation;\n            }\n            xmlStr += tagText;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.cdataPropName) {\n            if (isPreviousElementTag) {\n                xmlStr += indentation;\n            }\n            xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.commentPropName) {\n            xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        } else if (tagName[0] === \"?\") {\n            const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode);\n            const tempInd = tagName === \"?xml\" ? \"\" : indentation;\n            let piTextNodeName = tagObj[tagName][0][options.textNodeName];\n            piTextNodeName = piTextNodeName.length !== 0 ? \" \" + piTextNodeName : \"\"; //remove extra spacing\n            xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr}?>`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        }\n\n        let newIdentation = indentation;\n        if (newIdentation !== \"\") {\n            newIdentation += options.indentBy;\n        }\n\n        // Pass isStopNode to attr_to_str so attributes are also not processed for stopNodes\n        const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode);\n        const tagStart = indentation + `<${tagName}${attStr}`;\n\n        // If this is a stopNode, get raw content without processing\n        let tagValue;\n        if (isStopNode) {\n            tagValue = getRawContent(tagObj[tagName], options);\n        } else {\n            tagValue = arrToStr(tagObj[tagName], options, newIdentation, matcher, stopNodeExpressions);\n        }\n\n        if (options.unpairedTags.indexOf(tagName) !== -1) {\n            if (options.suppressUnpairedNode) xmlStr += tagStart + \">\";\n            else xmlStr += tagStart + \"/>\";\n        } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {\n            xmlStr += tagStart + \"/>\";\n        } else if (tagValue && tagValue.endsWith(\">\")) {\n            xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;\n        } else {\n            xmlStr += tagStart + \">\";\n            if (tagValue && indentation !== \"\" && (tagValue.includes(\"/>\") || tagValue.includes(\"</\"))) {\n                xmlStr += indentation + options.indentBy + tagValue + indentation;\n            } else {\n                xmlStr += tagValue;\n            }\n            xmlStr += `</${tagName}>`;\n        }\n        isPreviousElementTag = true;\n\n        // Pop tag from matcher\n        matcher.pop();\n    }\n\n    return xmlStr;\n}\n\n/**\n * Extract attribute values from the \":@\" object and return as plain object\n * for passing to matcher.push()\n */\nfunction extractAttributeValues(attrMap, options) {\n    if (!attrMap || options.ignoreAttributes) return null;\n\n    const attrValues = {};\n    let hasAttrs = false;\n\n    for (let attr in attrMap) {\n        if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n        // Remove the attribute prefix to get clean attribute name\n        const cleanAttrName = attr.startsWith(options.attributeNamePrefix)\n            ? attr.substr(options.attributeNamePrefix.length)\n            : attr;\n        attrValues[cleanAttrName] = attrMap[attr];\n        hasAttrs = true;\n    }\n\n    return hasAttrs ? attrValues : null;\n}\n\n/**\n * Extract raw content from a stopNode without any processing\n * This preserves the content exactly as-is, including special characters\n */\nfunction getRawContent(arr, options) {\n    if (!Array.isArray(arr)) {\n        // Non-array values return as-is\n        if (arr !== undefined && arr !== null) {\n            return arr.toString();\n        }\n        return \"\";\n    }\n\n    let content = \"\";\n    for (let i = 0; i < arr.length; i++) {\n        const item = arr[i];\n        const tagName = propName(item);\n\n        if (tagName === options.textNodeName) {\n            // Raw text content - NO processing, NO entity replacement\n            content += item[tagName];\n        } else if (tagName === options.cdataPropName) {\n            // CDATA content\n            content += item[tagName][0][options.textNodeName];\n        } else if (tagName === options.commentPropName) {\n            // Comment content\n            content += item[tagName][0][options.textNodeName];\n        } else if (tagName && tagName[0] === \"?\") {\n            // Processing instruction - skip for stopNodes\n            continue;\n        } else if (tagName) {\n            // Nested tags within stopNode\n            // Recursively get raw content and reconstruct the tag\n            // For stopNodes, we don't process attributes either\n            const attStr = attr_to_str_raw(item[\":@\"], options);\n            const nestedContent = getRawContent(item[tagName], options);\n\n            if (!nestedContent || nestedContent.length === 0) {\n                content += `<${tagName}${attStr}/>`;\n            } else {\n                content += `<${tagName}${attStr}>${nestedContent}</${tagName}>`;\n            }\n        }\n    }\n    return content;\n}\n\n/**\n * Build attribute string for stopNodes - NO entity replacement\n */\nfunction attr_to_str_raw(attrMap, options) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n            // For stopNodes, use raw value without processing\n            let attrVal = attrMap[attr];\n            if (attrVal === true && options.suppressBooleanAttributes) {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;\n            } else {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}=\"${attrVal}\"`;\n            }\n        }\n    }\n    return attrStr;\n}\n\nfunction propName(obj) {\n    const keys = Object.keys(obj);\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n        if (key !== \":@\") return key;\n    }\n}\n\nfunction attr_to_str(attrMap, options, isStopNode) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n            let attrVal;\n\n            if (isStopNode) {\n                // For stopNodes, use raw value without any processing\n                attrVal = attrMap[attr];\n            } else {\n                // Normal processing: apply attributeValueProcessor and entity replacement\n                attrVal = options.attributeValueProcessor(attr, attrMap[attr]);\n                attrVal = replaceEntitiesValue(attrVal, options);\n            }\n\n            if (attrVal === true && options.suppressBooleanAttributes) {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;\n            } else {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}=\"${attrVal}\"`;\n            }\n        }\n    }\n    return attrStr;\n}\n\nfunction checkStopNode(matcher, stopNodeExpressions) {\n    if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;\n\n    for (let i = 0; i < stopNodeExpressions.length; i++) {\n        if (matcher.matches(stopNodeExpressions[i])) {\n            return true;\n        }\n    }\n    return false;\n}\n\nfunction replaceEntitiesValue(textValue, options) {\n    if (textValue && textValue.length > 0 && options.processEntities) {\n        for (let i = 0; i < options.entities.length; i++) {\n            const entity = options.entities[i];\n            textValue = textValue.replace(entity.regex, entity.val);\n        }\n    }\n    return textValue;\n}","'use strict';\n//parse Empty Node as self closing node\nimport buildFromOrderedJs from './orderedJs2Xml.js';\nimport getIgnoreAttributesFn from \"./ignoreAttributes.js\";\nimport { Expression, Matcher } from 'path-expression-matcher';\n\nconst defaultOptions = {\n  attributeNamePrefix: '@_',\n  attributesGroupName: false,\n  textNodeName: '#text',\n  ignoreAttributes: true,\n  cdataPropName: false,\n  format: false,\n  indentBy: '  ',\n  suppressEmptyNode: false,\n  suppressUnpairedNode: true,\n  suppressBooleanAttributes: true,\n  tagValueProcessor: function (key, a) {\n    return a;\n  },\n  attributeValueProcessor: function (attrName, a) {\n    return a;\n  },\n  preserveOrder: false,\n  commentPropName: false,\n  unpairedTags: [],\n  entities: [\n    { regex: new RegExp(\"&\", \"g\"), val: \"&amp;\" },//it must be on top\n    { regex: new RegExp(\">\", \"g\"), val: \"&gt;\" },\n    { regex: new RegExp(\"<\", \"g\"), val: \"&lt;\" },\n    { regex: new RegExp(\"\\'\", \"g\"), val: \"&apos;\" },\n    { regex: new RegExp(\"\\\"\", \"g\"), val: \"&quot;\" }\n  ],\n  processEntities: true,\n  stopNodes: [],\n  // transformTagName: false,\n  // transformAttributeName: false,\n  oneListGroup: false,\n  jPath: true  // When true, callbacks receive string jPath; when false, receive Matcher instance\n};\n\nexport default function Builder(options) {\n  this.options = Object.assign({}, defaultOptions, options);\n\n  // Convert old-style stopNodes for backward compatibility\n  // Old syntax: \"*.tag\" meant \"tag anywhere in tree\"\n  // New syntax: \"..tag\" means \"tag anywhere in tree\"\n  if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) {\n    this.options.stopNodes = this.options.stopNodes.map(node => {\n      if (typeof node === 'string' && node.startsWith('*.')) {\n        // Convert old wildcard syntax to deep wildcard\n        return '..' + node.substring(2);\n      }\n      return node;\n    });\n  }\n\n  // Pre-compile stopNode expressions for pattern matching\n  this.stopNodeExpressions = [];\n  if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) {\n    for (let i = 0; i < this.options.stopNodes.length; i++) {\n      const node = this.options.stopNodes[i];\n      if (typeof node === 'string') {\n        this.stopNodeExpressions.push(new Expression(node));\n      } else if (node instanceof Expression) {\n        this.stopNodeExpressions.push(node);\n      }\n    }\n  }\n\n  if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {\n    this.isAttribute = function (/*a*/) {\n      return false;\n    };\n  } else {\n    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)\n    this.attrPrefixLen = this.options.attributeNamePrefix.length;\n    this.isAttribute = isAttribute;\n  }\n\n  this.processTextOrObjNode = processTextOrObjNode\n\n  if (this.options.format) {\n    this.indentate = indentate;\n    this.tagEndChar = '>\\n';\n    this.newLine = '\\n';\n  } else {\n    this.indentate = function () {\n      return '';\n    };\n    this.tagEndChar = '>';\n    this.newLine = '';\n  }\n}\n\nBuilder.prototype.build = function (jObj) {\n  if (this.options.preserveOrder) {\n    return buildFromOrderedJs(jObj, this.options);\n  } else {\n    if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {\n      jObj = {\n        [this.options.arrayNodeName]: jObj\n      }\n    }\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n    return this.j2x(jObj, 0, matcher).val;\n  }\n};\n\nBuilder.prototype.j2x = function (jObj, level, matcher) {\n  let attrStr = '';\n  let val = '';\n\n  // Get jPath based on option: string for backward compatibility, or Matcher for new features\n  const jPath = this.options.jPath ? matcher.toString() : matcher;\n\n  // Check if current node is a stopNode (will be used for attribute encoding)\n  const isCurrentStopNode = this.checkStopNode(matcher);\n\n  for (let key in jObj) {\n    if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;\n    if (typeof jObj[key] === 'undefined') {\n      // supress undefined node only if it is not an attribute\n      if (this.isAttribute(key)) {\n        val += '';\n      }\n    } else if (jObj[key] === null) {\n      // null attribute should be ignored by the attribute list, but should not cause the tag closing\n      if (this.isAttribute(key)) {\n        val += '';\n      } else if (key === this.options.cdataPropName) {\n        val += '';\n      } else if (key[0] === '?') {\n        val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;\n      } else {\n        val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n      }\n      // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n    } else if (jObj[key] instanceof Date) {\n      val += this.buildTextValNode(jObj[key], key, '', level, matcher);\n    } else if (typeof jObj[key] !== 'object') {\n      //premitive type\n      const attr = this.isAttribute(key);\n      if (attr && !this.ignoreAttributesFn(attr, jPath)) {\n        attrStr += this.buildAttrPairStr(attr, '' + jObj[key], isCurrentStopNode);\n      } else if (!attr) {\n        //tag value\n        if (key === this.options.textNodeName) {\n          let newval = this.options.tagValueProcessor(key, '' + jObj[key]);\n          val += this.replaceEntitiesValue(newval);\n        } else {\n          // Check if this is a stopNode before building\n          matcher.push(key);\n          const isStopNode = this.checkStopNode(matcher);\n          matcher.pop();\n\n          if (isStopNode) {\n            // Build as raw content without encoding\n            const textValue = '' + jObj[key];\n            if (textValue === '') {\n              val += this.indentate(level) + '<' + key + this.closeTag(key) + this.tagEndChar;\n            } else {\n              val += this.indentate(level) + '<' + key + '>' + textValue + '</' + key + this.tagEndChar;\n            }\n          } else {\n            val += this.buildTextValNode(jObj[key], key, '', level, matcher);\n          }\n        }\n      }\n    } else if (Array.isArray(jObj[key])) {\n      //repeated nodes\n      const arrLen = jObj[key].length;\n      let listTagVal = \"\";\n      let listTagAttr = \"\";\n      for (let j = 0; j < arrLen; j++) {\n        const item = jObj[key][j];\n        if (typeof item === 'undefined') {\n          // supress undefined node\n        } else if (item === null) {\n          if (key[0] === \"?\") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;\n          else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n          // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n        } else if (typeof item === 'object') {\n          if (this.options.oneListGroup) {\n            // Push tag to matcher before recursive call\n            matcher.push(key);\n            const result = this.j2x(item, level + 1, matcher);\n            // Pop tag from matcher after recursive call\n            matcher.pop();\n\n            listTagVal += result.val;\n            if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {\n              listTagAttr += result.attrStr\n            }\n          } else {\n            listTagVal += this.processTextOrObjNode(item, key, level, matcher)\n          }\n        } else {\n          if (this.options.oneListGroup) {\n            let textValue = this.options.tagValueProcessor(key, item);\n            textValue = this.replaceEntitiesValue(textValue);\n            listTagVal += textValue;\n          } else {\n            // Check if this is a stopNode before building\n            matcher.push(key);\n            const isStopNode = this.checkStopNode(matcher);\n            matcher.pop();\n\n            if (isStopNode) {\n              // Build as raw content without encoding\n              const textValue = '' + item;\n              if (textValue === '') {\n                listTagVal += this.indentate(level) + '<' + key + this.closeTag(key) + this.tagEndChar;\n              } else {\n                listTagVal += this.indentate(level) + '<' + key + '>' + textValue + '</' + key + this.tagEndChar;\n              }\n            } else {\n              listTagVal += this.buildTextValNode(item, key, '', level, matcher);\n            }\n          }\n        }\n      }\n      if (this.options.oneListGroup) {\n        listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);\n      }\n      val += listTagVal;\n    } else {\n      //nested node\n      if (this.options.attributesGroupName && key === this.options.attributesGroupName) {\n        const Ks = Object.keys(jObj[key]);\n        const L = Ks.length;\n        for (let j = 0; j < L; j++) {\n          attrStr += this.buildAttrPairStr(Ks[j], '' + jObj[key][Ks[j]], isCurrentStopNode);\n        }\n      } else {\n        val += this.processTextOrObjNode(jObj[key], key, level, matcher)\n      }\n    }\n  }\n  return { attrStr: attrStr, val: val };\n};\n\nBuilder.prototype.buildAttrPairStr = function (attrName, val, isStopNode) {\n  if (!isStopNode) {\n    val = this.options.attributeValueProcessor(attrName, '' + val);\n    val = this.replaceEntitiesValue(val);\n  }\n  if (this.options.suppressBooleanAttributes && val === \"true\") {\n    return ' ' + attrName;\n  } else return ' ' + attrName + '=\"' + val + '\"';\n}\n\nfunction processTextOrObjNode(object, key, level, matcher) {\n  // Extract attributes to pass to matcher\n  const attrValues = this.extractAttributes(object);\n\n  // Push tag to matcher before recursion WITH attributes\n  matcher.push(key, attrValues);\n\n  // Check if this entire node is a stopNode\n  const isStopNode = this.checkStopNode(matcher);\n\n  if (isStopNode) {\n    // For stopNodes, build raw content without entity encoding\n    const rawContent = this.buildRawContent(object);\n    const attrStr = this.buildAttributesForStopNode(object);\n    matcher.pop();\n    return this.buildObjectNode(rawContent, key, attrStr, level);\n  }\n\n  const result = this.j2x(object, level + 1, matcher);\n  // Pop tag from matcher after recursion\n  matcher.pop();\n\n  if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {\n    return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level, matcher);\n  } else {\n    return this.buildObjectNode(result.val, key, result.attrStr, level);\n  }\n}\n\n// Helper method to extract attributes from an object\nBuilder.prototype.extractAttributes = function (obj) {\n  if (!obj || typeof obj !== 'object') return null;\n\n  const attrValues = {};\n  let hasAttrs = false;\n\n  // Check for attributesGroupName (when attributes are grouped)\n  if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {\n    const attrGroup = obj[this.options.attributesGroupName];\n    for (let attrKey in attrGroup) {\n      if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;\n      // Remove attribute prefix if present\n      const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix)\n        ? attrKey.substring(this.options.attributeNamePrefix.length)\n        : attrKey;\n      attrValues[cleanKey] = attrGroup[attrKey];\n      hasAttrs = true;\n    }\n  } else {\n    // Look for individual attributes (prefixed with attributeNamePrefix)\n    for (let key in obj) {\n      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n      const attr = this.isAttribute(key);\n      if (attr) {\n        attrValues[attr] = obj[key];\n        hasAttrs = true;\n      }\n    }\n  }\n\n  return hasAttrs ? attrValues : null;\n};\n\n// Build raw content for stopNode without entity encoding\nBuilder.prototype.buildRawContent = function (obj) {\n  if (typeof obj === 'string') {\n    return obj; // Already a string, return as-is\n  }\n\n  if (typeof obj !== 'object' || obj === null) {\n    return String(obj);\n  }\n\n  // Check if this is a stopNode data from parser: { \"#text\": \"raw xml\", \"@_attr\": \"val\" }\n  if (obj[this.options.textNodeName] !== undefined) {\n    return obj[this.options.textNodeName]; // Return raw text without encoding\n  }\n\n  // Build raw XML from nested structure\n  let content = '';\n\n  for (let key in obj) {\n    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n\n    // Skip attributes\n    if (this.isAttribute(key)) continue;\n    if (this.options.attributesGroupName && key === this.options.attributesGroupName) continue;\n\n    const value = obj[key];\n\n    if (key === this.options.textNodeName) {\n      content += value; // Raw text\n    } else if (Array.isArray(value)) {\n      // Array of same tag\n      for (let item of value) {\n        if (typeof item === 'string' || typeof item === 'number') {\n          content += `<${key}>${item}</${key}>`;\n        } else if (typeof item === 'object' && item !== null) {\n          const nestedContent = this.buildRawContent(item);\n          const nestedAttrs = this.buildAttributesForStopNode(item);\n          if (nestedContent === '') {\n            content += `<${key}${nestedAttrs}/>`;\n          } else {\n            content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;\n          }\n        }\n      }\n    } else if (typeof value === 'object' && value !== null) {\n      // Nested object\n      const nestedContent = this.buildRawContent(value);\n      const nestedAttrs = this.buildAttributesForStopNode(value);\n      if (nestedContent === '') {\n        content += `<${key}${nestedAttrs}/>`;\n      } else {\n        content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;\n      }\n    } else {\n      // Primitive value\n      content += `<${key}>${value}</${key}>`;\n    }\n  }\n\n  return content;\n};\n\n// Build attribute string for stopNode (no entity encoding)\nBuilder.prototype.buildAttributesForStopNode = function (obj) {\n  if (!obj || typeof obj !== 'object') return '';\n\n  let attrStr = '';\n\n  // Check for attributesGroupName (when attributes are grouped)\n  if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {\n    const attrGroup = obj[this.options.attributesGroupName];\n    for (let attrKey in attrGroup) {\n      if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;\n      const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix)\n        ? attrKey.substring(this.options.attributeNamePrefix.length)\n        : attrKey;\n      const val = attrGroup[attrKey];\n      if (val === true && this.options.suppressBooleanAttributes) {\n        attrStr += ' ' + cleanKey;\n      } else {\n        attrStr += ' ' + cleanKey + '=\"' + val + '\"'; // No encoding for stopNode\n      }\n    }\n  } else {\n    // Look for individual attributes\n    for (let key in obj) {\n      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n      const attr = this.isAttribute(key);\n      if (attr) {\n        const val = obj[key];\n        if (val === true && this.options.suppressBooleanAttributes) {\n          attrStr += ' ' + attr;\n        } else {\n          attrStr += ' ' + attr + '=\"' + val + '\"'; // No encoding for stopNode\n        }\n      }\n    }\n  }\n\n  return attrStr;\n};\n\nBuilder.prototype.buildObjectNode = function (val, key, attrStr, level) {\n  if (val === \"\") {\n    if (key[0] === \"?\") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n    else {\n      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;\n    }\n  } else {\n\n    let tagEndExp = '</' + key + this.tagEndChar;\n    let piClosingChar = \"\";\n\n    if (key[0] === \"?\") {\n      piClosingChar = \"?\";\n      tagEndExp = \"\";\n    }\n\n    // attrStr is an empty string in case the attribute came as undefined or null\n    if ((attrStr || attrStr === '') && val.indexOf('<') === -1) {\n      return (this.indentate(level) + '<' + key + attrStr + piClosingChar + '>' + val + tagEndExp);\n    } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {\n      return this.indentate(level) + `<!--${val}-->` + this.newLine;\n    } else {\n      return (\n        this.indentate(level) + '<' + key + attrStr + piClosingChar + this.tagEndChar +\n        val +\n        this.indentate(level) + tagEndExp);\n    }\n  }\n}\n\nBuilder.prototype.closeTag = function (key) {\n  let closeTag = \"\";\n  if (this.options.unpairedTags.indexOf(key) !== -1) { //unpaired\n    if (!this.options.suppressUnpairedNode) closeTag = \"/\"\n  } else if (this.options.suppressEmptyNode) { //empty\n    closeTag = \"/\";\n  } else {\n    closeTag = `></${key}`\n  }\n  return closeTag;\n}\n\nBuilder.prototype.checkStopNode = function (matcher) {\n  if (!this.stopNodeExpressions || this.stopNodeExpressions.length === 0) return false;\n\n  for (let i = 0; i < this.stopNodeExpressions.length; i++) {\n    if (matcher.matches(this.stopNodeExpressions[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction buildEmptyObjNode(val, key, attrStr, level) {\n  if (val !== '') {\n    return this.buildObjectNode(val, key, attrStr, level);\n  } else {\n    if (key[0] === \"?\") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n    else {\n      return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;\n      // return this.buildTagStr(level,key, attrStr);\n    }\n  }\n}\n\nBuilder.prototype.buildTextValNode = function (val, key, attrStr, level, matcher) {\n  if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {\n    return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;\n  } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {\n    return this.indentate(level) + `<!--${val}-->` + this.newLine;\n  } else if (key[0] === \"?\") {//PI tag\n    return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n  } else {\n    // Normal processing: apply tagValueProcessor and entity replacement\n    let textValue = this.options.tagValueProcessor(key, val);\n    textValue = this.replaceEntitiesValue(textValue);\n\n    if (textValue === '') {\n      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;\n    } else {\n      return this.indentate(level) + '<' + key + attrStr + '>' +\n        textValue +\n        '</' + key + this.tagEndChar;\n    }\n  }\n}\n\nBuilder.prototype.replaceEntitiesValue = function (textValue) {\n  if (textValue && textValue.length > 0 && this.options.processEntities) {\n    for (let i = 0; i < this.options.entities.length; i++) {\n      const entity = this.options.entities[i];\n      textValue = textValue.replace(entity.regex, entity.val);\n    }\n  }\n  return textValue;\n}\n\nfunction indentate(level) {\n  return this.options.indentBy.repeat(level);\n}\n\nfunction isAttribute(name /*, options*/) {\n  if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {\n    return name.substr(this.attrPrefixLen);\n  } else {\n    return false;\n  }\n}","export default function getIgnoreAttributesFn(ignoreAttributes) {\n    if (typeof ignoreAttributes === 'function') {\n        return ignoreAttributes\n    }\n    if (Array.isArray(ignoreAttributes)) {\n        return (attrName) => {\n            for (const pattern of ignoreAttributes) {\n                if (typeof pattern === 'string' && attrName === pattern) {\n                    return true\n                }\n                if (pattern instanceof RegExp && pattern.test(attrName)) {\n                    return true\n                }\n            }\n        }\n    }\n    return () => false\n}","// Re-export from fast-xml-builder for backward compatibility\nimport XMLBuilder from 'fast-xml-builder';\nexport default XMLBuilder;\n\n// If there are any named exports you also want to re-export:\nexport * from 'fast-xml-builder';","'use strict';\n\nimport { validate } from './validator.js';\nimport XMLParser from './xmlparser/XMLParser.js';\nimport XMLBuilder from './xmlbuilder/json2xml.js';\n\nconst XMLValidator = {\n  validate: validate\n}\nexport {\n  XMLParser,\n  XMLValidator,\n  XMLBuilder\n};"],"names":["root","factory","exports","module","define","amd","this","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","nameStartChar","regexName","RegExp","getAllMatches","string","regex","matches","match","exec","allmatches","startIndex","lastIndex","length","len","index","push","isName","defaultOptions","allowBooleanAttributes","unpairedTags","validate","xmlData","options","assign","tags","tagFound","reachedRoot","substr","i","readPI","err","isWhiteSpace","getErrorObject","getLineNumberForPosition","tagStartPos","readCommentAndCDATA","closingTag","tagName","trim","substring","validateTagName","result","readAttributeStr","attrStr","attrStrStart","isValid","validateAttributeString","code","msg","line","tagClosed","otg","pop","openPos","col","indexOf","afterAmp","validateAmpersand","JSON","stringify","map","t","replace","char","start","tagname","angleBracketsCount","doubleQuote","singleQuote","startChar","validAttrStrRegxp","attrNames","getPositionFromMatch","undefined","attrName","validateAttrName","re","validateNumberAmpersand","count","message","lineNumber","lines","split","preserveOrder","attributeNamePrefix","attributesGroupName","textNodeName","ignoreAttributes","removeNSPrefix","parseTagValue","parseAttributeValue","trimValues","cdataPropName","numberParseOptions","hex","leadingZeros","eNotation","tagValueProcessor","val","attributeValueProcessor","stopNodes","alwaysCreateTextNode","isArray","commentPropName","processEntities","htmlEntities","ignoreDeclaration","ignorePiTags","transformTagName","transformAttributeName","updateTag","jPath","attrs","captureMetaData","maxNestedTags","strictReservedNames","normalizeProcessEntities","enabled","maxEntitySize","maxExpansionDepth","maxTotalExpansions","maxExpandedLength","maxEntityCount","allowedTags","tagFilter","_value$maxEntitySize","_value$maxExpansionDe","_value$maxTotalExpans","_value$maxExpandedLen","_value$maxEntityCount","_value$allowedTags","_value$tagFilter","METADATA_SYMBOL","buildOptions","built","Array","node","startsWith","XmlNode","child","create","_proto","add","_this$child$push","addChild","_this$child$push2","_this$child$push3","keys","getMetaDataSymbol","DocTypeReader","suppressValidationErr","readDocType","entities","entityCount","Error","hasBody","comment","hasSeq","entityName","_this$readEntityExp","readEntityExp","escaped","regx","readElementExp","readNotationExp","skipWhitespace","test","validateEntityName","toUpperCase","entityValue","_this$readIdentifierV","readIdentifierVal","notationName","identifierType","publicIdentifier","systemIdentifier","_this$readIdentifierV2","_this$readIdentifierV3","_this$readIdentifierV4","type","identifierVal","elementName","contentModel","readAttlistExp","attributeName","attributeType","allowedNotations","notation","join","includes","defaultValue","_this$readIdentifierV5","data","seq","j","name","hexRegex","numRegex","consider","decimalPoint","eNotationRegx","Matcher","constructor","separator","path","siblingStacks","attrValues","namespace","values","currentLevel","Map","siblings","siblingKey","counter","position","set","tag","updateCurrent","current","getCurrentTag","getCurrentNamespace","getAttrValue","hasAttr","getPosition","getCounter","getIndex","getDepth","toString","includeNamespace","sep","n","toArray","reset","expression","segments","hasDeepWildcard","_matchWithDeepWildcard","_matchSimple","segment","isCurrentNode","_matchSegment","pathIdx","segIdx","nextSeg","found","attrValue","actualValue","String","positionValue","snapshot","restore","Expression","pattern","_parse","_hasDeepWildcard","some","seg","_hasAttributeCondition","_hasPositionSelector","currentPart","_parseSegment","part","bracketContent","withoutBrackets","bracketMatch","content","slice","tagAndPosition","nsIndex","positionMatch","colonIndex","lastIndexOf","tagPart","posPart","eqIndex","nthMatch","parseInt","hasAttributeCondition","hasPositionSelector","extractRawAttributes","prefixedAttrs","rawAttrs","extractNamespace","rawTagName","ns","OrderedObjParser","currentNode","tagsNodeStack","docTypeEntities","lastEntities","ampEntity","_","str","fromCodePoint","addExternalEntities","parseXml","parseTextData","resolveNameSpace","buildAttributesMap","isItStopNode","replaceEntitiesValue","readStopNodeData","saveTextToParentTag","ignoreAttributesFn","_step","_iterator","_createForOfIteratorHelperLoose","done","entityExpansionCount","currentExpandedLength","matcher","isCurrentNodeStopNode","stopNodeExpressions","stopNodeExp","externalEntities","entKeys","ent","dontTrim","hasAttributes","isLeafNode","escapeEntities","jPathOrMatcher","newval","parseValue","prefix","charAt","attrsRegx","rawAttrsForMatcher","oldVal","parsedVal","jPathStr","aName","newVal","attrCollection","xmlObj","xmlNode","textData","docTypeReader","closeIndex","findClosingIndex","lastTagName","tagData","readTagExp","childNode","tagExp","attrExpPresent","endIndex","_ref","_ref2","context","Math","max","min","newTagName","lastTag","isSelfClosing","tagContent","entityConfig","entity","lengthBefore","parentNode","errMsg","closingIndex","closingChar","attrBoundary","ch","tagExpWithClosingIndex","separatorIndex","search","trimStart","openTagCount","shouldParse","trimmedStr","skipLike","numStr","Number","window","parse_int","sign","eChar","eAdjacentToLeadingZeros","resolveEnotation","numTrimmedByZeros","decimalAdjacentToLeadingZeros","num","parsedStr","toNumber","base","codePoint","stripAttributePrefix","prettify","compress","arr","text","compressedObj","tagObj","property","propName","isLeaf","isLeafTag","assignAttributes","attrMap","atrrName","rawAttrName","propCount","XMLParser","parse","validationOption","orderedObjParser","orderedResult","addEntity","toXml","jArray","indentation","format","indentBy","arrToStr","xmlStr","isPreviousElementTag","extractAttributeValues","isStopNode","checkStopNode","tagText","attStr","attr_to_str","tempInd","piTextNodeName","newIdentation","tagStart","tagValue","getRawContent","suppressUnpairedNode","suppressEmptyNode","endsWith","hasAttrs","attr","item","attr_to_str_raw","nestedContent","attrVal","suppressBooleanAttributes","textValue","a","oneListGroup","Builder","isAttribute","attrPrefixLen","processTextOrObjNode","indentate","tagEndChar","newLine","object","level","extractAttributes","rawContent","buildRawContent","buildAttributesForStopNode","buildObjectNode","j2x","buildTextValNode","repeat","build","jObj","buildFromOrderedJs","arrayNodeName","isCurrentStopNode","Date","buildAttrPairStr","closeTag","arrLen","listTagVal","listTagAttr","Ks","L","attrGroup","attrKey","nestedAttrs","cleanKey","tagEndExp","piClosingChar","XMLValidator"],"sourceRoot":""}
+{"version":3,"file":"./lib/fxp.min.js","mappings":"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","sources":["webpack://fxp/webpack/universalModuleDefinition","webpack://fxp/webpack/bootstrap","webpack://fxp/webpack/runtime/define property getters","webpack://fxp/webpack/runtime/hasOwnProperty shorthand","webpack://fxp/webpack/runtime/make namespace object","webpack://fxp/./src/util.js","webpack://fxp/./src/validator.js","webpack://fxp/./src/xmlparser/OptionsBuilder.js","webpack://fxp/./src/xmlparser/xmlNode.js","webpack://fxp/./src/xmlparser/DocTypeReader.js","webpack://fxp/./node_modules/strnum/strnum.js","webpack://fxp/./node_modules/path-expression-matcher/src/Matcher.js","webpack://fxp/./node_modules/path-expression-matcher/src/Expression.js","webpack://fxp/./src/xmlparser/OrderedObjParser.js","webpack://fxp/./src/ignoreAttributes.js","webpack://fxp/./src/xmlparser/node2json.js","webpack://fxp/./src/xmlparser/XMLParser.js","webpack://fxp/./node_modules/fast-xml-builder/src/orderedJs2Xml.js","webpack://fxp/./node_modules/fast-xml-builder/src/fxb.js","webpack://fxp/./node_modules/fast-xml-builder/src/ignoreAttributes.js","webpack://fxp/./src/xmlbuilder/json2xml.js","webpack://fxp/./src/fxp.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"fxp\"] = factory();\n\telse\n\t\troot[\"fxp\"] = factory();\n})(this, () => {\nreturn ","// The require scope\nvar __webpack_require__ = {};\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","'use strict';\n\nconst 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';\nconst nameChar = nameStartChar + '\\\\-.\\\\d\\\\u00B7\\\\u0300-\\\\u036F\\\\u203F-\\\\u2040';\nexport const nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*';\nconst regexName = new RegExp('^' + nameRegexp + '$');\n\nexport function getAllMatches(string, regex) {\n  const matches = [];\n  let match = regex.exec(string);\n  while (match) {\n    const allmatches = [];\n    allmatches.startIndex = regex.lastIndex - match[0].length;\n    const len = match.length;\n    for (let index = 0; index < len; index++) {\n      allmatches.push(match[index]);\n    }\n    matches.push(allmatches);\n    match = regex.exec(string);\n  }\n  return matches;\n}\n\nexport const isName = function (string) {\n  const match = regexName.exec(string);\n  return !(match === null || typeof match === 'undefined');\n}\n\nexport function isExist(v) {\n  return typeof v !== 'undefined';\n}\n\nexport function isEmptyObject(obj) {\n  return Object.keys(obj).length === 0;\n}\n\nexport function getValue(v) {\n  if (exports.isExist(v)) {\n    return v;\n  } else {\n    return '';\n  }\n}\n\n/**\n * Dangerous property names that could lead to prototype pollution or security issues\n */\nexport const DANGEROUS_PROPERTY_NAMES = [\n  // '__proto__',\n  // 'constructor',\n  // 'prototype',\n  'hasOwnProperty',\n  'toString',\n  'valueOf',\n  '__defineGetter__',\n  '__defineSetter__',\n  '__lookupGetter__',\n  '__lookupSetter__'\n];\n\nexport const criticalProperties = [\"__proto__\", \"constructor\", \"prototype\"];","'use strict';\n\nimport { getAllMatches, isName } from './util.js';\n\nconst defaultOptions = {\n  allowBooleanAttributes: false, //A tag can have attributes without any value\n  unpairedTags: []\n};\n\n//const tagsPattern = new RegExp(\"<\\\\/?([\\\\w:\\\\-_\\.]+)\\\\s*\\/?>\",\"g\");\nexport function validate(xmlData, options) {\n  options = Object.assign({}, defaultOptions, options);\n\n  //xmlData = xmlData.replace(/(\\r\\n|\\n|\\r)/gm,\"\");//make it single line\n  //xmlData = xmlData.replace(/(^\\s*<\\?xml.*?\\?>)/g,\"\");//Remove XML starting tag\n  //xmlData = xmlData.replace(/(<!DOCTYPE[\\s\\w\\\"\\.\\/\\-\\:]+(\\[.*\\])*\\s*>)/g,\"\");//Remove DOCTYPE\n  const tags = [];\n  let tagFound = false;\n\n  //indicates that the root tag has been closed (aka. depth 0 has been reached)\n  let reachedRoot = false;\n\n  if (xmlData[0] === '\\ufeff') {\n    // check for byte order mark (BOM)\n    xmlData = xmlData.substr(1);\n  }\n\n  for (let i = 0; i < xmlData.length; i++) {\n\n    if (xmlData[i] === '<' && xmlData[i + 1] === '?') {\n      i += 2;\n      i = readPI(xmlData, i);\n      if (i.err) return i;\n    } else if (xmlData[i] === '<') {\n      //starting of tag\n      //read until you reach to '>' avoiding any '>' in attribute value\n      let tagStartPos = i;\n      i++;\n\n      if (xmlData[i] === '!') {\n        i = readCommentAndCDATA(xmlData, i);\n        continue;\n      } else {\n        let closingTag = false;\n        if (xmlData[i] === '/') {\n          //closing tag\n          closingTag = true;\n          i++;\n        }\n        //read tagname\n        let tagName = '';\n        for (; i < xmlData.length &&\n          xmlData[i] !== '>' &&\n          xmlData[i] !== ' ' &&\n          xmlData[i] !== '\\t' &&\n          xmlData[i] !== '\\n' &&\n          xmlData[i] !== '\\r'; i++\n        ) {\n          tagName += xmlData[i];\n        }\n        tagName = tagName.trim();\n        //console.log(tagName);\n\n        if (tagName[tagName.length - 1] === '/') {\n          //self closing tag without attributes\n          tagName = tagName.substring(0, tagName.length - 1);\n          //continue;\n          i--;\n        }\n        if (!validateTagName(tagName)) {\n          let msg;\n          if (tagName.trim().length === 0) {\n            msg = \"Invalid space after '<'.\";\n          } else {\n            msg = \"Tag '\" + tagName + \"' is an invalid name.\";\n          }\n          return getErrorObject('InvalidTag', msg, getLineNumberForPosition(xmlData, i));\n        }\n\n        const result = readAttributeStr(xmlData, i);\n        if (result === false) {\n          return getErrorObject('InvalidAttr', \"Attributes for '\" + tagName + \"' have open quote.\", getLineNumberForPosition(xmlData, i));\n        }\n        let attrStr = result.value;\n        i = result.index;\n\n        if (attrStr[attrStr.length - 1] === '/') {\n          //self closing tag\n          const attrStrStart = i - attrStr.length;\n          attrStr = attrStr.substring(0, attrStr.length - 1);\n          const isValid = validateAttributeString(attrStr, options);\n          if (isValid === true) {\n            tagFound = true;\n            //continue; //text may presents after self closing tag\n          } else {\n            //the result from the nested function returns the position of the error within the attribute\n            //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute\n            //this gives us the absolute index in the entire xml, which we can use to find the line at last\n            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));\n          }\n        } else if (closingTag) {\n          if (!result.tagClosed) {\n            return getErrorObject('InvalidTag', \"Closing tag '\" + tagName + \"' doesn't have proper closing.\", getLineNumberForPosition(xmlData, i));\n          } else if (attrStr.trim().length > 0) {\n            return getErrorObject('InvalidTag', \"Closing tag '\" + tagName + \"' can't have attributes or invalid starting.\", getLineNumberForPosition(xmlData, tagStartPos));\n          } else if (tags.length === 0) {\n            return getErrorObject('InvalidTag', \"Closing tag '\" + tagName + \"' has not been opened.\", getLineNumberForPosition(xmlData, tagStartPos));\n          } else {\n            const otg = tags.pop();\n            if (tagName !== otg.tagName) {\n              let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);\n              return getErrorObject('InvalidTag',\n                \"Expected closing tag '\" + otg.tagName + \"' (opened in line \" + openPos.line + \", col \" + openPos.col + \") instead of closing tag '\" + tagName + \"'.\",\n                getLineNumberForPosition(xmlData, tagStartPos));\n            }\n\n            //when there are no more tags, we reached the root level.\n            if (tags.length == 0) {\n              reachedRoot = true;\n            }\n          }\n        } else {\n          const isValid = validateAttributeString(attrStr, options);\n          if (isValid !== true) {\n            //the result from the nested function returns the position of the error within the attribute\n            //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute\n            //this gives us the absolute index in the entire xml, which we can use to find the line at last\n            return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));\n          }\n\n          //if the root level has been reached before ...\n          if (reachedRoot === true) {\n            return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));\n          } else if (options.unpairedTags.indexOf(tagName) !== -1) {\n            //don't push into stack\n          } else {\n            tags.push({ tagName, tagStartPos });\n          }\n          tagFound = true;\n        }\n\n        //skip tag text value\n        //It may include comments and CDATA value\n        for (i++; i < xmlData.length; i++) {\n          if (xmlData[i] === '<') {\n            if (xmlData[i + 1] === '!') {\n              //comment or CADATA\n              i++;\n              i = readCommentAndCDATA(xmlData, i);\n              continue;\n            } else if (xmlData[i + 1] === '?') {\n              i = readPI(xmlData, ++i);\n              if (i.err) return i;\n            } else {\n              break;\n            }\n          } else if (xmlData[i] === '&') {\n            const afterAmp = validateAmpersand(xmlData, i);\n            if (afterAmp == -1)\n              return getErrorObject('InvalidChar', \"char '&' is not expected.\", getLineNumberForPosition(xmlData, i));\n            i = afterAmp;\n          } else {\n            if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {\n              return getErrorObject('InvalidXml', \"Extra text at the end\", getLineNumberForPosition(xmlData, i));\n            }\n          }\n        } //end of reading tag text value\n        if (xmlData[i] === '<') {\n          i--;\n        }\n      }\n    } else {\n      if (isWhiteSpace(xmlData[i])) {\n        continue;\n      }\n      return getErrorObject('InvalidChar', \"char '\" + xmlData[i] + \"' is not expected.\", getLineNumberForPosition(xmlData, i));\n    }\n  }\n\n  if (!tagFound) {\n    return getErrorObject('InvalidXml', 'Start tag expected.', 1);\n  } else if (tags.length == 1) {\n    return getErrorObject('InvalidTag', \"Unclosed tag '\" + tags[0].tagName + \"'.\", getLineNumberForPosition(xmlData, tags[0].tagStartPos));\n  } else if (tags.length > 0) {\n    return getErrorObject('InvalidXml', \"Invalid '\" +\n      JSON.stringify(tags.map(t => t.tagName), null, 4).replace(/\\r?\\n/g, '') +\n      \"' found.\", { line: 1, col: 1 });\n  }\n\n  return true;\n};\n\nfunction isWhiteSpace(char) {\n  return char === ' ' || char === '\\t' || char === '\\n' || char === '\\r';\n}\n/**\n * Read Processing insstructions and skip\n * @param {*} xmlData\n * @param {*} i\n */\nfunction readPI(xmlData, i) {\n  const start = i;\n  for (; i < xmlData.length; i++) {\n    if (xmlData[i] == '?' || xmlData[i] == ' ') {\n      //tagname\n      const tagname = xmlData.substr(start, i - start);\n      if (i > 5 && tagname === 'xml') {\n        return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i));\n      } else if (xmlData[i] == '?' && xmlData[i + 1] == '>') {\n        //check if valid attribut string\n        i++;\n        break;\n      } else {\n        continue;\n      }\n    }\n  }\n  return i;\n}\n\nfunction readCommentAndCDATA(xmlData, i) {\n  if (xmlData.length > i + 5 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') {\n    //comment\n    for (i += 3; i < xmlData.length; i++) {\n      if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') {\n        i += 2;\n        break;\n      }\n    }\n  } else if (\n    xmlData.length > i + 8 &&\n    xmlData[i + 1] === 'D' &&\n    xmlData[i + 2] === 'O' &&\n    xmlData[i + 3] === 'C' &&\n    xmlData[i + 4] === 'T' &&\n    xmlData[i + 5] === 'Y' &&\n    xmlData[i + 6] === 'P' &&\n    xmlData[i + 7] === 'E'\n  ) {\n    let angleBracketsCount = 1;\n    for (i += 8; i < xmlData.length; i++) {\n      if (xmlData[i] === '<') {\n        angleBracketsCount++;\n      } else if (xmlData[i] === '>') {\n        angleBracketsCount--;\n        if (angleBracketsCount === 0) {\n          break;\n        }\n      }\n    }\n  } else if (\n    xmlData.length > i + 9 &&\n    xmlData[i + 1] === '[' &&\n    xmlData[i + 2] === 'C' &&\n    xmlData[i + 3] === 'D' &&\n    xmlData[i + 4] === 'A' &&\n    xmlData[i + 5] === 'T' &&\n    xmlData[i + 6] === 'A' &&\n    xmlData[i + 7] === '['\n  ) {\n    for (i += 8; i < xmlData.length; i++) {\n      if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') {\n        i += 2;\n        break;\n      }\n    }\n  }\n\n  return i;\n}\n\nconst doubleQuote = '\"';\nconst singleQuote = \"'\";\n\n/**\n * Keep reading xmlData until '<' is found outside the attribute value.\n * @param {string} xmlData\n * @param {number} i\n */\nfunction readAttributeStr(xmlData, i) {\n  let attrStr = '';\n  let startChar = '';\n  let tagClosed = false;\n  for (; i < xmlData.length; i++) {\n    if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {\n      if (startChar === '') {\n        startChar = xmlData[i];\n      } else if (startChar !== xmlData[i]) {\n        //if vaue is enclosed with double quote then single quotes are allowed inside the value and vice versa\n      } else {\n        startChar = '';\n      }\n    } else if (xmlData[i] === '>') {\n      if (startChar === '') {\n        tagClosed = true;\n        break;\n      }\n    }\n    attrStr += xmlData[i];\n  }\n  if (startChar !== '') {\n    return false;\n  }\n\n  return {\n    value: attrStr,\n    index: i,\n    tagClosed: tagClosed\n  };\n}\n\n/**\n * Select all the attributes whether valid or invalid.\n */\nconst validAttrStrRegxp = new RegExp('(\\\\s*)([^\\\\s=]+)(\\\\s*=)?(\\\\s*([\\'\"])(([\\\\s\\\\S])*?)\\\\5)?', 'g');\n\n//attr, =\"sd\", a=\"amit's\", a=\"sd\"b=\"saf\", ab  cd=\"\"\n\nfunction validateAttributeString(attrStr, options) {\n  //console.log(\"start:\"+attrStr+\":end\");\n\n  //if(attrStr.trim().length === 0) return true; //empty string\n\n  const matches = getAllMatches(attrStr, validAttrStrRegxp);\n  const attrNames = {};\n\n  for (let i = 0; i < matches.length; i++) {\n    if (matches[i][1].length === 0) {\n      //nospace before attribute name: a=\"sd\"b=\"saf\"\n      return getErrorObject('InvalidAttr', \"Attribute '\" + matches[i][2] + \"' has no space in starting.\", getPositionFromMatch(matches[i]))\n    } else if (matches[i][3] !== undefined && matches[i][4] === undefined) {\n      return getErrorObject('InvalidAttr', \"Attribute '\" + matches[i][2] + \"' is without value.\", getPositionFromMatch(matches[i]));\n    } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {\n      //independent attribute: ab\n      return getErrorObject('InvalidAttr', \"boolean attribute '\" + matches[i][2] + \"' is not allowed.\", getPositionFromMatch(matches[i]));\n    }\n    /* else if(matches[i][6] === undefined){//attribute without value: ab=\n                    return { err: { code:\"InvalidAttr\",msg:\"attribute \" + matches[i][2] + \" has no value assigned.\"}};\n                } */\n    const attrName = matches[i][2];\n    if (!validateAttrName(attrName)) {\n      return getErrorObject('InvalidAttr', \"Attribute '\" + attrName + \"' is an invalid name.\", getPositionFromMatch(matches[i]));\n    }\n    if (!Object.prototype.hasOwnProperty.call(attrNames, attrName)) {\n      //check for duplicate attribute.\n      attrNames[attrName] = 1;\n    } else {\n      return getErrorObject('InvalidAttr', \"Attribute '\" + attrName + \"' is repeated.\", getPositionFromMatch(matches[i]));\n    }\n  }\n\n  return true;\n}\n\nfunction validateNumberAmpersand(xmlData, i) {\n  let re = /\\d/;\n  if (xmlData[i] === 'x') {\n    i++;\n    re = /[\\da-fA-F]/;\n  }\n  for (; i < xmlData.length; i++) {\n    if (xmlData[i] === ';')\n      return i;\n    if (!xmlData[i].match(re))\n      break;\n  }\n  return -1;\n}\n\nfunction validateAmpersand(xmlData, i) {\n  // https://www.w3.org/TR/xml/#dt-charref\n  i++;\n  if (xmlData[i] === ';')\n    return -1;\n  if (xmlData[i] === '#') {\n    i++;\n    return validateNumberAmpersand(xmlData, i);\n  }\n  let count = 0;\n  for (; i < xmlData.length; i++, count++) {\n    if (xmlData[i].match(/\\w/) && count < 20)\n      continue;\n    if (xmlData[i] === ';')\n      break;\n    return -1;\n  }\n  return i;\n}\n\nfunction getErrorObject(code, message, lineNumber) {\n  return {\n    err: {\n      code: code,\n      msg: message,\n      line: lineNumber.line || lineNumber,\n      col: lineNumber.col,\n    },\n  };\n}\n\nfunction validateAttrName(attrName) {\n  return isName(attrName);\n}\n\n// const startsWithXML = /^xml/i;\n\nfunction validateTagName(tagname) {\n  return isName(tagname) /* && !tagname.match(startsWithXML) */;\n}\n\n//this function returns the line number for the character at the given index\nfunction getLineNumberForPosition(xmlData, index) {\n  const lines = xmlData.substring(0, index).split(/\\r?\\n/);\n  return {\n    line: lines.length,\n\n    // column number is last line's length + 1, because column numbering starts at 1:\n    col: lines[lines.length - 1].length + 1\n  };\n}\n\n//this function returns the position of the first character of match within attrStr\nfunction getPositionFromMatch(match) {\n  return match.startIndex + match[1].length;\n}\n","import { DANGEROUS_PROPERTY_NAMES, criticalProperties } from \"../util.js\";\n\nconst defaultOnDangerousProperty = (name) => {\n  if (DANGEROUS_PROPERTY_NAMES.includes(name)) {\n    return \"__\" + name;\n  }\n  return name;\n};\n\n\nexport const defaultOptions = {\n  preserveOrder: false,\n  attributeNamePrefix: '@_',\n  attributesGroupName: false,\n  textNodeName: '#text',\n  ignoreAttributes: true,\n  removeNSPrefix: false, // remove NS from tag name or attribute name if true\n  allowBooleanAttributes: false, //a tag can have attributes without any value\n  //ignoreRootElement : false,\n  parseTagValue: true,\n  parseAttributeValue: false,\n  trimValues: true, //Trim string values of tag and attributes\n  cdataPropName: false,\n  numberParseOptions: {\n    hex: true,\n    leadingZeros: true,\n    eNotation: true\n  },\n  tagValueProcessor: function (tagName, val) {\n    return val;\n  },\n  attributeValueProcessor: function (attrName, val) {\n    return val;\n  },\n  stopNodes: [], //nested tags will not be parsed even for errors\n  alwaysCreateTextNode: false,\n  isArray: () => false,\n  commentPropName: false,\n  unpairedTags: [],\n  processEntities: true,\n  htmlEntities: false,\n  ignoreDeclaration: false,\n  ignorePiTags: false,\n  transformTagName: false,\n  transformAttributeName: false,\n  updateTag: function (tagName, jPath, attrs) {\n    return tagName\n  },\n  // skipEmptyListItem: false\n  captureMetaData: false,\n  maxNestedTags: 100,\n  strictReservedNames: true,\n  jPath: true, // if true, pass jPath string to callbacks; if false, pass matcher instance\n  onDangerousProperty: defaultOnDangerousProperty\n};\n\n\n/**\n * Validates that a property name is safe to use\n * @param {string} propertyName - The property name to validate\n * @param {string} optionName - The option field name (for error message)\n * @throws {Error} If property name is dangerous\n */\nfunction validatePropertyName(propertyName, optionName) {\n  if (typeof propertyName !== 'string') {\n    return; // Only validate string property names\n  }\n\n  const normalized = propertyName.toLowerCase();\n  if (DANGEROUS_PROPERTY_NAMES.some(dangerous => normalized === dangerous.toLowerCase())) {\n    throw new Error(\n      `[SECURITY] Invalid ${optionName}: \"${propertyName}\" is a reserved JavaScript keyword that could cause prototype pollution`\n    );\n  }\n\n  if (criticalProperties.some(dangerous => normalized === dangerous.toLowerCase())) {\n    throw new Error(\n      `[SECURITY] Invalid ${optionName}: \"${propertyName}\" is a reserved JavaScript keyword that could cause prototype pollution`\n    );\n  }\n}\n\n/**\n * Normalizes processEntities option for backward compatibility\n * @param {boolean|object} value \n * @returns {object} Always returns normalized object\n */\nfunction normalizeProcessEntities(value) {\n  // Boolean backward compatibility\n  if (typeof value === 'boolean') {\n    return {\n      enabled: value, // true or false\n      maxEntitySize: 10000,\n      maxExpansionDepth: 10,\n      maxTotalExpansions: 1000,\n      maxExpandedLength: 100000,\n      maxEntityCount: 100,\n      allowedTags: null,\n      tagFilter: null\n    };\n  }\n\n  // Object config - merge with defaults\n  if (typeof value === 'object' && value !== null) {\n    return {\n      enabled: value.enabled !== false, // default true if not specified\n      maxEntitySize: value.maxEntitySize ?? 10000,\n      maxExpansionDepth: value.maxExpansionDepth ?? 10,\n      maxTotalExpansions: value.maxTotalExpansions ?? 1000,\n      maxExpandedLength: value.maxExpandedLength ?? 100000,\n      maxEntityCount: value.maxEntityCount ?? 100,\n      allowedTags: value.allowedTags ?? null,\n      tagFilter: value.tagFilter ?? null\n    };\n  }\n\n  // Default to enabled with limits\n  return normalizeProcessEntities(true);\n}\n\nexport const buildOptions = function (options) {\n  const built = Object.assign({}, defaultOptions, options);\n\n  // Validate property names to prevent prototype pollution\n  const propertyNameOptions = [\n    { value: built.attributeNamePrefix, name: 'attributeNamePrefix' },\n    { value: built.attributesGroupName, name: 'attributesGroupName' },\n    { value: built.textNodeName, name: 'textNodeName' },\n    { value: built.cdataPropName, name: 'cdataPropName' },\n    { value: built.commentPropName, name: 'commentPropName' }\n  ];\n\n  for (const { value, name } of propertyNameOptions) {\n    if (value) {\n      validatePropertyName(value, name);\n    }\n  }\n\n  if (built.onDangerousProperty === null) {\n    built.onDangerousProperty = defaultOnDangerousProperty;\n  }\n\n  // Always normalize processEntities for backward compatibility and validation\n  built.processEntities = normalizeProcessEntities(built.processEntities);\n\n  // Convert old-style stopNodes for backward compatibility\n  if (built.stopNodes && Array.isArray(built.stopNodes)) {\n    built.stopNodes = built.stopNodes.map(node => {\n      if (typeof node === 'string' && node.startsWith('*.')) {\n        // Old syntax: *.tagname meant \"tagname anywhere\"\n        // Convert to new syntax: ..tagname\n        return '..' + node.substring(2);\n      }\n      return node;\n    });\n  }\n  //console.debug(built.processEntities)\n  return built;\n};","'use strict';\n\nlet METADATA_SYMBOL;\n\nif (typeof Symbol !== \"function\") {\n  METADATA_SYMBOL = \"@@xmlMetadata\";\n} else {\n  METADATA_SYMBOL = Symbol(\"XML Node Metadata\");\n}\n\nexport default class XmlNode {\n  constructor(tagname) {\n    this.tagname = tagname;\n    this.child = []; //nested tags, text, cdata, comments in order\n    this[\":@\"] = Object.create(null); //attributes map\n  }\n  add(key, val) {\n    // this.child.push( {name : key, val: val, isCdata: isCdata });\n    if (key === \"__proto__\") key = \"#__proto__\";\n    this.child.push({ [key]: val });\n  }\n  addChild(node, startIndex) {\n    if (node.tagname === \"__proto__\") node.tagname = \"#__proto__\";\n    if (node[\":@\"] && Object.keys(node[\":@\"]).length > 0) {\n      this.child.push({ [node.tagname]: node.child, [\":@\"]: node[\":@\"] });\n    } else {\n      this.child.push({ [node.tagname]: node.child });\n    }\n    // if requested, add the startIndex\n    if (startIndex !== undefined) {\n      // Note: for now we just overwrite the metadata. If we had more complex metadata,\n      // we might need to do an object append here:  metadata = { ...metadata, startIndex }\n      this.child[this.child.length - 1][METADATA_SYMBOL] = { startIndex };\n    }\n  }\n  /** symbol used for metadata */\n  static getMetaDataSymbol() {\n    return METADATA_SYMBOL;\n  }\n}\n","import { isName } from '../util.js';\n\nexport default class DocTypeReader {\n    constructor(options) {\n        this.suppressValidationErr = !options;\n        this.options = options;\n    }\n\n    readDocType(xmlData, i) {\n        const entities = Object.create(null);\n        let entityCount = 0;\n\n        if (xmlData[i + 3] === 'O' &&\n            xmlData[i + 4] === 'C' &&\n            xmlData[i + 5] === 'T' &&\n            xmlData[i + 6] === 'Y' &&\n            xmlData[i + 7] === 'P' &&\n            xmlData[i + 8] === 'E') {\n            i = i + 9;\n            let angleBracketsCount = 1;\n            let hasBody = false, comment = false;\n            let exp = \"\";\n            for (; i < xmlData.length; i++) {\n                if (xmlData[i] === '<' && !comment) { //Determine the tag type\n                    if (hasBody && hasSeq(xmlData, \"!ENTITY\", i)) {\n                        i += 7;\n                        let entityName, val;\n                        [entityName, val, i] = this.readEntityExp(xmlData, i + 1, this.suppressValidationErr);\n                        if (val.indexOf(\"&\") === -1) { //Parameter entities are not supported\n                            if (this.options.enabled !== false &&\n                                this.options.maxEntityCount &&\n                                entityCount >= this.options.maxEntityCount) {\n                                throw new Error(\n                                    `Entity count (${entityCount + 1}) exceeds maximum allowed (${this.options.maxEntityCount})`\n                                );\n                            }\n                            const escaped = entityName.replace(/[.\\-+*:]/g, '\\\\.');\n                            entities[entityName] = {\n                                regx: RegExp(`&${escaped};`, \"g\"),\n                                val: val\n                            };\n                            entityCount++;\n                        }\n                    }\n                    else if (hasBody && hasSeq(xmlData, \"!ELEMENT\", i)) {\n                        i += 8;//Not supported\n                        const { index } = this.readElementExp(xmlData, i + 1);\n                        i = index;\n                    } else if (hasBody && hasSeq(xmlData, \"!ATTLIST\", i)) {\n                        i += 8;//Not supported\n                        // const {index} = this.readAttlistExp(xmlData,i+1);\n                        // i = index;\n                    } else if (hasBody && hasSeq(xmlData, \"!NOTATION\", i)) {\n                        i += 9;//Not supported\n                        const { index } = this.readNotationExp(xmlData, i + 1, this.suppressValidationErr);\n                        i = index;\n                    } else if (hasSeq(xmlData, \"!--\", i)) comment = true;\n                    else throw new Error(`Invalid DOCTYPE`);\n\n                    angleBracketsCount++;\n                    exp = \"\";\n                } else if (xmlData[i] === '>') { //Read tag content\n                    if (comment) {\n                        if (xmlData[i - 1] === \"-\" && xmlData[i - 2] === \"-\") {\n                            comment = false;\n                            angleBracketsCount--;\n                        }\n                    } else {\n                        angleBracketsCount--;\n                    }\n                    if (angleBracketsCount === 0) {\n                        break;\n                    }\n                } else if (xmlData[i] === '[') {\n                    hasBody = true;\n                } else {\n                    exp += xmlData[i];\n                }\n            }\n            if (angleBracketsCount !== 0) {\n                throw new Error(`Unclosed DOCTYPE`);\n            }\n        } else {\n            throw new Error(`Invalid Tag instead of DOCTYPE`);\n        }\n        return { entities, i };\n    }\n    readEntityExp(xmlData, i) {\n        //External entities are not supported\n        //    <!ENTITY ext SYSTEM \"http://normal-website.com\" >\n\n        //Parameter entities are not supported\n        //    <!ENTITY entityname \"&anotherElement;\">\n\n        //Internal entities are supported\n        //    <!ENTITY entityname \"replacement text\">\n\n        // Skip leading whitespace after <!ENTITY\n        i = skipWhitespace(xmlData, i);\n\n        // Read entity name\n        let entityName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i]) && xmlData[i] !== '\"' && xmlData[i] !== \"'\") {\n            entityName += xmlData[i];\n            i++;\n        }\n        validateEntityName(entityName);\n\n        // Skip whitespace after entity name\n        i = skipWhitespace(xmlData, i);\n\n        // Check for unsupported constructs (external entities or parameter entities)\n        if (!this.suppressValidationErr) {\n            if (xmlData.substring(i, i + 6).toUpperCase() === \"SYSTEM\") {\n                throw new Error(\"External entities are not supported\");\n            } else if (xmlData[i] === \"%\") {\n                throw new Error(\"Parameter entities are not supported\");\n            }\n        }\n\n        // Read entity value (internal entity)\n        let entityValue = \"\";\n        [i, entityValue] = this.readIdentifierVal(xmlData, i, \"entity\");\n\n        // Validate entity size\n        if (this.options.enabled !== false &&\n            this.options.maxEntitySize &&\n            entityValue.length > this.options.maxEntitySize) {\n            throw new Error(\n                `Entity \"${entityName}\" size (${entityValue.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`\n            );\n        }\n\n        i--;\n        return [entityName, entityValue, i];\n    }\n\n    readNotationExp(xmlData, i) {\n        // Skip leading whitespace after <!NOTATION\n        i = skipWhitespace(xmlData, i);\n\n        // Read notation name\n        let notationName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            notationName += xmlData[i];\n            i++;\n        }\n        !this.suppressValidationErr && validateEntityName(notationName);\n\n        // Skip whitespace after notation name\n        i = skipWhitespace(xmlData, i);\n\n        // Check identifier type (SYSTEM or PUBLIC)\n        const identifierType = xmlData.substring(i, i + 6).toUpperCase();\n        if (!this.suppressValidationErr && identifierType !== \"SYSTEM\" && identifierType !== \"PUBLIC\") {\n            throw new Error(`Expected SYSTEM or PUBLIC, found \"${identifierType}\"`);\n        }\n        i += identifierType.length;\n\n        // Skip whitespace after identifier type\n        i = skipWhitespace(xmlData, i);\n\n        // Read public identifier (if PUBLIC)\n        let publicIdentifier = null;\n        let systemIdentifier = null;\n\n        if (identifierType === \"PUBLIC\") {\n            [i, publicIdentifier] = this.readIdentifierVal(xmlData, i, \"publicIdentifier\");\n\n            // Skip whitespace after public identifier\n            i = skipWhitespace(xmlData, i);\n\n            // Optionally read system identifier\n            if (xmlData[i] === '\"' || xmlData[i] === \"'\") {\n                [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, \"systemIdentifier\");\n            }\n        } else if (identifierType === \"SYSTEM\") {\n            // Read system identifier (mandatory for SYSTEM)\n            [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, \"systemIdentifier\");\n\n            if (!this.suppressValidationErr && !systemIdentifier) {\n                throw new Error(\"Missing mandatory system identifier for SYSTEM notation\");\n            }\n        }\n\n        return { notationName, publicIdentifier, systemIdentifier, index: --i };\n    }\n\n    readIdentifierVal(xmlData, i, type) {\n        let identifierVal = \"\";\n        const startChar = xmlData[i];\n        if (startChar !== '\"' && startChar !== \"'\") {\n            throw new Error(`Expected quoted string, found \"${startChar}\"`);\n        }\n        i++;\n\n        while (i < xmlData.length && xmlData[i] !== startChar) {\n            identifierVal += xmlData[i];\n            i++;\n        }\n\n        if (xmlData[i] !== startChar) {\n            throw new Error(`Unterminated ${type} value`);\n        }\n        i++;\n        return [i, identifierVal];\n    }\n\n    readElementExp(xmlData, i) {\n        // <!ELEMENT br EMPTY>\n        // <!ELEMENT div ANY>\n        // <!ELEMENT title (#PCDATA)>\n        // <!ELEMENT book (title, author+)>\n        // <!ELEMENT name (content-model)>\n\n        // Skip leading whitespace after <!ELEMENT\n        i = skipWhitespace(xmlData, i);\n\n        // Read element name\n        let elementName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            elementName += xmlData[i];\n            i++;\n        }\n\n        // Validate element name\n        if (!this.suppressValidationErr && !isName(elementName)) {\n            throw new Error(`Invalid element name: \"${elementName}\"`);\n        }\n\n        // Skip whitespace after element name\n        i = skipWhitespace(xmlData, i);\n        let contentModel = \"\";\n        // Expect '(' to start content model\n        if (xmlData[i] === \"E\" && hasSeq(xmlData, \"MPTY\", i)) i += 4;\n        else if (xmlData[i] === \"A\" && hasSeq(xmlData, \"NY\", i)) i += 2;\n        else if (xmlData[i] === \"(\") {\n            i++; // Move past '('\n\n            // Read content model\n            while (i < xmlData.length && xmlData[i] !== \")\") {\n                contentModel += xmlData[i];\n                i++;\n            }\n            if (xmlData[i] !== \")\") {\n                throw new Error(\"Unterminated content model\");\n            }\n\n        } else if (!this.suppressValidationErr) {\n            throw new Error(`Invalid Element Expression, found \"${xmlData[i]}\"`);\n        }\n\n        return {\n            elementName,\n            contentModel: contentModel.trim(),\n            index: i\n        };\n    }\n\n    readAttlistExp(xmlData, i) {\n        // Skip leading whitespace after <!ATTLIST\n        i = skipWhitespace(xmlData, i);\n\n        // Read element name\n        let elementName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            elementName += xmlData[i];\n            i++;\n        }\n\n        // Validate element name\n        validateEntityName(elementName)\n\n        // Skip whitespace after element name\n        i = skipWhitespace(xmlData, i);\n\n        // Read attribute name\n        let attributeName = \"\";\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            attributeName += xmlData[i];\n            i++;\n        }\n\n        // Validate attribute name\n        if (!validateEntityName(attributeName)) {\n            throw new Error(`Invalid attribute name: \"${attributeName}\"`);\n        }\n\n        // Skip whitespace after attribute name\n        i = skipWhitespace(xmlData, i);\n\n        // Read attribute type\n        let attributeType = \"\";\n        if (xmlData.substring(i, i + 8).toUpperCase() === \"NOTATION\") {\n            attributeType = \"NOTATION\";\n            i += 8; // Move past \"NOTATION\"\n\n            // Skip whitespace after \"NOTATION\"\n            i = skipWhitespace(xmlData, i);\n\n            // Expect '(' to start the list of notations\n            if (xmlData[i] !== \"(\") {\n                throw new Error(`Expected '(', found \"${xmlData[i]}\"`);\n            }\n            i++; // Move past '('\n\n            // Read the list of allowed notations\n            let allowedNotations = [];\n            while (i < xmlData.length && xmlData[i] !== \")\") {\n                let notation = \"\";\n                while (i < xmlData.length && xmlData[i] !== \"|\" && xmlData[i] !== \")\") {\n                    notation += xmlData[i];\n                    i++;\n                }\n\n                // Validate notation name\n                notation = notation.trim();\n                if (!validateEntityName(notation)) {\n                    throw new Error(`Invalid notation name: \"${notation}\"`);\n                }\n\n                allowedNotations.push(notation);\n\n                // Skip '|' separator or exit loop\n                if (xmlData[i] === \"|\") {\n                    i++; // Move past '|'\n                    i = skipWhitespace(xmlData, i); // Skip optional whitespace after '|'\n                }\n            }\n\n            if (xmlData[i] !== \")\") {\n                throw new Error(\"Unterminated list of notations\");\n            }\n            i++; // Move past ')'\n\n            // Store the allowed notations as part of the attribute type\n            attributeType += \" (\" + allowedNotations.join(\"|\") + \")\";\n        } else {\n            // Handle simple types (e.g., CDATA, ID, IDREF, etc.)\n            while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n                attributeType += xmlData[i];\n                i++;\n            }\n\n            // Validate simple attribute type\n            const validTypes = [\"CDATA\", \"ID\", \"IDREF\", \"IDREFS\", \"ENTITY\", \"ENTITIES\", \"NMTOKEN\", \"NMTOKENS\"];\n            if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {\n                throw new Error(`Invalid attribute type: \"${attributeType}\"`);\n            }\n        }\n\n        // Skip whitespace after attribute type\n        i = skipWhitespace(xmlData, i);\n\n        // Read default value\n        let defaultValue = \"\";\n        if (xmlData.substring(i, i + 8).toUpperCase() === \"#REQUIRED\") {\n            defaultValue = \"#REQUIRED\";\n            i += 8;\n        } else if (xmlData.substring(i, i + 7).toUpperCase() === \"#IMPLIED\") {\n            defaultValue = \"#IMPLIED\";\n            i += 7;\n        } else {\n            [i, defaultValue] = this.readIdentifierVal(xmlData, i, \"ATTLIST\");\n        }\n\n        return {\n            elementName,\n            attributeName,\n            attributeType,\n            defaultValue,\n            index: i\n        }\n    }\n}\n\n\n\nconst skipWhitespace = (data, index) => {\n    while (index < data.length && /\\s/.test(data[index])) {\n        index++;\n    }\n    return index;\n};\n\n\n\nfunction hasSeq(data, seq, i) {\n    for (let j = 0; j < seq.length; j++) {\n        if (seq[j] !== data[i + j + 1]) return false;\n    }\n    return true;\n}\n\nfunction validateEntityName(name) {\n    if (isName(name))\n        return name;\n    else\n        throw new Error(`Invalid entity name ${name}`);\n}","const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;\nconst numRegex = /^([\\-\\+])?(0*)([0-9]*(\\.[0-9]*)?)$/;\n// const octRegex = /^0x[a-z0-9]+/;\n// const binRegex = /0x[a-z0-9]+/;\n\n \nconst consider = {\n    hex :  true,\n    // oct: false,\n    leadingZeros: true,\n    decimalPoint: \"\\.\",\n    eNotation: true,\n    //skipLike: /regex/\n};\n\nexport default function toNumber(str, options = {}){\n    options = Object.assign({}, consider, options );\n    if(!str || typeof str !== \"string\" ) return str;\n    \n    let trimmedStr  = str.trim();\n    \n    if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;\n    else if(str===\"0\") return 0;\n    else if (options.hex && hexRegex.test(trimmedStr)) {\n        return parse_int(trimmedStr, 16);\n    // }else if (options.oct && octRegex.test(str)) {\n    //     return Number.parseInt(val, 8);\n    }else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation\n        return resolveEnotation(str,trimmedStr,options);\n    // }else if (options.parseBin && binRegex.test(str)) {\n    //     return Number.parseInt(val, 2);\n    }else{\n        //separate negative sign, leading zeros, and rest number\n        const match = numRegex.exec(trimmedStr);\n        // +00.123 => [ , '+', '00', '.123', ..\n        if(match){\n            const sign = match[1] || \"\";\n            const leadingZeros = match[2];\n            let numTrimmedByZeros = trimZeros(match[3]); //complete num without leading zeros\n            const decimalAdjacentToLeadingZeros = sign ? // 0., -00., 000.\n                str[leadingZeros.length+1] === \".\" \n                : str[leadingZeros.length] === \".\";\n\n            //trim ending zeros for floating number\n            if(!options.leadingZeros //leading zeros are not allowed\n                && (leadingZeros.length > 1 \n                    || (leadingZeros.length === 1 && !decimalAdjacentToLeadingZeros))){\n                // 00, 00.3, +03.24, 03, 03.24\n                return str;\n            }\n            else{//no leading zeros or leading zeros are allowed\n                const num = Number(trimmedStr);\n                const parsedStr = String(num);\n\n                if( num === 0) return num;\n                if(parsedStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation\n                    if(options.eNotation) return num;\n                    else return str;\n                }else if(trimmedStr.indexOf(\".\") !== -1){ //floating number\n                    if(parsedStr === \"0\") return num; //0.0\n                    else if(parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000\n                    else if( parsedStr === `${sign}${numTrimmedByZeros}`) return num;\n                    else return str;\n                }\n                \n                let n = leadingZeros? numTrimmedByZeros : trimmedStr;\n                if(leadingZeros){\n                    // -009 => -9\n                    return (n === parsedStr) || (sign+n === parsedStr) ? num : str\n                }else  {\n                    // +9\n                    return (n === parsedStr) || (n === sign+parsedStr) ? num : str\n                }\n            }\n        }else{ //non-numeric string\n            return str;\n        }\n    }\n}\n\nconst eNotationRegx = /^([-+])?(0*)(\\d*(\\.\\d*)?[eE][-\\+]?\\d+)$/;\nfunction resolveEnotation(str,trimmedStr,options){\n    if(!options.eNotation) return str;\n    const notation = trimmedStr.match(eNotationRegx); \n    if(notation){\n        let sign = notation[1] || \"\";\n        const eChar = notation[3].indexOf(\"e\") === -1 ? \"E\" : \"e\";\n        const leadingZeros = notation[2];\n        const eAdjacentToLeadingZeros = sign ? // 0E.\n            str[leadingZeros.length+1] === eChar \n            : str[leadingZeros.length] === eChar;\n\n        if(leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;\n        else if(leadingZeros.length === 1 \n            && (notation[3].startsWith(`.${eChar}`) || notation[3][0] === eChar)){\n                return Number(trimmedStr);\n        }else if(options.leadingZeros && !eAdjacentToLeadingZeros){ //accept with leading zeros\n            //remove leading 0s\n            trimmedStr = (notation[1] || \"\") + notation[3];\n            return Number(trimmedStr);\n        }else return str;\n    }else{\n        return str;\n    }\n}\n\n/**\n * \n * @param {string} numStr without leading zeros\n * @returns \n */\nfunction trimZeros(numStr){\n    if(numStr && numStr.indexOf(\".\") !== -1){//float\n        numStr = numStr.replace(/0+$/, \"\"); //remove ending zeros\n        if(numStr === \".\")  numStr = \"0\";\n        else if(numStr[0] === \".\")  numStr = \"0\"+numStr;\n        else if(numStr[numStr.length-1] === \".\")  numStr = numStr.substring(0,numStr.length-1);\n        return numStr;\n    }\n    return numStr;\n}\n\nfunction parse_int(numStr, base){\n    //polyfill\n    if(parseInt) return parseInt(numStr, base);\n    else if(Number.parseInt) return Number.parseInt(numStr, base);\n    else if(window && window.parseInt) return window.parseInt(numStr, base);\n    else throw new Error(\"parseInt, Number.parseInt, window.parseInt are not supported\")\n}","/**\n * Matcher - Tracks current path in XML/JSON tree and matches against Expressions\n * \n * The matcher maintains a stack of nodes representing the current path from root to\n * current tag. It only stores attribute values for the current (top) node to minimize\n * memory usage. Sibling tracking is used to auto-calculate position and counter.\n * \n * @example\n * const matcher = new Matcher();\n * matcher.push(\"root\", {});\n * matcher.push(\"users\", {});\n * matcher.push(\"user\", { id: \"123\", type: \"admin\" });\n * \n * const expr = new Expression(\"root.users.user\");\n * matcher.matches(expr); // true\n */\nexport default class Matcher {\n  /**\n   * Create a new Matcher\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Default path separator (default: '.')\n   */\n  constructor(options = {}) {\n    this.separator = options.separator || '.';\n    this.path = [];\n    this.siblingStacks = [];\n    // Each path node: { tag: string, values: object, position: number, counter: number }\n    // values only present for current (last) node\n    // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n  }\n\n  /**\n   * Push a new tag onto the path\n   * @param {string} tagName - Name of the tag\n   * @param {Object} attrValues - Attribute key-value pairs for current node (optional)\n   * @param {string} namespace - Namespace for the tag (optional)\n   */\n  push(tagName, attrValues = null, namespace = null) {\n    // Remove values from previous current node (now becoming ancestor)\n    if (this.path.length > 0) {\n      const prev = this.path[this.path.length - 1];\n      prev.values = undefined;\n    }\n\n    // Get or create sibling tracking for current level\n    const currentLevel = this.path.length;\n    if (!this.siblingStacks[currentLevel]) {\n      this.siblingStacks[currentLevel] = new Map();\n    }\n\n    const siblings = this.siblingStacks[currentLevel];\n\n    // Create a unique key for sibling tracking that includes namespace\n    const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;\n\n    // Calculate counter (how many times this tag appeared at this level)\n    const counter = siblings.get(siblingKey) || 0;\n\n    // Calculate position (total children at this level so far)\n    let position = 0;\n    for (const count of siblings.values()) {\n      position += count;\n    }\n\n    // Update sibling count for this tag\n    siblings.set(siblingKey, counter + 1);\n\n    // Create new node\n    const node = {\n      tag: tagName,\n      position: position,\n      counter: counter\n    };\n\n    // Store namespace if provided\n    if (namespace !== null && namespace !== undefined) {\n      node.namespace = namespace;\n    }\n\n    // Store values only for current node\n    if (attrValues !== null && attrValues !== undefined) {\n      node.values = attrValues;\n    }\n\n    this.path.push(node);\n  }\n\n  /**\n   * Pop the last tag from the path\n   * @returns {Object|undefined} The popped node\n   */\n  pop() {\n    if (this.path.length === 0) {\n      return undefined;\n    }\n\n    const node = this.path.pop();\n\n    // Clean up sibling tracking for levels deeper than current\n    // After pop, path.length is the new depth\n    // We need to clean up siblingStacks[path.length + 1] and beyond\n    if (this.siblingStacks.length > this.path.length + 1) {\n      this.siblingStacks.length = this.path.length + 1;\n    }\n\n    return node;\n  }\n\n  /**\n   * Update current node's attribute values\n   * Useful when attributes are parsed after push\n   * @param {Object} attrValues - Attribute values\n   */\n  updateCurrent(attrValues) {\n    if (this.path.length > 0) {\n      const current = this.path[this.path.length - 1];\n      if (attrValues !== null && attrValues !== undefined) {\n        current.values = attrValues;\n      }\n    }\n  }\n\n  /**\n   * Get current tag name\n   * @returns {string|undefined}\n   */\n  getCurrentTag() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;\n  }\n\n  /**\n   * Get current namespace\n   * @returns {string|undefined}\n   */\n  getCurrentNamespace() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;\n  }\n\n  /**\n   * Get current node's attribute value\n   * @param {string} attrName - Attribute name\n   * @returns {*} Attribute value or undefined\n   */\n  getAttrValue(attrName) {\n    if (this.path.length === 0) return undefined;\n    const current = this.path[this.path.length - 1];\n    return current.values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute\n   * @param {string} attrName - Attribute name\n   * @returns {boolean}\n   */\n  hasAttr(attrName) {\n    if (this.path.length === 0) return false;\n    const current = this.path[this.path.length - 1];\n    return current.values !== undefined && attrName in current.values;\n  }\n\n  /**\n   * Get current node's sibling position (child index in parent)\n   * @returns {number}\n   */\n  getPosition() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].position ?? 0;\n  }\n\n  /**\n   * Get current node's repeat counter (occurrence count of this tag name)\n   * @returns {number}\n   */\n  getCounter() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].counter ?? 0;\n  }\n\n  /**\n   * Get current node's sibling index (alias for getPosition for backward compatibility)\n   * @returns {number}\n   * @deprecated Use getPosition() or getCounter() instead\n   */\n  getIndex() {\n    return this.getPosition();\n  }\n\n  /**\n   * Get current path depth\n   * @returns {number}\n   */\n  getDepth() {\n    return this.path.length;\n  }\n\n  /**\n   * Get path as string\n   * @param {string} separator - Optional separator (uses default if not provided)\n   * @param {boolean} includeNamespace - Whether to include namespace in output (default: true)\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    const sep = separator || this.separator;\n    return this.path.map(n => {\n      if (includeNamespace && n.namespace) {\n        return `${n.namespace}:${n.tag}`;\n      }\n      return n.tag;\n    }).join(sep);\n  }\n\n  /**\n   * Get path as array of tag names\n   * @returns {string[]}\n   */\n  toArray() {\n    return this.path.map(n => n.tag);\n  }\n\n  /**\n   * Reset the path to empty\n   */\n  reset() {\n    this.path = [];\n    this.siblingStacks = [];\n  }\n\n  /**\n   * Match current path against an Expression\n   * @param {Expression} expression - The expression to match against\n   * @returns {boolean} True if current path matches the expression\n   */\n  matches(expression) {\n    const segments = expression.segments;\n\n    if (segments.length === 0) {\n      return false;\n    }\n\n    // Handle deep wildcard patterns\n    if (expression.hasDeepWildcard()) {\n      return this._matchWithDeepWildcard(segments);\n    }\n\n    // Simple path matching (no deep wildcards)\n    return this._matchSimple(segments);\n  }\n\n  /**\n   * Match simple path (no deep wildcards)\n   * @private\n   */\n  _matchSimple(segments) {\n    // Path must be same length as segments\n    if (this.path.length !== segments.length) {\n      return false;\n    }\n\n    // Match each segment bottom-to-top\n    for (let i = 0; i < segments.length; i++) {\n      const segment = segments[i];\n      const node = this.path[i];\n      const isCurrentNode = (i === this.path.length - 1);\n\n      if (!this._matchSegment(segment, node, isCurrentNode)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Match path with deep wildcards\n   * @private\n   */\n  _matchWithDeepWildcard(segments) {\n    let pathIdx = this.path.length - 1;  // Start from current node (bottom)\n    let segIdx = segments.length - 1;     // Start from last segment\n\n    while (segIdx >= 0 && pathIdx >= 0) {\n      const segment = segments[segIdx];\n\n      if (segment.type === 'deep-wildcard') {\n        // \"..\" matches zero or more levels\n        segIdx--;\n\n        if (segIdx < 0) {\n          // Pattern ends with \"..\", always matches\n          return true;\n        }\n\n        // Find where next segment matches in the path\n        const nextSeg = segments[segIdx];\n        let found = false;\n\n        for (let i = pathIdx; i >= 0; i--) {\n          const isCurrentNode = (i === this.path.length - 1);\n          if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {\n            pathIdx = i - 1;\n            segIdx--;\n            found = true;\n            break;\n          }\n        }\n\n        if (!found) {\n          return false;\n        }\n      } else {\n        // Regular segment\n        const isCurrentNode = (pathIdx === this.path.length - 1);\n        if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {\n          return false;\n        }\n        pathIdx--;\n        segIdx--;\n      }\n    }\n\n    // All segments must be consumed\n    return segIdx < 0;\n  }\n\n  /**\n   * Match a single segment against a node\n   * @private\n   * @param {Object} segment - Segment from Expression\n   * @param {Object} node - Node from path\n   * @param {boolean} isCurrentNode - Whether this is the current (last) node\n   * @returns {boolean}\n   */\n  _matchSegment(segment, node, isCurrentNode) {\n    // Match tag name (* is wildcard)\n    if (segment.tag !== '*' && segment.tag !== node.tag) {\n      return false;\n    }\n\n    // Match namespace if specified in segment\n    if (segment.namespace !== undefined) {\n      // Segment has namespace - node must match it\n      if (segment.namespace !== '*' && segment.namespace !== node.namespace) {\n        return false;\n      }\n    }\n    // If segment has no namespace, it matches nodes with or without namespace\n\n    // Match attribute name (check if node has this attribute)\n    // Can only check for current node since ancestors don't have values\n    if (segment.attrName !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check attributes for ancestor nodes (values not stored)\n        return false;\n      }\n\n      if (!node.values || !(segment.attrName in node.values)) {\n        return false;\n      }\n\n      // Match attribute value (only possible for current node)\n      if (segment.attrValue !== undefined) {\n        const actualValue = node.values[segment.attrName];\n        // Both should be strings\n        if (String(actualValue) !== String(segment.attrValue)) {\n          return false;\n        }\n      }\n    }\n\n    // Match position (only for current node)\n    if (segment.position !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check position for ancestor nodes\n        return false;\n      }\n\n      const counter = node.counter ?? 0;\n\n      if (segment.position === 'first' && counter !== 0) {\n        return false;\n      } else if (segment.position === 'odd' && counter % 2 !== 1) {\n        return false;\n      } else if (segment.position === 'even' && counter % 2 !== 0) {\n        return false;\n      } else if (segment.position === 'nth') {\n        if (counter !== segment.positionValue) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Create a snapshot of current state\n   * @returns {Object} State snapshot\n   */\n  snapshot() {\n    return {\n      path: this.path.map(node => ({ ...node })),\n      siblingStacks: this.siblingStacks.map(map => new Map(map))\n    };\n  }\n\n  /**\n   * Restore state from snapshot\n   * @param {Object} snapshot - State snapshot\n   */\n  restore(snapshot) {\n    this.path = snapshot.path.map(node => ({ ...node }));\n    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));\n  }\n}","/**\n * Expression - Parses and stores a tag pattern expression\n * \n * Patterns are parsed once and stored in an optimized structure for fast matching.\n * \n * @example\n * const expr = new Expression(\"root.users.user\");\n * const expr2 = new Expression(\"..user[id]:first\");\n * const expr3 = new Expression(\"root/users/user\", { separator: '/' });\n */\nexport default class Expression {\n  /**\n   * Create a new Expression\n   * @param {string} pattern - Pattern string (e.g., \"root.users.user\", \"..user[id]\")\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Path separator (default: '.')\n   */\n  constructor(pattern, options = {}) {\n    this.pattern = pattern;\n    this.separator = options.separator || '.';\n    this.segments = this._parse(pattern);\n\n    // Cache expensive checks for performance (O(1) instead of O(n))\n    this._hasDeepWildcard = this.segments.some(seg => seg.type === 'deep-wildcard');\n    this._hasAttributeCondition = this.segments.some(seg => seg.attrName !== undefined);\n    this._hasPositionSelector = this.segments.some(seg => seg.position !== undefined);\n  }\n\n  /**\n   * Parse pattern string into segments\n   * @private\n   * @param {string} pattern - Pattern to parse\n   * @returns {Array} Array of segment objects\n   */\n  _parse(pattern) {\n    const segments = [];\n\n    // Split by separator but handle \"..\" specially\n    let i = 0;\n    let currentPart = '';\n\n    while (i < pattern.length) {\n      if (pattern[i] === this.separator) {\n        // Check if next char is also separator (deep wildcard)\n        if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {\n          // Flush current part if any\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n            currentPart = '';\n          }\n          // Add deep wildcard\n          segments.push({ type: 'deep-wildcard' });\n          i += 2; // Skip both separators\n        } else {\n          // Regular separator\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n          }\n          currentPart = '';\n          i++;\n        }\n      } else {\n        currentPart += pattern[i];\n        i++;\n      }\n    }\n\n    // Flush remaining part\n    if (currentPart.trim()) {\n      segments.push(this._parseSegment(currentPart.trim()));\n    }\n\n    return segments;\n  }\n\n  /**\n   * Parse a single segment\n   * @private\n   * @param {string} part - Segment string (e.g., \"user\", \"ns::user\", \"user[id]\", \"ns::user:first\")\n   * @returns {Object} Segment object\n   */\n  _parseSegment(part) {\n    const segment = { type: 'tag' };\n\n    // NEW NAMESPACE SYNTAX (v2.0):\n    // ============================\n    // Namespace uses DOUBLE colon (::)\n    // Position uses SINGLE colon (:)\n    // \n    // Examples:\n    //   \"user\"              → tag\n    //   \"user:first\"        → tag + position\n    //   \"user[id]\"          → tag + attribute\n    //   \"user[id]:first\"    → tag + attribute + position\n    //   \"ns::user\"          → namespace + tag\n    //   \"ns::user:first\"    → namespace + tag + position\n    //   \"ns::user[id]\"      → namespace + tag + attribute\n    //   \"ns::user[id]:first\" → namespace + tag + attribute + position\n    //   \"ns::first\"         → namespace + tag named \"first\" (NO ambiguity!)\n    //\n    // This eliminates all ambiguity:\n    //   :: = namespace separator\n    //   :  = position selector\n    //   [] = attributes\n\n    // Step 1: Extract brackets [attr] or [attr=value]\n    let bracketContent = null;\n    let withoutBrackets = part;\n\n    const bracketMatch = part.match(/^([^\\[]+)(\\[[^\\]]*\\])(.*)$/);\n    if (bracketMatch) {\n      withoutBrackets = bracketMatch[1] + bracketMatch[3];\n      if (bracketMatch[2]) {\n        const content = bracketMatch[2].slice(1, -1);\n        if (content) {\n          bracketContent = content;\n        }\n      }\n    }\n\n    // Step 2: Check for namespace (double colon ::)\n    let namespace = undefined;\n    let tagAndPosition = withoutBrackets;\n\n    if (withoutBrackets.includes('::')) {\n      const nsIndex = withoutBrackets.indexOf('::');\n      namespace = withoutBrackets.substring(0, nsIndex).trim();\n      tagAndPosition = withoutBrackets.substring(nsIndex + 2).trim(); // Skip ::\n\n      if (!namespace) {\n        throw new Error(`Invalid namespace in pattern: ${part}`);\n      }\n    }\n\n    // Step 3: Parse tag and position (single colon :)\n    let tag = undefined;\n    let positionMatch = null;\n\n    if (tagAndPosition.includes(':')) {\n      const colonIndex = tagAndPosition.lastIndexOf(':'); // Use last colon for position\n      const tagPart = tagAndPosition.substring(0, colonIndex).trim();\n      const posPart = tagAndPosition.substring(colonIndex + 1).trim();\n\n      // Verify position is a valid keyword\n      const isPositionKeyword = ['first', 'last', 'odd', 'even'].includes(posPart) ||\n        /^nth\\(\\d+\\)$/.test(posPart);\n\n      if (isPositionKeyword) {\n        tag = tagPart;\n        positionMatch = posPart;\n      } else {\n        // Not a valid position keyword, treat whole thing as tag\n        tag = tagAndPosition;\n      }\n    } else {\n      tag = tagAndPosition;\n    }\n\n    if (!tag) {\n      throw new Error(`Invalid segment pattern: ${part}`);\n    }\n\n    segment.tag = tag;\n    if (namespace) {\n      segment.namespace = namespace;\n    }\n\n    // Step 4: Parse attributes\n    if (bracketContent) {\n      if (bracketContent.includes('=')) {\n        const eqIndex = bracketContent.indexOf('=');\n        segment.attrName = bracketContent.substring(0, eqIndex).trim();\n        segment.attrValue = bracketContent.substring(eqIndex + 1).trim();\n      } else {\n        segment.attrName = bracketContent.trim();\n      }\n    }\n\n    // Step 5: Parse position selector\n    if (positionMatch) {\n      const nthMatch = positionMatch.match(/^nth\\((\\d+)\\)$/);\n      if (nthMatch) {\n        segment.position = 'nth';\n        segment.positionValue = parseInt(nthMatch[1], 10);\n      } else {\n        segment.position = positionMatch;\n      }\n    }\n\n    return segment;\n  }\n\n  /**\n   * Get the number of segments\n   * @returns {number}\n   */\n  get length() {\n    return this.segments.length;\n  }\n\n  /**\n   * Check if expression contains deep wildcard\n   * @returns {boolean}\n   */\n  hasDeepWildcard() {\n    return this._hasDeepWildcard;\n  }\n\n  /**\n   * Check if expression has attribute conditions\n   * @returns {boolean}\n   */\n  hasAttributeCondition() {\n    return this._hasAttributeCondition;\n  }\n\n  /**\n   * Check if expression has position selectors\n   * @returns {boolean}\n   */\n  hasPositionSelector() {\n    return this._hasPositionSelector;\n  }\n\n  /**\n   * Get string representation\n   * @returns {string}\n   */\n  toString() {\n    return this.pattern;\n  }\n}","'use strict';\n///@ts-check\n\nimport { getAllMatches, isExist, DANGEROUS_PROPERTY_NAMES, criticalProperties } from '../util.js';\nimport xmlNode from './xmlNode.js';\nimport DocTypeReader from './DocTypeReader.js';\nimport toNumber from \"strnum\";\nimport getIgnoreAttributesFn from \"../ignoreAttributes.js\";\nimport { Expression, Matcher } from 'path-expression-matcher';\n\n// const regx =\n//   '<((!\\\\[CDATA\\\\[([\\\\s\\\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\\\/)(NAME)\\\\s*>))([^<]*)'\n//   .replace(/NAME/g, util.nameRegexp);\n\n//const tagsRegx = new RegExp(\"<(\\\\/?[\\\\w:\\\\-\\._]+)([^>]*)>(\\\\s*\"+cdataRegx+\")*([^<]+)?\",\"g\");\n//const tagsRegx = new RegExp(\"<(\\\\/?)((\\\\w*:)?([\\\\w:\\\\-\\._]+))([^>]*)>([^<]*)(\"+cdataRegx+\"([^<]*))*([^<]+)?\",\"g\");\n\n// Helper functions for attribute and namespace handling\n\n/**\n * Extract raw attributes (without prefix) from prefixed attribute map\n * @param {object} prefixedAttrs - Attributes with prefix from buildAttributesMap\n * @param {object} options - Parser options containing attributeNamePrefix\n * @returns {object} Raw attributes for matcher\n */\nfunction extractRawAttributes(prefixedAttrs, options) {\n  if (!prefixedAttrs) return {};\n\n  // Handle attributesGroupName option\n  const attrs = options.attributesGroupName\n    ? prefixedAttrs[options.attributesGroupName]\n    : prefixedAttrs;\n\n  if (!attrs) return {};\n\n  const rawAttrs = {};\n  for (const key in attrs) {\n    // Remove the attribute prefix to get raw name\n    if (key.startsWith(options.attributeNamePrefix)) {\n      const rawName = key.substring(options.attributeNamePrefix.length);\n      rawAttrs[rawName] = attrs[key];\n    } else {\n      // Attribute without prefix (shouldn't normally happen, but be safe)\n      rawAttrs[key] = attrs[key];\n    }\n  }\n  return rawAttrs;\n}\n\n/**\n * Extract namespace from raw tag name\n * @param {string} rawTagName - Tag name possibly with namespace (e.g., \"soap:Envelope\")\n * @returns {string|undefined} Namespace or undefined\n */\nfunction extractNamespace(rawTagName) {\n  if (!rawTagName || typeof rawTagName !== 'string') return undefined;\n\n  const colonIndex = rawTagName.indexOf(':');\n  if (colonIndex !== -1 && colonIndex > 0) {\n    const ns = rawTagName.substring(0, colonIndex);\n    // Don't treat xmlns as a namespace\n    if (ns !== 'xmlns') {\n      return ns;\n    }\n  }\n  return undefined;\n}\n\nexport default class OrderedObjParser {\n  constructor(options) {\n    this.options = options;\n    this.currentNode = null;\n    this.tagsNodeStack = [];\n    this.docTypeEntities = {};\n    this.lastEntities = {\n      \"apos\": { regex: /&(apos|#39|#x27);/g, val: \"'\" },\n      \"gt\": { regex: /&(gt|#62|#x3E);/g, val: \">\" },\n      \"lt\": { regex: /&(lt|#60|#x3C);/g, val: \"<\" },\n      \"quot\": { regex: /&(quot|#34|#x22);/g, val: \"\\\"\" },\n    };\n    this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: \"&\" };\n    this.htmlEntities = {\n      \"space\": { regex: /&(nbsp|#160);/g, val: \" \" },\n      // \"lt\" : { regex: /&(lt|#60);/g, val: \"<\" },\n      // \"gt\" : { regex: /&(gt|#62);/g, val: \">\" },\n      // \"amp\" : { regex: /&(amp|#38);/g, val: \"&\" },\n      // \"quot\" : { regex: /&(quot|#34);/g, val: \"\\\"\" },\n      // \"apos\" : { regex: /&(apos|#39);/g, val: \"'\" },\n      \"cent\": { regex: /&(cent|#162);/g, val: \"¢\" },\n      \"pound\": { regex: /&(pound|#163);/g, val: \"£\" },\n      \"yen\": { regex: /&(yen|#165);/g, val: \"¥\" },\n      \"euro\": { regex: /&(euro|#8364);/g, val: \"€\" },\n      \"copyright\": { regex: /&(copy|#169);/g, val: \"©\" },\n      \"reg\": { regex: /&(reg|#174);/g, val: \"®\" },\n      \"inr\": { regex: /&(inr|#8377);/g, val: \"₹\" },\n      \"num_dec\": { regex: /&#([0-9]{1,7});/g, val: (_, str) => fromCodePoint(str, 10, \"&#\") },\n      \"num_hex\": { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => fromCodePoint(str, 16, \"&#x\") },\n    };\n    this.addExternalEntities = addExternalEntities;\n    this.parseXml = parseXml;\n    this.parseTextData = parseTextData;\n    this.resolveNameSpace = resolveNameSpace;\n    this.buildAttributesMap = buildAttributesMap;\n    this.isItStopNode = isItStopNode;\n    this.replaceEntitiesValue = replaceEntitiesValue;\n    this.readStopNodeData = readStopNodeData;\n    this.saveTextToParentTag = saveTextToParentTag;\n    this.addChild = addChild;\n    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)\n    this.entityExpansionCount = 0;\n    this.currentExpandedLength = 0;\n\n    // Initialize path matcher for path-expression-matcher\n    this.matcher = new Matcher();\n\n    // Flag to track if current node is a stop node (optimization)\n    this.isCurrentNodeStopNode = false;\n\n    // Pre-compile stopNodes expressions\n    if (this.options.stopNodes && this.options.stopNodes.length > 0) {\n      this.stopNodeExpressions = [];\n      for (let i = 0; i < this.options.stopNodes.length; i++) {\n        const stopNodeExp = this.options.stopNodes[i];\n        if (typeof stopNodeExp === 'string') {\n          // Convert string to Expression object\n          this.stopNodeExpressions.push(new Expression(stopNodeExp));\n        } else if (stopNodeExp instanceof Expression) {\n          // Already an Expression object\n          this.stopNodeExpressions.push(stopNodeExp);\n        }\n      }\n    }\n  }\n\n}\n\nfunction addExternalEntities(externalEntities) {\n  const entKeys = Object.keys(externalEntities);\n  for (let i = 0; i < entKeys.length; i++) {\n    const ent = entKeys[i];\n    const escaped = ent.replace(/[.\\-+*:]/g, '\\\\.');\n    this.lastEntities[ent] = {\n      regex: new RegExp(\"&\" + escaped + \";\", \"g\"),\n      val: externalEntities[ent]\n    }\n  }\n}\n\n/**\n * @param {string} val\n * @param {string} tagName\n * @param {string|Matcher} jPath - jPath string or Matcher instance based on options.jPath\n * @param {boolean} dontTrim\n * @param {boolean} hasAttributes\n * @param {boolean} isLeafNode\n * @param {boolean} escapeEntities\n */\nfunction parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {\n  if (val !== undefined) {\n    if (this.options.trimValues && !dontTrim) {\n      val = val.trim();\n    }\n    if (val.length > 0) {\n      if (!escapeEntities) val = this.replaceEntitiesValue(val, tagName, jPath);\n\n      // Pass jPath string or matcher based on options.jPath setting\n      const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;\n      const newval = this.options.tagValueProcessor(tagName, val, jPathOrMatcher, hasAttributes, isLeafNode);\n      if (newval === null || newval === undefined) {\n        //don't parse\n        return val;\n      } else if (typeof newval !== typeof val || newval !== val) {\n        //overwrite\n        return newval;\n      } else if (this.options.trimValues) {\n        return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);\n      } else {\n        const trimmedVal = val.trim();\n        if (trimmedVal === val) {\n          return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions);\n        } else {\n          return val;\n        }\n      }\n    }\n  }\n}\n\nfunction resolveNameSpace(tagname) {\n  if (this.options.removeNSPrefix) {\n    const tags = tagname.split(':');\n    const prefix = tagname.charAt(0) === '/' ? '/' : '';\n    if (tags[0] === 'xmlns') {\n      return '';\n    }\n    if (tags.length === 2) {\n      tagname = prefix + tags[1];\n    }\n  }\n  return tagname;\n}\n\n//TODO: change regex to capture NS\n//const attrsRegx = new RegExp(\"([\\\\w\\\\-\\\\.\\\\:]+)\\\\s*=\\\\s*(['\\\"])((.|\\n)*?)\\\\2\",\"gm\");\nconst attrsRegx = new RegExp('([^\\\\s=]+)\\\\s*(=\\\\s*([\\'\"])([\\\\s\\\\S]*?)\\\\3)?', 'gm');\n\nfunction buildAttributesMap(attrStr, jPath, tagName) {\n  if (this.options.ignoreAttributes !== true && typeof attrStr === 'string') {\n    // attrStr = attrStr.replace(/\\r?\\n/g, ' ');\n    //attrStr = attrStr || attrStr.trim();\n\n    const matches = getAllMatches(attrStr, attrsRegx);\n    const len = matches.length; //don't make it inline\n    const attrs = {};\n\n    // First pass: parse all attributes and update matcher with raw values\n    // This ensures the matcher has all attribute values when processors run\n    const rawAttrsForMatcher = {};\n    for (let i = 0; i < len; i++) {\n      const attrName = this.resolveNameSpace(matches[i][1]);\n      const oldVal = matches[i][4];\n\n      if (attrName.length && oldVal !== undefined) {\n        let parsedVal = oldVal;\n        if (this.options.trimValues) {\n          parsedVal = parsedVal.trim();\n        }\n        parsedVal = this.replaceEntitiesValue(parsedVal, tagName, jPath);\n        rawAttrsForMatcher[attrName] = parsedVal;\n      }\n    }\n\n    // Update matcher with raw attribute values BEFORE running processors\n    if (Object.keys(rawAttrsForMatcher).length > 0 && typeof jPath === 'object' && jPath.updateCurrent) {\n      jPath.updateCurrent(rawAttrsForMatcher);\n    }\n\n    // Second pass: now process attributes with matcher having full attribute context\n    for (let i = 0; i < len; i++) {\n      const attrName = this.resolveNameSpace(matches[i][1]);\n\n      // Convert jPath to string if needed for ignoreAttributesFn\n      const jPathStr = this.options.jPath ? jPath.toString() : jPath;\n      if (this.ignoreAttributesFn(attrName, jPathStr)) {\n        continue\n      }\n\n      let oldVal = matches[i][4];\n      let aName = this.options.attributeNamePrefix + attrName;\n\n      if (attrName.length) {\n        if (this.options.transformAttributeName) {\n          aName = this.options.transformAttributeName(aName);\n        }\n        //if (aName === \"__proto__\") aName = \"#__proto__\";\n        aName = sanitizeName(aName, this.options);\n\n        if (oldVal !== undefined) {\n          if (this.options.trimValues) {\n            oldVal = oldVal.trim();\n          }\n          oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);\n\n          // Pass jPath string or matcher based on options.jPath setting\n          const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;\n          const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPathOrMatcher);\n          if (newVal === null || newVal === undefined) {\n            //don't parse\n            attrs[aName] = oldVal;\n          } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {\n            //overwrite\n            attrs[aName] = newVal;\n          } else {\n            //parse\n            attrs[aName] = parseValue(\n              oldVal,\n              this.options.parseAttributeValue,\n              this.options.numberParseOptions\n            );\n          }\n        } else if (this.options.allowBooleanAttributes) {\n          attrs[aName] = true;\n        }\n      }\n    }\n\n    if (!Object.keys(attrs).length) {\n      return;\n    }\n    if (this.options.attributesGroupName) {\n      const attrCollection = {};\n      attrCollection[this.options.attributesGroupName] = attrs;\n      return attrCollection;\n    }\n    return attrs\n  }\n}\n\nconst parseXml = function (xmlData) {\n  xmlData = xmlData.replace(/\\r\\n?/g, \"\\n\"); //TODO: remove this line\n  const xmlObj = new xmlNode('!xml');\n  let currentNode = xmlObj;\n  let textData = \"\";\n\n  // Reset matcher for new document\n  this.matcher.reset();\n\n  // Reset entity expansion counters for this document\n  this.entityExpansionCount = 0;\n  this.currentExpandedLength = 0;\n\n  const docTypeReader = new DocTypeReader(this.options.processEntities);\n  for (let i = 0; i < xmlData.length; i++) {//for each char in XML data\n    const ch = xmlData[i];\n    if (ch === '<') {\n      // const nextIndex = i+1;\n      // const _2ndChar = xmlData[nextIndex];\n      if (xmlData[i + 1] === '/') {//Closing Tag\n        const closeIndex = findClosingIndex(xmlData, \">\", i, \"Closing Tag is not closed.\")\n        let tagName = xmlData.substring(i + 2, closeIndex).trim();\n\n        if (this.options.removeNSPrefix) {\n          const colonIndex = tagName.indexOf(\":\");\n          if (colonIndex !== -1) {\n            tagName = tagName.substr(colonIndex + 1);\n          }\n        }\n\n        tagName = transformTagName(this.options.transformTagName, tagName, \"\", this.options).tagName;\n\n        if (currentNode) {\n          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);\n        }\n\n        //check if last tag of nested tag was unpaired tag\n        const lastTagName = this.matcher.getCurrentTag();\n        if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {\n          throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);\n        }\n        if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {\n          // Pop the unpaired tag\n          this.matcher.pop();\n          this.tagsNodeStack.pop();\n        }\n        // Pop the closing tag\n        this.matcher.pop();\n        this.isCurrentNodeStopNode = false; // Reset flag when closing tag\n\n        currentNode = this.tagsNodeStack.pop();//avoid recursion, set the parent tag scope\n        textData = \"\";\n        i = closeIndex;\n      } else if (xmlData[i + 1] === '?') {\n\n        let tagData = readTagExp(xmlData, i, false, \"?>\");\n        if (!tagData) throw new Error(\"Pi Tag is not closed.\");\n\n        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);\n        if ((this.options.ignoreDeclaration && tagData.tagName === \"?xml\") || this.options.ignorePiTags) {\n          //do nothing\n        } else {\n\n          const childNode = new xmlNode(tagData.tagName);\n          childNode.add(this.options.textNodeName, \"\");\n\n          if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {\n            childNode[\":@\"] = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName);\n          }\n          this.addChild(currentNode, childNode, this.matcher, i);\n        }\n\n\n        i = tagData.closeIndex + 1;\n      } else if (xmlData.substr(i + 1, 3) === '!--') {\n        const endIndex = findClosingIndex(xmlData, \"-->\", i + 4, \"Comment is not closed.\")\n        if (this.options.commentPropName) {\n          const comment = xmlData.substring(i + 4, endIndex - 2);\n\n          textData = this.saveTextToParentTag(textData, currentNode, this.matcher);\n\n          currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);\n        }\n        i = endIndex;\n      } else if (xmlData.substr(i + 1, 2) === '!D') {\n        const result = docTypeReader.readDocType(xmlData, i);\n        this.docTypeEntities = result.entities;\n        i = result.i;\n      } else if (xmlData.substr(i + 1, 2) === '![') {\n        const closeIndex = findClosingIndex(xmlData, \"]]>\", i, \"CDATA is not closed.\") - 2;\n        const tagExp = xmlData.substring(i + 9, closeIndex);\n\n        textData = this.saveTextToParentTag(textData, currentNode, this.matcher);\n\n        let val = this.parseTextData(tagExp, currentNode.tagname, this.matcher, true, false, true, true);\n        if (val == undefined) val = \"\";\n\n        //cdata should be set even if it is 0 length string\n        if (this.options.cdataPropName) {\n          currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);\n        } else {\n          currentNode.add(this.options.textNodeName, val);\n        }\n\n        i = closeIndex + 2;\n      } else {//Opening tag\n        let result = readTagExp(xmlData, i, this.options.removeNSPrefix);\n\n        // Safety check: readTagExp can return undefined\n        if (!result) {\n          // Log context for debugging\n          const context = xmlData.substring(Math.max(0, i - 50), Math.min(xmlData.length, i + 50));\n          throw new Error(`readTagExp returned undefined at position ${i}. Context: \"${context}\"`);\n        }\n\n        let tagName = result.tagName;\n        const rawTagName = result.rawTagName;\n        let tagExp = result.tagExp;\n        let attrExpPresent = result.attrExpPresent;\n        let closeIndex = result.closeIndex;\n\n        ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));\n\n        if (this.options.strictReservedNames &&\n          (tagName === this.options.commentPropName\n            || tagName === this.options.cdataPropName\n          )) {\n          throw new Error(`Invalid tag name: ${tagName}`);\n        }\n\n        //save text as child node\n        if (currentNode && textData) {\n          if (currentNode.tagname !== '!xml') {\n            //when nested tag is found\n            textData = this.saveTextToParentTag(textData, currentNode, this.matcher, false);\n          }\n        }\n\n        //check if last tag was unpaired tag\n        const lastTag = currentNode;\n        if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {\n          currentNode = this.tagsNodeStack.pop();\n          this.matcher.pop();\n        }\n\n        // Clean up self-closing syntax BEFORE processing attributes\n        // This is where tagExp gets the trailing / removed\n        let isSelfClosing = false;\n        if (tagExp.length > 0 && tagExp.lastIndexOf(\"/\") === tagExp.length - 1) {\n          isSelfClosing = true;\n          if (tagName[tagName.length - 1] === \"/\") {\n            tagName = tagName.substr(0, tagName.length - 1);\n            tagExp = tagName;\n          } else {\n            tagExp = tagExp.substr(0, tagExp.length - 1);\n          }\n\n          // Re-check attrExpPresent after cleaning\n          attrExpPresent = (tagName !== tagExp);\n        }\n\n        // Now process attributes with CLEAN tagExp (no trailing /)\n        let prefixedAttrs = null;\n        let rawAttrs = {};\n        let namespace = undefined;\n\n        // Extract namespace from rawTagName\n        namespace = extractNamespace(rawTagName);\n\n        // Push tag to matcher FIRST (with empty attrs for now) so callbacks see correct path\n        if (tagName !== xmlObj.tagname) {\n          this.matcher.push(tagName, {}, namespace);\n        }\n\n        // Now build attributes - callbacks will see correct matcher state\n        if (tagName !== tagExp && attrExpPresent) {\n          // Build attributes (returns prefixed attributes for the tree)\n          // Note: buildAttributesMap now internally updates the matcher with raw attributes\n          prefixedAttrs = this.buildAttributesMap(tagExp, this.matcher, tagName);\n\n          if (prefixedAttrs) {\n            // Extract raw attributes (without prefix) for our use\n            rawAttrs = extractRawAttributes(prefixedAttrs, this.options);\n          }\n        }\n\n        // Now check if this is a stop node (after attributes are set)\n        if (tagName !== xmlObj.tagname) {\n          this.isCurrentNodeStopNode = this.isItStopNode(this.stopNodeExpressions, this.matcher);\n        }\n\n        const startIndex = i;\n        if (this.isCurrentNodeStopNode) {\n          let tagContent = \"\";\n\n          // For self-closing tags, content is empty\n          if (isSelfClosing) {\n            i = result.closeIndex;\n          }\n          //unpaired tag\n          else if (this.options.unpairedTags.indexOf(tagName) !== -1) {\n            i = result.closeIndex;\n          }\n          //normal tag\n          else {\n            //read until closing tag is found\n            const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);\n            if (!result) throw new Error(`Unexpected end of ${rawTagName}`);\n            i = result.i;\n            tagContent = result.tagContent;\n          }\n\n          const childNode = new xmlNode(tagName);\n\n          if (prefixedAttrs) {\n            childNode[\":@\"] = prefixedAttrs;\n          }\n\n          // For stop nodes, store raw content as-is without any processing\n          childNode.add(this.options.textNodeName, tagContent);\n\n          this.matcher.pop(); // Pop the stop node tag\n          this.isCurrentNodeStopNode = false; // Reset flag\n\n          this.addChild(currentNode, childNode, this.matcher, startIndex);\n        } else {\n          //selfClosing tag\n          if (isSelfClosing) {\n            ({ tagName, tagExp } = transformTagName(this.options.transformTagName, tagName, tagExp, this.options));\n\n            const childNode = new xmlNode(tagName);\n            if (prefixedAttrs) {\n              childNode[\":@\"] = prefixedAttrs;\n            }\n            this.addChild(currentNode, childNode, this.matcher, startIndex);\n            this.matcher.pop(); // Pop self-closing tag\n            this.isCurrentNodeStopNode = false; // Reset flag\n          }\n          else if (this.options.unpairedTags.indexOf(tagName) !== -1) {//unpaired tag\n            const childNode = new xmlNode(tagName);\n            if (prefixedAttrs) {\n              childNode[\":@\"] = prefixedAttrs;\n            }\n            this.addChild(currentNode, childNode, this.matcher, startIndex);\n            this.matcher.pop(); // Pop unpaired tag\n            this.isCurrentNodeStopNode = false; // Reset flag\n            i = result.closeIndex;\n            // Continue to next iteration without changing currentNode\n            continue;\n          }\n          //opening tag\n          else {\n            const childNode = new xmlNode(tagName);\n            if (this.tagsNodeStack.length > this.options.maxNestedTags) {\n              throw new Error(\"Maximum nested tags exceeded\");\n            }\n            this.tagsNodeStack.push(currentNode);\n\n            if (prefixedAttrs) {\n              childNode[\":@\"] = prefixedAttrs;\n            }\n            this.addChild(currentNode, childNode, this.matcher, startIndex);\n            currentNode = childNode;\n          }\n          textData = \"\";\n          i = closeIndex;\n        }\n      }\n    } else {\n      textData += xmlData[i];\n    }\n  }\n  return xmlObj.child;\n}\n\nfunction addChild(currentNode, childNode, matcher, startIndex) {\n  // unset startIndex if not requested\n  if (!this.options.captureMetaData) startIndex = undefined;\n\n  // Pass jPath string or matcher based on options.jPath setting\n  const jPathOrMatcher = this.options.jPath ? matcher.toString() : matcher;\n  const result = this.options.updateTag(childNode.tagname, jPathOrMatcher, childNode[\":@\"])\n  if (result === false) {\n    //do nothing\n  } else if (typeof result === \"string\") {\n    childNode.tagname = result\n    currentNode.addChild(childNode, startIndex);\n  } else {\n    currentNode.addChild(childNode, startIndex);\n  }\n}\n\n/**\n * @param {object} val - Entity object with regex and val properties\n * @param {string} tagName - Tag name\n * @param {string|Matcher} jPath - jPath string or Matcher instance based on options.jPath\n */\nfunction replaceEntitiesValue(val, tagName, jPath) {\n  const entityConfig = this.options.processEntities;\n\n  if (!entityConfig || !entityConfig.enabled) {\n    return val;\n  }\n\n  // Check if tag is allowed to contain entities\n  if (entityConfig.allowedTags) {\n    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;\n    const allowed = Array.isArray(entityConfig.allowedTags)\n      ? entityConfig.allowedTags.includes(tagName)\n      : entityConfig.allowedTags(tagName, jPathOrMatcher);\n\n    if (!allowed) {\n      return val;\n    }\n  }\n\n  // Apply custom tag filter if provided\n  if (entityConfig.tagFilter) {\n    const jPathOrMatcher = this.options.jPath ? jPath.toString() : jPath;\n    if (!entityConfig.tagFilter(tagName, jPathOrMatcher)) {\n      return val; // Skip based on custom filter\n    }\n  }\n\n  // Replace DOCTYPE entities\n  for (let entityName in this.docTypeEntities) {\n    const entity = this.docTypeEntities[entityName];\n    const matches = val.match(entity.regx);\n\n    if (matches) {\n      // Track expansions\n      this.entityExpansionCount += matches.length;\n\n      // Check expansion limit\n      if (entityConfig.maxTotalExpansions &&\n        this.entityExpansionCount > entityConfig.maxTotalExpansions) {\n        throw new Error(\n          `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`\n        );\n      }\n\n      // Store length before replacement\n      const lengthBefore = val.length;\n      val = val.replace(entity.regx, entity.val);\n\n      // Check expanded length immediately after replacement\n      if (entityConfig.maxExpandedLength) {\n        this.currentExpandedLength += (val.length - lengthBefore);\n\n        if (this.currentExpandedLength > entityConfig.maxExpandedLength) {\n          throw new Error(\n            `Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`\n          );\n        }\n      }\n    }\n  }\n  if (val.indexOf('&') === -1) return val;  // Early exit\n\n  // Replace standard entities\n  for (let entityName in this.lastEntities) {\n    const entity = this.lastEntities[entityName];\n    val = val.replace(entity.regex, entity.val);\n  }\n  if (val.indexOf('&') === -1) return val;  // Early exit\n\n  // Replace HTML entities if enabled\n  if (this.options.htmlEntities) {\n    for (let entityName in this.htmlEntities) {\n      const entity = this.htmlEntities[entityName];\n      val = val.replace(entity.regex, entity.val);\n    }\n  }\n\n  // Replace ampersand entity last\n  val = val.replace(this.ampEntity.regex, this.ampEntity.val);\n\n  return val;\n}\n\n\nfunction saveTextToParentTag(textData, parentNode, matcher, isLeafNode) {\n  if (textData) { //store previously collected data as textNode\n    if (isLeafNode === undefined) isLeafNode = parentNode.child.length === 0\n\n    textData = this.parseTextData(textData,\n      parentNode.tagname,\n      matcher,\n      false,\n      parentNode[\":@\"] ? Object.keys(parentNode[\":@\"]).length !== 0 : false,\n      isLeafNode);\n\n    if (textData !== undefined && textData !== \"\")\n      parentNode.add(this.options.textNodeName, textData);\n    textData = \"\";\n  }\n  return textData;\n}\n\n//TODO: use jPath to simplify the logic\n/**\n * @param {Array<Expression>} stopNodeExpressions - Array of compiled Expression objects\n * @param {Matcher} matcher - Current path matcher\n */\nfunction isItStopNode(stopNodeExpressions, matcher) {\n  if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;\n\n  for (let i = 0; i < stopNodeExpressions.length; i++) {\n    if (matcher.matches(stopNodeExpressions[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Returns the tag Expression and where it is ending handling single-double quotes situation\n * @param {string} xmlData \n * @param {number} i starting index\n * @returns \n */\nfunction tagExpWithClosingIndex(xmlData, i, closingChar = \">\") {\n  let attrBoundary;\n  let tagExp = \"\";\n  for (let index = i; index < xmlData.length; index++) {\n    let ch = xmlData[index];\n    if (attrBoundary) {\n      if (ch === attrBoundary) attrBoundary = \"\";//reset\n    } else if (ch === '\"' || ch === \"'\") {\n      attrBoundary = ch;\n    } else if (ch === closingChar[0]) {\n      if (closingChar[1]) {\n        if (xmlData[index + 1] === closingChar[1]) {\n          return {\n            data: tagExp,\n            index: index\n          }\n        }\n      } else {\n        return {\n          data: tagExp,\n          index: index\n        }\n      }\n    } else if (ch === '\\t') {\n      ch = \" \"\n    }\n    tagExp += ch;\n  }\n}\n\nfunction findClosingIndex(xmlData, str, i, errMsg) {\n  const closingIndex = xmlData.indexOf(str, i);\n  if (closingIndex === -1) {\n    throw new Error(errMsg)\n  } else {\n    return closingIndex + str.length - 1;\n  }\n}\n\nfunction readTagExp(xmlData, i, removeNSPrefix, closingChar = \">\") {\n  const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);\n  if (!result) return;\n  let tagExp = result.data;\n  const closeIndex = result.index;\n  const separatorIndex = tagExp.search(/\\s/);\n  let tagName = tagExp;\n  let attrExpPresent = true;\n  if (separatorIndex !== -1) {//separate tag name and attributes expression\n    tagName = tagExp.substring(0, separatorIndex);\n    tagExp = tagExp.substring(separatorIndex + 1).trimStart();\n  }\n\n  const rawTagName = tagName;\n  if (removeNSPrefix) {\n    const colonIndex = tagName.indexOf(\":\");\n    if (colonIndex !== -1) {\n      tagName = tagName.substr(colonIndex + 1);\n      attrExpPresent = tagName !== result.data.substr(colonIndex + 1);\n    }\n  }\n\n  return {\n    tagName: tagName,\n    tagExp: tagExp,\n    closeIndex: closeIndex,\n    attrExpPresent: attrExpPresent,\n    rawTagName: rawTagName,\n  }\n}\n/**\n * find paired tag for a stop node\n * @param {string} xmlData \n * @param {string} tagName \n * @param {number} i \n */\nfunction readStopNodeData(xmlData, tagName, i) {\n  const startIndex = i;\n  // Starting at 1 since we already have an open tag\n  let openTagCount = 1;\n\n  for (; i < xmlData.length; i++) {\n    if (xmlData[i] === \"<\") {\n      if (xmlData[i + 1] === \"/\") {//close tag\n        const closeIndex = findClosingIndex(xmlData, \">\", i, `${tagName} is not closed`);\n        let closeTagName = xmlData.substring(i + 2, closeIndex).trim();\n        if (closeTagName === tagName) {\n          openTagCount--;\n          if (openTagCount === 0) {\n            return {\n              tagContent: xmlData.substring(startIndex, i),\n              i: closeIndex\n            }\n          }\n        }\n        i = closeIndex;\n      } else if (xmlData[i + 1] === '?') {\n        const closeIndex = findClosingIndex(xmlData, \"?>\", i + 1, \"StopNode is not closed.\")\n        i = closeIndex;\n      } else if (xmlData.substr(i + 1, 3) === '!--') {\n        const closeIndex = findClosingIndex(xmlData, \"-->\", i + 3, \"StopNode is not closed.\")\n        i = closeIndex;\n      } else if (xmlData.substr(i + 1, 2) === '![') {\n        const closeIndex = findClosingIndex(xmlData, \"]]>\", i, \"StopNode is not closed.\") - 2;\n        i = closeIndex;\n      } else {\n        const tagData = readTagExp(xmlData, i, '>')\n\n        if (tagData) {\n          const openTagName = tagData && tagData.tagName;\n          if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== \"/\") {\n            openTagCount++;\n          }\n          i = tagData.closeIndex;\n        }\n      }\n    }\n  }//end for loop\n}\n\nfunction parseValue(val, shouldParse, options) {\n  if (shouldParse && typeof val === 'string') {\n    //console.log(options)\n    const newval = val.trim();\n    if (newval === 'true') return true;\n    else if (newval === 'false') return false;\n    else return toNumber(val, options);\n  } else {\n    if (isExist(val)) {\n      return val;\n    } else {\n      return '';\n    }\n  }\n}\n\nfunction fromCodePoint(str, base, prefix) {\n  const codePoint = Number.parseInt(str, base);\n\n  if (codePoint >= 0 && codePoint <= 0x10FFFF) {\n    return String.fromCodePoint(codePoint);\n  } else {\n    return prefix + str + \";\";\n  }\n}\n\nfunction transformTagName(fn, tagName, tagExp, options) {\n  if (fn) {\n    const newTagName = fn(tagName);\n    if (tagExp === tagName) {\n      tagExp = newTagName\n    }\n    tagName = newTagName;\n  }\n  tagName = sanitizeName(tagName, options);\n  return { tagName, tagExp };\n}\n\n\n\nfunction sanitizeName(name, options) {\n  if (criticalProperties.includes(name)) {\n    throw new Error(`[SECURITY] Invalid name: \"${name}\" is a reserved JavaScript keyword that could cause prototype pollution`);\n  } else if (DANGEROUS_PROPERTY_NAMES.includes(name)) {\n    return options.onDangerousProperty(name);\n  }\n  return name;\n}","export default function getIgnoreAttributesFn(ignoreAttributes) {\n    if (typeof ignoreAttributes === 'function') {\n        return ignoreAttributes\n    }\n    if (Array.isArray(ignoreAttributes)) {\n        return (attrName) => {\n            for (const pattern of ignoreAttributes) {\n                if (typeof pattern === 'string' && attrName === pattern) {\n                    return true\n                }\n                if (pattern instanceof RegExp && pattern.test(attrName)) {\n                    return true\n                }\n            }\n        }\n    }\n    return () => false\n}","'use strict';\n\nimport XmlNode from './xmlNode.js';\nimport { Matcher } from 'path-expression-matcher';\n\nconst METADATA_SYMBOL = XmlNode.getMetaDataSymbol();\n\n/**\n * Helper function to strip attribute prefix from attribute map\n * @param {object} attrs - Attributes with prefix (e.g., {\"@_class\": \"code\"})\n * @param {string} prefix - Attribute prefix to remove (e.g., \"@_\")\n * @returns {object} Attributes without prefix (e.g., {\"class\": \"code\"})\n */\nfunction stripAttributePrefix(attrs, prefix) {\n  if (!attrs || typeof attrs !== 'object') return {};\n  if (!prefix) return attrs;\n\n  const rawAttrs = {};\n  for (const key in attrs) {\n    if (key.startsWith(prefix)) {\n      const rawName = key.substring(prefix.length);\n      rawAttrs[rawName] = attrs[key];\n    } else {\n      // Attribute without prefix (shouldn't normally happen, but be safe)\n      rawAttrs[key] = attrs[key];\n    }\n  }\n  return rawAttrs;\n}\n\n/**\n * \n * @param {array} node \n * @param {any} options \n * @param {Matcher} matcher - Path matcher instance\n * @returns \n */\nexport default function prettify(node, options, matcher) {\n  return compress(node, options, matcher);\n}\n\n/**\n * \n * @param {array} arr \n * @param {object} options \n * @param {Matcher} matcher - Path matcher instance\n * @returns object\n */\nfunction compress(arr, options, matcher) {\n  let text;\n  const compressedObj = {}; //This is intended to be a plain object\n  for (let i = 0; i < arr.length; i++) {\n    const tagObj = arr[i];\n    const property = propName(tagObj);\n\n    // Push current property to matcher WITH RAW ATTRIBUTES (no prefix)\n    if (property !== undefined && property !== options.textNodeName) {\n      const rawAttrs = stripAttributePrefix(\n        tagObj[\":@\"] || {},\n        options.attributeNamePrefix\n      );\n      matcher.push(property, rawAttrs);\n    }\n\n    if (property === options.textNodeName) {\n      if (text === undefined) text = tagObj[property];\n      else text += \"\" + tagObj[property];\n    } else if (property === undefined) {\n      continue;\n    } else if (tagObj[property]) {\n\n      let val = compress(tagObj[property], options, matcher);\n      const isLeaf = isLeafTag(val, options);\n\n      if (tagObj[\":@\"]) {\n        assignAttributes(val, tagObj[\":@\"], matcher, options);\n      } else if (Object.keys(val).length === 1 && val[options.textNodeName] !== undefined && !options.alwaysCreateTextNode) {\n        val = val[options.textNodeName];\n      } else if (Object.keys(val).length === 0) {\n        if (options.alwaysCreateTextNode) val[options.textNodeName] = \"\";\n        else val = \"\";\n      }\n\n      if (tagObj[METADATA_SYMBOL] !== undefined && typeof val === \"object\" && val !== null) {\n        val[METADATA_SYMBOL] = tagObj[METADATA_SYMBOL]; // copy over metadata\n      }\n\n\n      if (compressedObj[property] !== undefined && Object.prototype.hasOwnProperty.call(compressedObj, property)) {\n        if (!Array.isArray(compressedObj[property])) {\n          compressedObj[property] = [compressedObj[property]];\n        }\n        compressedObj[property].push(val);\n      } else {\n        //TODO: if a node is not an array, then check if it should be an array\n        //also determine if it is a leaf node\n\n        // Pass jPath string or matcher based on options.jPath setting\n        const jPathOrMatcher = options.jPath ? matcher.toString() : matcher;\n        if (options.isArray(property, jPathOrMatcher, isLeaf)) {\n          compressedObj[property] = [val];\n        } else {\n          compressedObj[property] = val;\n        }\n      }\n\n      // Pop property from matcher after processing\n      if (property !== undefined && property !== options.textNodeName) {\n        matcher.pop();\n      }\n    }\n\n  }\n  // if(text && text.length > 0) compressedObj[options.textNodeName] = text;\n  if (typeof text === \"string\") {\n    if (text.length > 0) compressedObj[options.textNodeName] = text;\n  } else if (text !== undefined) compressedObj[options.textNodeName] = text;\n\n\n  return compressedObj;\n}\n\nfunction propName(obj) {\n  const keys = Object.keys(obj);\n  for (let i = 0; i < keys.length; i++) {\n    const key = keys[i];\n    if (key !== \":@\") return key;\n  }\n}\n\nfunction assignAttributes(obj, attrMap, matcher, options) {\n  if (attrMap) {\n    const keys = Object.keys(attrMap);\n    const len = keys.length; //don't make it inline\n    for (let i = 0; i < len; i++) {\n      const atrrName = keys[i];  // This is the PREFIXED name (e.g., \"@_class\")\n\n      // Strip prefix for matcher path (for isArray callback)\n      const rawAttrName = atrrName.startsWith(options.attributeNamePrefix)\n        ? atrrName.substring(options.attributeNamePrefix.length)\n        : atrrName;\n\n      // For attributes, we need to create a temporary path\n      // Pass jPath string or matcher based on options.jPath setting\n      const jPathOrMatcher = options.jPath\n        ? matcher.toString() + \".\" + rawAttrName\n        : matcher;\n\n      if (options.isArray(atrrName, jPathOrMatcher, true, true)) {\n        obj[atrrName] = [attrMap[atrrName]];\n      } else {\n        obj[atrrName] = attrMap[atrrName];\n      }\n    }\n  }\n}\n\nfunction isLeafTag(obj, options) {\n  const { textNodeName } = options;\n  const propCount = Object.keys(obj).length;\n\n  if (propCount === 0) {\n    return true;\n  }\n\n  if (\n    propCount === 1 &&\n    (obj[textNodeName] || typeof obj[textNodeName] === \"boolean\" || obj[textNodeName] === 0)\n  ) {\n    return true;\n  }\n\n  return false;\n}","import { buildOptions } from './OptionsBuilder.js';\nimport OrderedObjParser from './OrderedObjParser.js';\nimport prettify from './node2json.js';\nimport { validate } from \"../validator.js\";\nimport XmlNode from './xmlNode.js';\n\nexport default class XMLParser {\n\n    constructor(options) {\n        this.externalEntities = {};\n        this.options = buildOptions(options);\n\n    }\n    /**\n     * Parse XML dats to JS object \n     * @param {string|Uint8Array} xmlData \n     * @param {boolean|Object} validationOption \n     */\n    parse(xmlData, validationOption) {\n        if (typeof xmlData !== \"string\" && xmlData.toString) {\n            xmlData = xmlData.toString();\n        } else if (typeof xmlData !== \"string\") {\n            throw new Error(\"XML data is accepted in String or Bytes[] form.\")\n        }\n\n        if (validationOption) {\n            if (validationOption === true) validationOption = {}; //validate with default options\n\n            const result = validate(xmlData, validationOption);\n            if (result !== true) {\n                throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`)\n            }\n        }\n        const orderedObjParser = new OrderedObjParser(this.options);\n        orderedObjParser.addExternalEntities(this.externalEntities);\n        const orderedResult = orderedObjParser.parseXml(xmlData);\n        if (this.options.preserveOrder || orderedResult === undefined) return orderedResult;\n        else return prettify(orderedResult, this.options, orderedObjParser.matcher);\n    }\n\n    /**\n     * Add Entity which is not by default supported by this library\n     * @param {string} key \n     * @param {string} value \n     */\n    addEntity(key, value) {\n        if (value.indexOf(\"&\") !== -1) {\n            throw new Error(\"Entity value can't have '&'\")\n        } else if (key.indexOf(\"&\") !== -1 || key.indexOf(\";\") !== -1) {\n            throw new Error(\"An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'\")\n        } else if (value === \"&\") {\n            throw new Error(\"An entity with value '&' is not permitted\");\n        } else {\n            this.externalEntities[key] = value;\n        }\n    }\n\n    /**\n     * Returns a Symbol that can be used to access the metadata\n     * property on a node.\n     * \n     * If Symbol is not available in the environment, an ordinary property is used\n     * and the name of the property is here returned.\n     * \n     * The XMLMetaData property is only present when `captureMetaData`\n     * is true in the options.\n     */\n    static getMetaDataSymbol() {\n        return XmlNode.getMetaDataSymbol();\n    }\n}\n","import { Expression, Matcher } from 'path-expression-matcher';\n\nconst EOL = \"\\n\";\n\n/**\n * \n * @param {array} jArray \n * @param {any} options \n * @returns \n */\nexport default function toXml(jArray, options) {\n    let indentation = \"\";\n    if (options.format && options.indentBy.length > 0) {\n        indentation = EOL;\n    }\n\n    // Pre-compile stopNode expressions for pattern matching\n    const stopNodeExpressions = [];\n    if (options.stopNodes && Array.isArray(options.stopNodes)) {\n        for (let i = 0; i < options.stopNodes.length; i++) {\n            const node = options.stopNodes[i];\n            if (typeof node === 'string') {\n                stopNodeExpressions.push(new Expression(node));\n            } else if (node instanceof Expression) {\n                stopNodeExpressions.push(node);\n            }\n        }\n    }\n\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n\n    return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions);\n}\n\nfunction arrToStr(arr, options, indentation, matcher, stopNodeExpressions) {\n    let xmlStr = \"\";\n    let isPreviousElementTag = false;\n\n\n    if (!Array.isArray(arr)) {\n        // Non-array values (e.g. string tag values) should be treated as text content\n        if (arr !== undefined && arr !== null) {\n            let text = arr.toString();\n            text = replaceEntitiesValue(text, options);\n            return text;\n        }\n        return \"\";\n    }\n\n    for (let i = 0; i < arr.length; i++) {\n        const tagObj = arr[i];\n        const tagName = propName(tagObj);\n        if (tagName === undefined) continue;\n\n        // Extract attributes from \":@\" property\n        const attrValues = extractAttributeValues(tagObj[\":@\"], options);\n\n        // Push tag to matcher WITH attributes\n        matcher.push(tagName, attrValues);\n\n        // Check if this is a stop node using Expression matching\n        const isStopNode = checkStopNode(matcher, stopNodeExpressions);\n\n        if (tagName === options.textNodeName) {\n            let tagText = tagObj[tagName];\n            if (!isStopNode) {\n                tagText = options.tagValueProcessor(tagName, tagText);\n                tagText = replaceEntitiesValue(tagText, options);\n            }\n            if (isPreviousElementTag) {\n                xmlStr += indentation;\n            }\n            xmlStr += tagText;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.cdataPropName) {\n            if (isPreviousElementTag) {\n                xmlStr += indentation;\n            }\n            xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.commentPropName) {\n            xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        } else if (tagName[0] === \"?\") {\n            const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode);\n            const tempInd = tagName === \"?xml\" ? \"\" : indentation;\n            let piTextNodeName = tagObj[tagName][0][options.textNodeName];\n            piTextNodeName = piTextNodeName.length !== 0 ? \" \" + piTextNodeName : \"\"; //remove extra spacing\n            xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr}?>`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        }\n\n        let newIdentation = indentation;\n        if (newIdentation !== \"\") {\n            newIdentation += options.indentBy;\n        }\n\n        // Pass isStopNode to attr_to_str so attributes are also not processed for stopNodes\n        const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode);\n        const tagStart = indentation + `<${tagName}${attStr}`;\n\n        // If this is a stopNode, get raw content without processing\n        let tagValue;\n        if (isStopNode) {\n            tagValue = getRawContent(tagObj[tagName], options);\n        } else {\n            tagValue = arrToStr(tagObj[tagName], options, newIdentation, matcher, stopNodeExpressions);\n        }\n\n        if (options.unpairedTags.indexOf(tagName) !== -1) {\n            if (options.suppressUnpairedNode) xmlStr += tagStart + \">\";\n            else xmlStr += tagStart + \"/>\";\n        } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {\n            xmlStr += tagStart + \"/>\";\n        } else if (tagValue && tagValue.endsWith(\">\")) {\n            xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;\n        } else {\n            xmlStr += tagStart + \">\";\n            if (tagValue && indentation !== \"\" && (tagValue.includes(\"/>\") || tagValue.includes(\"</\"))) {\n                xmlStr += indentation + options.indentBy + tagValue + indentation;\n            } else {\n                xmlStr += tagValue;\n            }\n            xmlStr += `</${tagName}>`;\n        }\n        isPreviousElementTag = true;\n\n        // Pop tag from matcher\n        matcher.pop();\n    }\n\n    return xmlStr;\n}\n\n/**\n * Extract attribute values from the \":@\" object and return as plain object\n * for passing to matcher.push()\n */\nfunction extractAttributeValues(attrMap, options) {\n    if (!attrMap || options.ignoreAttributes) return null;\n\n    const attrValues = {};\n    let hasAttrs = false;\n\n    for (let attr in attrMap) {\n        if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n        // Remove the attribute prefix to get clean attribute name\n        const cleanAttrName = attr.startsWith(options.attributeNamePrefix)\n            ? attr.substr(options.attributeNamePrefix.length)\n            : attr;\n        attrValues[cleanAttrName] = attrMap[attr];\n        hasAttrs = true;\n    }\n\n    return hasAttrs ? attrValues : null;\n}\n\n/**\n * Extract raw content from a stopNode without any processing\n * This preserves the content exactly as-is, including special characters\n */\nfunction getRawContent(arr, options) {\n    if (!Array.isArray(arr)) {\n        // Non-array values return as-is\n        if (arr !== undefined && arr !== null) {\n            return arr.toString();\n        }\n        return \"\";\n    }\n\n    let content = \"\";\n    for (let i = 0; i < arr.length; i++) {\n        const item = arr[i];\n        const tagName = propName(item);\n\n        if (tagName === options.textNodeName) {\n            // Raw text content - NO processing, NO entity replacement\n            content += item[tagName];\n        } else if (tagName === options.cdataPropName) {\n            // CDATA content\n            content += item[tagName][0][options.textNodeName];\n        } else if (tagName === options.commentPropName) {\n            // Comment content\n            content += item[tagName][0][options.textNodeName];\n        } else if (tagName && tagName[0] === \"?\") {\n            // Processing instruction - skip for stopNodes\n            continue;\n        } else if (tagName) {\n            // Nested tags within stopNode\n            // Recursively get raw content and reconstruct the tag\n            // For stopNodes, we don't process attributes either\n            const attStr = attr_to_str_raw(item[\":@\"], options);\n            const nestedContent = getRawContent(item[tagName], options);\n\n            if (!nestedContent || nestedContent.length === 0) {\n                content += `<${tagName}${attStr}/>`;\n            } else {\n                content += `<${tagName}${attStr}>${nestedContent}</${tagName}>`;\n            }\n        }\n    }\n    return content;\n}\n\n/**\n * Build attribute string for stopNodes - NO entity replacement\n */\nfunction attr_to_str_raw(attrMap, options) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n            // For stopNodes, use raw value without processing\n            let attrVal = attrMap[attr];\n            if (attrVal === true && options.suppressBooleanAttributes) {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;\n            } else {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}=\"${attrVal}\"`;\n            }\n        }\n    }\n    return attrStr;\n}\n\nfunction propName(obj) {\n    const keys = Object.keys(obj);\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n        if (key !== \":@\") return key;\n    }\n}\n\nfunction attr_to_str(attrMap, options, isStopNode) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n            let attrVal;\n\n            if (isStopNode) {\n                // For stopNodes, use raw value without any processing\n                attrVal = attrMap[attr];\n            } else {\n                // Normal processing: apply attributeValueProcessor and entity replacement\n                attrVal = options.attributeValueProcessor(attr, attrMap[attr]);\n                attrVal = replaceEntitiesValue(attrVal, options);\n            }\n\n            if (attrVal === true && options.suppressBooleanAttributes) {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;\n            } else {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}=\"${attrVal}\"`;\n            }\n        }\n    }\n    return attrStr;\n}\n\nfunction checkStopNode(matcher, stopNodeExpressions) {\n    if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;\n\n    for (let i = 0; i < stopNodeExpressions.length; i++) {\n        if (matcher.matches(stopNodeExpressions[i])) {\n            return true;\n        }\n    }\n    return false;\n}\n\nfunction replaceEntitiesValue(textValue, options) {\n    if (textValue && textValue.length > 0 && options.processEntities) {\n        for (let i = 0; i < options.entities.length; i++) {\n            const entity = options.entities[i];\n            textValue = textValue.replace(entity.regex, entity.val);\n        }\n    }\n    return textValue;\n}","'use strict';\n//parse Empty Node as self closing node\nimport buildFromOrderedJs from './orderedJs2Xml.js';\nimport getIgnoreAttributesFn from \"./ignoreAttributes.js\";\nimport { Expression, Matcher } from 'path-expression-matcher';\n\nconst defaultOptions = {\n  attributeNamePrefix: '@_',\n  attributesGroupName: false,\n  textNodeName: '#text',\n  ignoreAttributes: true,\n  cdataPropName: false,\n  format: false,\n  indentBy: '  ',\n  suppressEmptyNode: false,\n  suppressUnpairedNode: true,\n  suppressBooleanAttributes: true,\n  tagValueProcessor: function (key, a) {\n    return a;\n  },\n  attributeValueProcessor: function (attrName, a) {\n    return a;\n  },\n  preserveOrder: false,\n  commentPropName: false,\n  unpairedTags: [],\n  entities: [\n    { regex: new RegExp(\"&\", \"g\"), val: \"&amp;\" },//it must be on top\n    { regex: new RegExp(\">\", \"g\"), val: \"&gt;\" },\n    { regex: new RegExp(\"<\", \"g\"), val: \"&lt;\" },\n    { regex: new RegExp(\"\\'\", \"g\"), val: \"&apos;\" },\n    { regex: new RegExp(\"\\\"\", \"g\"), val: \"&quot;\" }\n  ],\n  processEntities: true,\n  stopNodes: [],\n  // transformTagName: false,\n  // transformAttributeName: false,\n  oneListGroup: false,\n  jPath: true  // When true, callbacks receive string jPath; when false, receive Matcher instance\n};\n\nexport default function Builder(options) {\n  this.options = Object.assign({}, defaultOptions, options);\n\n  // Convert old-style stopNodes for backward compatibility\n  // Old syntax: \"*.tag\" meant \"tag anywhere in tree\"\n  // New syntax: \"..tag\" means \"tag anywhere in tree\"\n  if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) {\n    this.options.stopNodes = this.options.stopNodes.map(node => {\n      if (typeof node === 'string' && node.startsWith('*.')) {\n        // Convert old wildcard syntax to deep wildcard\n        return '..' + node.substring(2);\n      }\n      return node;\n    });\n  }\n\n  // Pre-compile stopNode expressions for pattern matching\n  this.stopNodeExpressions = [];\n  if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) {\n    for (let i = 0; i < this.options.stopNodes.length; i++) {\n      const node = this.options.stopNodes[i];\n      if (typeof node === 'string') {\n        this.stopNodeExpressions.push(new Expression(node));\n      } else if (node instanceof Expression) {\n        this.stopNodeExpressions.push(node);\n      }\n    }\n  }\n\n  if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {\n    this.isAttribute = function (/*a*/) {\n      return false;\n    };\n  } else {\n    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)\n    this.attrPrefixLen = this.options.attributeNamePrefix.length;\n    this.isAttribute = isAttribute;\n  }\n\n  this.processTextOrObjNode = processTextOrObjNode\n\n  if (this.options.format) {\n    this.indentate = indentate;\n    this.tagEndChar = '>\\n';\n    this.newLine = '\\n';\n  } else {\n    this.indentate = function () {\n      return '';\n    };\n    this.tagEndChar = '>';\n    this.newLine = '';\n  }\n}\n\nBuilder.prototype.build = function (jObj) {\n  if (this.options.preserveOrder) {\n    return buildFromOrderedJs(jObj, this.options);\n  } else {\n    if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {\n      jObj = {\n        [this.options.arrayNodeName]: jObj\n      }\n    }\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n    return this.j2x(jObj, 0, matcher).val;\n  }\n};\n\nBuilder.prototype.j2x = function (jObj, level, matcher) {\n  let attrStr = '';\n  let val = '';\n\n  // Get jPath based on option: string for backward compatibility, or Matcher for new features\n  const jPath = this.options.jPath ? matcher.toString() : matcher;\n\n  // Check if current node is a stopNode (will be used for attribute encoding)\n  const isCurrentStopNode = this.checkStopNode(matcher);\n\n  for (let key in jObj) {\n    if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;\n    if (typeof jObj[key] === 'undefined') {\n      // supress undefined node only if it is not an attribute\n      if (this.isAttribute(key)) {\n        val += '';\n      }\n    } else if (jObj[key] === null) {\n      // null attribute should be ignored by the attribute list, but should not cause the tag closing\n      if (this.isAttribute(key)) {\n        val += '';\n      } else if (key === this.options.cdataPropName) {\n        val += '';\n      } else if (key[0] === '?') {\n        val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;\n      } else {\n        val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n      }\n      // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n    } else if (jObj[key] instanceof Date) {\n      val += this.buildTextValNode(jObj[key], key, '', level, matcher);\n    } else if (typeof jObj[key] !== 'object') {\n      //premitive type\n      const attr = this.isAttribute(key);\n      if (attr && !this.ignoreAttributesFn(attr, jPath)) {\n        attrStr += this.buildAttrPairStr(attr, '' + jObj[key], isCurrentStopNode);\n      } else if (!attr) {\n        //tag value\n        if (key === this.options.textNodeName) {\n          let newval = this.options.tagValueProcessor(key, '' + jObj[key]);\n          val += this.replaceEntitiesValue(newval);\n        } else {\n          // Check if this is a stopNode before building\n          matcher.push(key);\n          const isStopNode = this.checkStopNode(matcher);\n          matcher.pop();\n\n          if (isStopNode) {\n            // Build as raw content without encoding\n            const textValue = '' + jObj[key];\n            if (textValue === '') {\n              val += this.indentate(level) + '<' + key + this.closeTag(key) + this.tagEndChar;\n            } else {\n              val += this.indentate(level) + '<' + key + '>' + textValue + '</' + key + this.tagEndChar;\n            }\n          } else {\n            val += this.buildTextValNode(jObj[key], key, '', level, matcher);\n          }\n        }\n      }\n    } else if (Array.isArray(jObj[key])) {\n      //repeated nodes\n      const arrLen = jObj[key].length;\n      let listTagVal = \"\";\n      let listTagAttr = \"\";\n      for (let j = 0; j < arrLen; j++) {\n        const item = jObj[key][j];\n        if (typeof item === 'undefined') {\n          // supress undefined node\n        } else if (item === null) {\n          if (key[0] === \"?\") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;\n          else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n          // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n        } else if (typeof item === 'object') {\n          if (this.options.oneListGroup) {\n            // Push tag to matcher before recursive call\n            matcher.push(key);\n            const result = this.j2x(item, level + 1, matcher);\n            // Pop tag from matcher after recursive call\n            matcher.pop();\n\n            listTagVal += result.val;\n            if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {\n              listTagAttr += result.attrStr\n            }\n          } else {\n            listTagVal += this.processTextOrObjNode(item, key, level, matcher)\n          }\n        } else {\n          if (this.options.oneListGroup) {\n            let textValue = this.options.tagValueProcessor(key, item);\n            textValue = this.replaceEntitiesValue(textValue);\n            listTagVal += textValue;\n          } else {\n            // Check if this is a stopNode before building\n            matcher.push(key);\n            const isStopNode = this.checkStopNode(matcher);\n            matcher.pop();\n\n            if (isStopNode) {\n              // Build as raw content without encoding\n              const textValue = '' + item;\n              if (textValue === '') {\n                listTagVal += this.indentate(level) + '<' + key + this.closeTag(key) + this.tagEndChar;\n              } else {\n                listTagVal += this.indentate(level) + '<' + key + '>' + textValue + '</' + key + this.tagEndChar;\n              }\n            } else {\n              listTagVal += this.buildTextValNode(item, key, '', level, matcher);\n            }\n          }\n        }\n      }\n      if (this.options.oneListGroup) {\n        listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);\n      }\n      val += listTagVal;\n    } else {\n      //nested node\n      if (this.options.attributesGroupName && key === this.options.attributesGroupName) {\n        const Ks = Object.keys(jObj[key]);\n        const L = Ks.length;\n        for (let j = 0; j < L; j++) {\n          attrStr += this.buildAttrPairStr(Ks[j], '' + jObj[key][Ks[j]], isCurrentStopNode);\n        }\n      } else {\n        val += this.processTextOrObjNode(jObj[key], key, level, matcher)\n      }\n    }\n  }\n  return { attrStr: attrStr, val: val };\n};\n\nBuilder.prototype.buildAttrPairStr = function (attrName, val, isStopNode) {\n  if (!isStopNode) {\n    val = this.options.attributeValueProcessor(attrName, '' + val);\n    val = this.replaceEntitiesValue(val);\n  }\n  if (this.options.suppressBooleanAttributes && val === \"true\") {\n    return ' ' + attrName;\n  } else return ' ' + attrName + '=\"' + val + '\"';\n}\n\nfunction processTextOrObjNode(object, key, level, matcher) {\n  // Extract attributes to pass to matcher\n  const attrValues = this.extractAttributes(object);\n\n  // Push tag to matcher before recursion WITH attributes\n  matcher.push(key, attrValues);\n\n  // Check if this entire node is a stopNode\n  const isStopNode = this.checkStopNode(matcher);\n\n  if (isStopNode) {\n    // For stopNodes, build raw content without entity encoding\n    const rawContent = this.buildRawContent(object);\n    const attrStr = this.buildAttributesForStopNode(object);\n    matcher.pop();\n    return this.buildObjectNode(rawContent, key, attrStr, level);\n  }\n\n  const result = this.j2x(object, level + 1, matcher);\n  // Pop tag from matcher after recursion\n  matcher.pop();\n\n  if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {\n    return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level, matcher);\n  } else {\n    return this.buildObjectNode(result.val, key, result.attrStr, level);\n  }\n}\n\n// Helper method to extract attributes from an object\nBuilder.prototype.extractAttributes = function (obj) {\n  if (!obj || typeof obj !== 'object') return null;\n\n  const attrValues = {};\n  let hasAttrs = false;\n\n  // Check for attributesGroupName (when attributes are grouped)\n  if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {\n    const attrGroup = obj[this.options.attributesGroupName];\n    for (let attrKey in attrGroup) {\n      if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;\n      // Remove attribute prefix if present\n      const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix)\n        ? attrKey.substring(this.options.attributeNamePrefix.length)\n        : attrKey;\n      attrValues[cleanKey] = attrGroup[attrKey];\n      hasAttrs = true;\n    }\n  } else {\n    // Look for individual attributes (prefixed with attributeNamePrefix)\n    for (let key in obj) {\n      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n      const attr = this.isAttribute(key);\n      if (attr) {\n        attrValues[attr] = obj[key];\n        hasAttrs = true;\n      }\n    }\n  }\n\n  return hasAttrs ? attrValues : null;\n};\n\n// Build raw content for stopNode without entity encoding\nBuilder.prototype.buildRawContent = function (obj) {\n  if (typeof obj === 'string') {\n    return obj; // Already a string, return as-is\n  }\n\n  if (typeof obj !== 'object' || obj === null) {\n    return String(obj);\n  }\n\n  // Check if this is a stopNode data from parser: { \"#text\": \"raw xml\", \"@_attr\": \"val\" }\n  if (obj[this.options.textNodeName] !== undefined) {\n    return obj[this.options.textNodeName]; // Return raw text without encoding\n  }\n\n  // Build raw XML from nested structure\n  let content = '';\n\n  for (let key in obj) {\n    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n\n    // Skip attributes\n    if (this.isAttribute(key)) continue;\n    if (this.options.attributesGroupName && key === this.options.attributesGroupName) continue;\n\n    const value = obj[key];\n\n    if (key === this.options.textNodeName) {\n      content += value; // Raw text\n    } else if (Array.isArray(value)) {\n      // Array of same tag\n      for (let item of value) {\n        if (typeof item === 'string' || typeof item === 'number') {\n          content += `<${key}>${item}</${key}>`;\n        } else if (typeof item === 'object' && item !== null) {\n          const nestedContent = this.buildRawContent(item);\n          const nestedAttrs = this.buildAttributesForStopNode(item);\n          if (nestedContent === '') {\n            content += `<${key}${nestedAttrs}/>`;\n          } else {\n            content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;\n          }\n        }\n      }\n    } else if (typeof value === 'object' && value !== null) {\n      // Nested object\n      const nestedContent = this.buildRawContent(value);\n      const nestedAttrs = this.buildAttributesForStopNode(value);\n      if (nestedContent === '') {\n        content += `<${key}${nestedAttrs}/>`;\n      } else {\n        content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;\n      }\n    } else {\n      // Primitive value\n      content += `<${key}>${value}</${key}>`;\n    }\n  }\n\n  return content;\n};\n\n// Build attribute string for stopNode (no entity encoding)\nBuilder.prototype.buildAttributesForStopNode = function (obj) {\n  if (!obj || typeof obj !== 'object') return '';\n\n  let attrStr = '';\n\n  // Check for attributesGroupName (when attributes are grouped)\n  if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {\n    const attrGroup = obj[this.options.attributesGroupName];\n    for (let attrKey in attrGroup) {\n      if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;\n      const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix)\n        ? attrKey.substring(this.options.attributeNamePrefix.length)\n        : attrKey;\n      const val = attrGroup[attrKey];\n      if (val === true && this.options.suppressBooleanAttributes) {\n        attrStr += ' ' + cleanKey;\n      } else {\n        attrStr += ' ' + cleanKey + '=\"' + val + '\"'; // No encoding for stopNode\n      }\n    }\n  } else {\n    // Look for individual attributes\n    for (let key in obj) {\n      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n      const attr = this.isAttribute(key);\n      if (attr) {\n        const val = obj[key];\n        if (val === true && this.options.suppressBooleanAttributes) {\n          attrStr += ' ' + attr;\n        } else {\n          attrStr += ' ' + attr + '=\"' + val + '\"'; // No encoding for stopNode\n        }\n      }\n    }\n  }\n\n  return attrStr;\n};\n\nBuilder.prototype.buildObjectNode = function (val, key, attrStr, level) {\n  if (val === \"\") {\n    if (key[0] === \"?\") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n    else {\n      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;\n    }\n  } else {\n\n    let tagEndExp = '</' + key + this.tagEndChar;\n    let piClosingChar = \"\";\n\n    if (key[0] === \"?\") {\n      piClosingChar = \"?\";\n      tagEndExp = \"\";\n    }\n\n    // attrStr is an empty string in case the attribute came as undefined or null\n    if ((attrStr || attrStr === '') && val.indexOf('<') === -1) {\n      return (this.indentate(level) + '<' + key + attrStr + piClosingChar + '>' + val + tagEndExp);\n    } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {\n      return this.indentate(level) + `<!--${val}-->` + this.newLine;\n    } else {\n      return (\n        this.indentate(level) + '<' + key + attrStr + piClosingChar + this.tagEndChar +\n        val +\n        this.indentate(level) + tagEndExp);\n    }\n  }\n}\n\nBuilder.prototype.closeTag = function (key) {\n  let closeTag = \"\";\n  if (this.options.unpairedTags.indexOf(key) !== -1) { //unpaired\n    if (!this.options.suppressUnpairedNode) closeTag = \"/\"\n  } else if (this.options.suppressEmptyNode) { //empty\n    closeTag = \"/\";\n  } else {\n    closeTag = `></${key}`\n  }\n  return closeTag;\n}\n\nBuilder.prototype.checkStopNode = function (matcher) {\n  if (!this.stopNodeExpressions || this.stopNodeExpressions.length === 0) return false;\n\n  for (let i = 0; i < this.stopNodeExpressions.length; i++) {\n    if (matcher.matches(this.stopNodeExpressions[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction buildEmptyObjNode(val, key, attrStr, level) {\n  if (val !== '') {\n    return this.buildObjectNode(val, key, attrStr, level);\n  } else {\n    if (key[0] === \"?\") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n    else {\n      return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;\n      // return this.buildTagStr(level,key, attrStr);\n    }\n  }\n}\n\nBuilder.prototype.buildTextValNode = function (val, key, attrStr, level, matcher) {\n  if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {\n    return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine;\n  } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {\n    return this.indentate(level) + `<!--${val}-->` + this.newLine;\n  } else if (key[0] === \"?\") {//PI tag\n    return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n  } else {\n    // Normal processing: apply tagValueProcessor and entity replacement\n    let textValue = this.options.tagValueProcessor(key, val);\n    textValue = this.replaceEntitiesValue(textValue);\n\n    if (textValue === '') {\n      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;\n    } else {\n      return this.indentate(level) + '<' + key + attrStr + '>' +\n        textValue +\n        '</' + key + this.tagEndChar;\n    }\n  }\n}\n\nBuilder.prototype.replaceEntitiesValue = function (textValue) {\n  if (textValue && textValue.length > 0 && this.options.processEntities) {\n    for (let i = 0; i < this.options.entities.length; i++) {\n      const entity = this.options.entities[i];\n      textValue = textValue.replace(entity.regex, entity.val);\n    }\n  }\n  return textValue;\n}\n\nfunction indentate(level) {\n  return this.options.indentBy.repeat(level);\n}\n\nfunction isAttribute(name /*, options*/) {\n  if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {\n    return name.substr(this.attrPrefixLen);\n  } else {\n    return false;\n  }\n}","export default function getIgnoreAttributesFn(ignoreAttributes) {\n    if (typeof ignoreAttributes === 'function') {\n        return ignoreAttributes\n    }\n    if (Array.isArray(ignoreAttributes)) {\n        return (attrName) => {\n            for (const pattern of ignoreAttributes) {\n                if (typeof pattern === 'string' && attrName === pattern) {\n                    return true\n                }\n                if (pattern instanceof RegExp && pattern.test(attrName)) {\n                    return true\n                }\n            }\n        }\n    }\n    return () => false\n}","// Re-export from fast-xml-builder for backward compatibility\nimport XMLBuilder from 'fast-xml-builder';\nexport default XMLBuilder;\n\n// If there are any named exports you also want to re-export:\nexport * from 'fast-xml-builder';","'use strict';\n\nimport { validate } from './validator.js';\nimport XMLParser from './xmlparser/XMLParser.js';\nimport XMLBuilder from './xmlbuilder/json2xml.js';\n\nconst XMLValidator = {\n  validate: validate\n}\nexport {\n  XMLParser,\n  XMLValidator,\n  XMLBuilder\n};"],"names":["root","factory","exports","module","define","amd","this","__webpack_require__","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","Symbol","toStringTag","value","nameStartChar","regexName","RegExp","getAllMatches","string","regex","matches","match","exec","allmatches","startIndex","lastIndex","length","len","index","push","isName","DANGEROUS_PROPERTY_NAMES","criticalProperties","defaultOptions","allowBooleanAttributes","unpairedTags","validate","xmlData","options","assign","tags","tagFound","reachedRoot","substr","i","readPI","err","isWhiteSpace","getErrorObject","getLineNumberForPosition","tagStartPos","readCommentAndCDATA","closingTag","tagName","trim","substring","validateTagName","result","readAttributeStr","attrStr","attrStrStart","isValid","validateAttributeString","code","msg","line","tagClosed","otg","pop","openPos","col","indexOf","afterAmp","validateAmpersand","JSON","stringify","map","t","replace","char","start","tagname","angleBracketsCount","doubleQuote","singleQuote","startChar","validAttrStrRegxp","attrNames","getPositionFromMatch","undefined","attrName","validateAttrName","re","validateNumberAmpersand","count","message","lineNumber","lines","split","defaultOnDangerousProperty","name","includes","preserveOrder","attributeNamePrefix","attributesGroupName","textNodeName","ignoreAttributes","removeNSPrefix","parseTagValue","parseAttributeValue","trimValues","cdataPropName","numberParseOptions","hex","leadingZeros","eNotation","tagValueProcessor","val","attributeValueProcessor","stopNodes","alwaysCreateTextNode","isArray","commentPropName","processEntities","htmlEntities","ignoreDeclaration","ignorePiTags","transformTagName","transformAttributeName","updateTag","jPath","attrs","captureMetaData","maxNestedTags","strictReservedNames","onDangerousProperty","validatePropertyName","propertyName","optionName","normalized","toLowerCase","some","dangerous","Error","normalizeProcessEntities","enabled","maxEntitySize","maxExpansionDepth","maxTotalExpansions","maxExpandedLength","maxEntityCount","allowedTags","tagFilter","_value$maxEntitySize","_value$maxExpansionDe","_value$maxTotalExpans","_value$maxExpandedLen","_value$maxEntityCount","_value$allowedTags","_value$tagFilter","METADATA_SYMBOL","buildOptions","built","_i","_propertyNameOptions","_propertyNameOptions$","Array","node","startsWith","XmlNode","child","create","_proto","add","_this$child$push","addChild","_this$child$push2","_this$child$push3","keys","getMetaDataSymbol","DocTypeReader","suppressValidationErr","readDocType","entities","entityCount","hasBody","comment","hasSeq","entityName","_this$readEntityExp","readEntityExp","escaped","regx","readElementExp","readNotationExp","skipWhitespace","test","validateEntityName","toUpperCase","entityValue","_this$readIdentifierV","readIdentifierVal","notationName","identifierType","publicIdentifier","systemIdentifier","_this$readIdentifierV2","_this$readIdentifierV3","_this$readIdentifierV4","type","identifierVal","elementName","contentModel","readAttlistExp","attributeName","attributeType","allowedNotations","notation","join","defaultValue","_this$readIdentifierV5","data","seq","j","hexRegex","numRegex","consider","decimalPoint","eNotationRegx","Matcher","constructor","separator","path","siblingStacks","attrValues","namespace","values","currentLevel","Map","siblings","siblingKey","counter","position","set","tag","updateCurrent","current","getCurrentTag","getCurrentNamespace","getAttrValue","hasAttr","getPosition","getCounter","getIndex","getDepth","toString","includeNamespace","sep","n","toArray","reset","expression","segments","hasDeepWildcard","_matchWithDeepWildcard","_matchSimple","segment","isCurrentNode","_matchSegment","pathIdx","segIdx","nextSeg","found","attrValue","actualValue","String","positionValue","snapshot","restore","Expression","pattern","_parse","_hasDeepWildcard","seg","_hasAttributeCondition","_hasPositionSelector","currentPart","_parseSegment","part","bracketContent","withoutBrackets","bracketMatch","content","slice","tagAndPosition","nsIndex","positionMatch","colonIndex","lastIndexOf","tagPart","posPart","eqIndex","nthMatch","parseInt","hasAttributeCondition","hasPositionSelector","extractRawAttributes","prefixedAttrs","rawAttrs","extractNamespace","rawTagName","ns","OrderedObjParser","currentNode","tagsNodeStack","docTypeEntities","lastEntities","ampEntity","_","str","fromCodePoint","addExternalEntities","parseXml","parseTextData","resolveNameSpace","buildAttributesMap","isItStopNode","replaceEntitiesValue","readStopNodeData","saveTextToParentTag","ignoreAttributesFn","_step","_iterator","_createForOfIteratorHelperLoose","done","entityExpansionCount","currentExpandedLength","matcher","isCurrentNodeStopNode","stopNodeExpressions","stopNodeExp","externalEntities","entKeys","ent","dontTrim","hasAttributes","isLeafNode","escapeEntities","jPathOrMatcher","newval","parseValue","prefix","charAt","attrsRegx","rawAttrsForMatcher","oldVal","parsedVal","jPathStr","aName","sanitizeName","newVal","attrCollection","xmlObj","xmlNode","textData","docTypeReader","closeIndex","findClosingIndex","lastTagName","tagData","readTagExp","childNode","tagExp","attrExpPresent","endIndex","_ref","_ref2","context","Math","max","min","_transformTagName","lastTag","isSelfClosing","tagContent","_transformTagName2","entityConfig","entity","lengthBefore","parentNode","errMsg","closingIndex","closingChar","attrBoundary","ch","tagExpWithClosingIndex","separatorIndex","search","trimStart","openTagCount","shouldParse","trimmedStr","skipLike","numStr","Number","window","parse_int","sign","eChar","eAdjacentToLeadingZeros","resolveEnotation","numTrimmedByZeros","decimalAdjacentToLeadingZeros","num","parsedStr","toNumber","base","codePoint","fn","newTagName","stripAttributePrefix","prettify","compress","arr","text","compressedObj","tagObj","property","propName","isLeaf","isLeafTag","assignAttributes","attrMap","atrrName","rawAttrName","propCount","XMLParser","parse","validationOption","orderedObjParser","orderedResult","addEntity","toXml","jArray","indentation","format","indentBy","arrToStr","xmlStr","isPreviousElementTag","extractAttributeValues","isStopNode","checkStopNode","tagText","attStr","attr_to_str","tempInd","piTextNodeName","newIdentation","tagStart","tagValue","getRawContent","suppressUnpairedNode","suppressEmptyNode","endsWith","hasAttrs","attr","item","attr_to_str_raw","nestedContent","attrVal","suppressBooleanAttributes","textValue","a","oneListGroup","Builder","isAttribute","attrPrefixLen","processTextOrObjNode","indentate","tagEndChar","newLine","object","level","extractAttributes","rawContent","buildRawContent","buildAttributesForStopNode","buildObjectNode","j2x","buildTextValNode","repeat","build","jObj","buildFromOrderedJs","arrayNodeName","isCurrentStopNode","Date","buildAttrPairStr","closeTag","arrLen","listTagVal","listTagAttr","Ks","L","attrGroup","attrKey","nestedAttrs","cleanKey","tagEndExp","piClosingChar","XMLValidator"],"sourceRoot":""}