lambda-live-debugger 1.12.0 → 1.12.2

package/node_modules/fast-xml-parser/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\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,\n      maxEntitySize: Math.max(1, value.maxEntitySize ?? 10000),\n      maxExpansionDepth: Math.max(1, value.maxExpansionDepth ?? 10),\n      maxTotalExpansions: Math.max(1, value.maxTotalExpansions ?? 1000),\n      maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 100000),\n      maxEntityCount: Math.max(1, 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 != null &&\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                            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        const startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i]) && xmlData[i] !== '\"' && xmlData[i] !== \"'\") {\n            i++;\n        }\n        let entityName = xmlData.substring(startIndex, 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 != null &&\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\n        const startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            i++;\n        }\n        let notationName = xmlData.substring(startIndex, 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        const startIndex = i;\n        while (i < xmlData.length && xmlData[i] !== startChar) {\n            i++;\n        }\n        identifierVal = xmlData.substring(startIndex, i);\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        const startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            i++;\n        }\n        let elementName = xmlData.substring(startIndex, i);\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            const startIndex = i;\n            while (i < xmlData.length && xmlData[i] !== \")\") {\n                i++;\n            }\n            contentModel = xmlData.substring(startIndex, 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 startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            i++;\n        }\n        let elementName = xmlData.substring(startIndex, i);\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        startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            i++;\n        }\n        let attributeName = xmlData.substring(startIndex, i);\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\n\n                const startIndex = i;\n                while (i < xmlData.length && xmlData[i] !== \"|\" && xmlData[i] !== \")\") {\n                    i++;\n                }\n                let notation = xmlData.substring(startIndex, i);\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            const startIndex = i;\n            while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n                i++;\n            }\n            attributeType += xmlData.substring(startIndex, i);\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    infinity: \"original\", // \"null\", \"infinity\" (Infinity type), \"string\" (\"Infinity\" (the string literal))\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 (!isFinite(trimmedStr)) { //Infinity\n        return handleInfinity(str, Number(trimmedStr), options);\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 (leadingZeros.length > 0) {\n            // Has leading zeros — only accept if leadingZeros option allows it\n            if (options.leadingZeros && !eAdjacentToLeadingZeros) {\n                trimmedStr = (notation[1] || \"\") + notation[3];\n                return Number(trimmedStr);\n            } else return str;\n        } else {\n            // No leading zeros — always valid e-notation, parse it\n            return Number(trimmedStr);\n        }\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\n/**\n * Handle infinite values based on user option\n * @param {string} str - original input string\n * @param {number} num - parsed number (Infinity or -Infinity)\n * @param {object} options - user options\n * @returns {string|number|null} based on infinity option\n */\nfunction handleInfinity(str, num, options) {\n    const isPositive = num === Infinity;\n\n    switch (options.infinity.toLowerCase()) {\n        case \"null\":\n            return null;\n        case \"infinity\":\n            return num; // Return Infinity or -Infinity\n        case \"string\":\n            return isPositive ? \"Infinity\" : \"-Infinity\";\n        case \"original\":\n        default:\n            return str; // Return original string like \"1e1000\"\n    }\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 */\n\n/**\n * Names of methods that mutate Matcher state.\n * Any attempt to call these on a read-only view throws a TypeError.\n * @type {Set<string>}\n */\nconst MUTATING_METHODS = new Set(['push', 'pop', 'reset', 'updateCurrent', 'restore']);\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  /**\n   * Return a read-only view of this matcher.\n   *\n   * The returned object exposes all query/inspection methods but throws a\n   * TypeError if any state-mutating method is called (`push`, `pop`, `reset`,\n   * `updateCurrent`, `restore`).  Property reads (e.g. `.path`, `.separator`)\n   * are allowed but the returned arrays/objects are frozen so callers cannot\n   * mutate internal state through them either.\n   *\n   * @returns {ReadOnlyMatcher} A proxy that forwards read operations and blocks writes.\n   *\n   * @example\n   * const matcher = new Matcher();\n   * matcher.push(\"root\", {});\n   *\n   * const ro = matcher.readOnly();\n   * ro.matches(expr);      // ✓ works\n   * ro.getCurrentTag();    // ✓ works\n   * ro.push(\"child\", {}); // ✗ throws TypeError\n   * ro.reset();            // ✗ throws TypeError\n   */\n  readOnly() {\n    const self = this;\n\n    return new Proxy(self, {\n      get(target, prop, receiver) {\n        // Block mutating methods\n        if (MUTATING_METHODS.has(prop)) {\n          return () => {\n            throw new TypeError(\n              `Cannot call '${prop}' on a read-only Matcher. ` +\n              `Obtain a writable instance to mutate state.`\n            );\n          };\n        }\n\n        const value = Reflect.get(target, prop, receiver);\n\n        // Freeze array/object properties so callers can't mutate internal\n        // state through direct property access (e.g. matcher.path.push(...))\n        if (prop === 'path' || prop === 'siblingStacks') {\n          return Object.freeze(\n            Array.isArray(value)\n              ? value.map(item =>\n                item instanceof Map\n                  ? Object.freeze(new Map(item))   // freeze a copy of each Map\n                  : Object.freeze({ ...item })      // freeze a copy of each node\n              )\n              : value\n          );\n        }\n\n        // Bind methods so `this` inside them still refers to the real Matcher\n        if (typeof value === 'function') {\n          return value.bind(target);\n        }\n\n        return value;\n      },\n\n      // Prevent any property assignment on the read-only view\n      set(_target, prop) {\n        throw new TypeError(\n          `Cannot set property '${String(prop)}' on a read-only Matcher.`\n        );\n      },\n\n      // Prevent property deletion\n      deleteProperty(_target, prop) {\n        throw new TypeError(\n          `Cannot delete property '${String(prop)}' from a read-only Matcher.`\n        );\n      }\n    });\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    // Live read-only proxy of matcher — PEM creates and caches this internally.\n    // All user callbacks receive this instead of the mutable matcher.\n    this.readonlyMatcher = this.matcher.readOnly();\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, this.readonlyMatcher);\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() : this.readonlyMatcher;\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, this.readonlyMatcher);\n\n          // Pass jPath string or readonlyMatcher based on options.jPath setting\n          const jPathOrMatcher = this.options.jPath ? jPath.toString() : this.readonlyMatcher;\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.readonlyMatcher);\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.readonlyMatcher);\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.readonlyMatcher, 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.readonlyMatcher);\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.readonlyMatcher);\n\n        let val = this.parseTextData(tagExp, currentNode.tagname, this.readonlyMatcher, 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            || tagName === this.options.textNodeName\n            || tagName === this.options.attributesGroupName\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.readonlyMatcher, 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.readonlyMatcher, 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.readonlyMatcher, 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.readonlyMatcher, 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.readonlyMatcher, 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 (const entityName of Object.keys(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  // Replace standard entities\n  for (const entityName of Object.keys(this.lastEntities)) {\n    const entity = this.lastEntities[entityName];\n    const matches = val.match(entity.regex);\n    if (matches) {\n      this.entityExpansionCount += matches.length;\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    val = val.replace(entity.regex, entity.val);\n  }\n  if (val.indexOf('&') === -1) return val;\n\n  // Replace HTML entities if enabled\n  if (this.options.htmlEntities) {\n    for (const entityName of Object.keys(this.htmlEntities)) {\n      const entity = this.htmlEntities[entityName];\n      const matches = val.match(entity.regex);\n      if (matches) {\n        //console.log(matches);\n        this.entityExpansionCount += matches.length;\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      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, readonlyMatcher) {\n  return compress(node, options, matcher, readonlyMatcher);\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, readonlyMatcher) {\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, readonlyMatcher);\n      const isLeaf = isLeafTag(val, options);\n\n      if (tagObj[\":@\"]) {\n        assignAttributes(val, tagObj[\":@\"], readonlyMatcher, 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 readonlyMatcher based on options.jPath setting\n        const jPathOrMatcher = options.jPath ? readonlyMatcher.toString() : readonlyMatcher;\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, readonlyMatcher, 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        ? readonlyMatcher.toString() + \".\" + rawAttrName\n        : readonlyMatcher;\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, orderedObjParser.readonlyMatcher);\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}","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    if (options.maxNestedTags && matcher.getDepth() > options.maxNestedTags) {\n        throw new Error(\"Maximum nested tags exceeded\");\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\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  maxNestedTags: 100,\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  if (this.options.maxNestedTags && matcher.getDepth() >= this.options.maxNestedTags) {\n    throw new Error(\"Maximum nested tags exceeded\");\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","Math","max","_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","infinity","eNotationRegx","MUTATING_METHODS","Set","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","readOnly","Proxy","target","receiver","has","TypeError","Reflect","freeze","item","bind","_target","deleteProperty","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","readonlyMatcher","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","min","_transformTagName","lastTag","isSelfClosing","tagContent","_transformTagName2","entityConfig","_i2","_Object$keys","entity","lengthBefore","_i3","_Object$keys2","_i4","_Object$keys3","parentNode","errMsg","closingIndex","closingChar","attrBoundary","ch","tagExpWithClosingIndex","separatorIndex","search","trimStart","openTagCount","shouldParse","trimmedStr","skipLike","numStr","Number","window","parse_int","isFinite","sign","eChar","eAdjacentToLeadingZeros","resolveEnotation","numTrimmedByZeros","decimalAdjacentToLeadingZeros","num","parsedStr","isPositive","Infinity","handleInfinity","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","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/./node_modules/xml-naming/src/index.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/./node_modules/path-expression-matcher/src/ExpressionSet.js","webpack://fxp/./node_modules/@nodable/entities/src/entities.js","webpack://fxp/./node_modules/@nodable/entities/src/EntityDecoder.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/util.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\";\nimport { COMMON_HTML, CURRENCY } from '@nodable/entities';\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  entityDecoder: null,\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, htmlEntities) {\n  // Boolean backward compatibility\n  if (typeof value === 'boolean') {\n    return {\n      enabled: value, // true or false\n      maxEntitySize: 10000,\n      maxExpansionDepth: 10000,\n      maxTotalExpansions: Infinity,\n      maxExpandedLength: 100000,\n      maxEntityCount: 1000,\n      allowedTags: null,\n      tagFilter: null,\n      appliesTo: \"all\",\n    };\n  }\n\n  // Object config - merge with defaults\n  if (typeof value === 'object' && value !== null) {\n    return {\n      enabled: value.enabled !== false,\n      maxEntitySize: Math.max(1, value.maxEntitySize ?? 10000),\n      maxExpansionDepth: Math.max(1, value.maxExpansionDepth ?? 10000),\n      maxTotalExpansions: Math.max(1, value.maxTotalExpansions ?? Infinity),\n      maxExpandedLength: Math.max(1, value.maxExpandedLength ?? 100000),\n      maxEntityCount: Math.max(1, value.maxEntityCount ?? 1000),\n      allowedTags: value.allowedTags ?? null,\n      tagFilter: value.tagFilter ?? null,\n      appliesTo: value.appliesTo ?? \"all\",\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, built.htmlEntities);\n  built.unpairedTagsSet = new Set(built.unpairedTags);\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","/**\n * xml-naming\n * Validates XML Name productions as defined in the XML 1.0 and 1.1 specifications.\n * Covers: Name, NCName, QName, NMToken, NMTokens\n *\n * XML 1.0 spec: https://www.w3.org/TR/xml/#NT-Name\n * XML 1.1 spec: https://www.w3.org/TR/xml11/#NT-NameStartChar\n * XML NS spec:  https://www.w3.org/TR/xml-names/#NT-NCName\n */\n\n// ---------------------------------------------------------------------------\n// Character class strings — XML 1.0\n//\n// NameStartChar ::= \":\" | [A-Z] | \"_\" | [a-z]\n//   | [#xC0-#xD6]   | [#xD8-#xF6]   | [#xF8-#x2FF]\n//   | [#x370-#x37D] | [#x37F-#x1FFF]    <- split to exclude #x0487\n//   | [#x200C-#x200D]\n//   | [#x2070-#x218F] | [#x2C00-#x2FEF]\n//   | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD]\n//\n// NameChar ::= NameStartChar | \"-\" | \".\" | [0-9]\n//   | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]\n//\n// Note: \\u0487 (Combining Cyrillic Millions Sign) was added in Unicode 4.0,\n// after XML 1.0 was defined against Unicode 2.0. It falls inside the range\n// \\u037F-\\u1FFF but must be excluded. We split that range into\n// \\u037F-\\u0486 and \\u0488-\\u1FFF to exclude it explicitly.\n// ---------------------------------------------------------------------------\n\nconst nameStartChar10 =\n  ':A-Za-z_' +\n  '\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF' +\n  '\\u0370-\\u037D' +\n  '\\u037F-\\u0486\\u0488-\\u1FFF' +  // split to exclude \\u0487\n  '\\u200C-\\u200D' +\n  '\\u2070-\\u218F' +\n  '\\u2C00-\\u2FEF' +\n  '\\u3001-\\uD7FF' +\n  '\\uF900-\\uFDCF' +\n  '\\uFDF0-\\uFFFD';\n\nconst nameChar10 =\n  nameStartChar10 +\n  '\\\\-\\\\.\\\\d' +\n  '\\u00B7' +\n  '\\u0300-\\u036F' +\n  '\\u203F-\\u2040';\n\n// ---------------------------------------------------------------------------\n// Character class strings — XML 1.1\n//\n// Differences from XML 1.0:\n//\n// NameStartChar:\n//   1.0 has split ranges: \\u00C0-\\u00D6, \\u00D8-\\u00F6, \\u00F8-\\u02FF\n//   1.1 merges them into: \\u00C0-\\u02FF\n//   (\\u00D7 x and \\u00F7 / are division symbols, excluded in both versions)\n//\n//   1.0 tops out at \\uFFFD (BMP only)\n//   1.1 adds \\u{10000}-\\u{EFFFF} (supplementary planes)\n//   These require the /u flag on the RegExp — see buildRegexes below.\n//\n// NameChar:\n//   1.1 adds \\u0487 (Combining Cyrillic Millions Sign, added in Unicode 4.0)\n// ---------------------------------------------------------------------------\n\nconst nameStartChar11 =\n  ':A-Za-z_' +\n  '\\u00C0-\\u02FF' +                    // merged — 1.0 had three split ranges here\n  '\\u0370-\\u037D' +\n  '\\u037F-\\u0486\\u0488-\\u1FFF' +       // split to exclude \\u0487 (combining mark, never a NameStartChar)\n  '\\u200C-\\u200D' +\n  '\\u2070-\\u218F' +\n  '\\u2C00-\\u2FEF' +\n  '\\u3001-\\uD7FF' +\n  '\\uF900-\\uFDCF' +\n  '\\uFDF0-\\uFFFD' +\n  '\\u{10000}-\\u{EFFFF}';     // supplementary planes — REQUIRES /u flag on RegExp\n\nconst nameChar11 =\n  nameStartChar11 +\n  '\\\\-\\\\.\\\\d' +\n  '\\u00B7' +\n  '\\u0300-\\u036F' +\n  '\\u0487' +                 // Combining Cyrillic Millions Sign — valid in 1.1, not 1.0\n  '\\u203F-\\u2040';\n\n// ---------------------------------------------------------------------------\n// Regex builders\n//\n// XML 1.0 regexes: no flags — BMP only, standard JS regex behaviour.\n// XML 1.1 regexes: /u flag — required for \\u{10000}-\\u{EFFFF} to match actual\n//   supplementary code points rather than lone surrogates (which are illegal XML).\n// ---------------------------------------------------------------------------\n\nconst buildRegexes = (startChar, char, flags = '') => {\n  const ncStart = startChar.replace(':', '');\n  const ncChar = char.replace(':', '');\n  const ncNamePat = `[${ncStart}][${ncChar}]*`;\n\n  return {\n    name: new RegExp(`^[${startChar}][${char}]*$`, flags),\n    ncName: new RegExp(`^${ncNamePat}$`, flags),\n    qName: new RegExp(`^${ncNamePat}(?::${ncNamePat})?$`, flags),\n    nmToken: new RegExp(`^[${char}]+$`, flags),\n    nmTokens: new RegExp(`^[${char}]+(?:\\\\s+[${char}]+)*$`, flags),\n  };\n};\n\nconst regexes10 = buildRegexes(nameStartChar10, nameChar10);       // no /u — BMP only\nconst regexes11 = buildRegexes(nameStartChar11, nameChar11, 'u');  // /u — enables \\u{10000}-\\u{EFFFF}\n\nconst getRegexes = (xmlVersion = '1.0') =>\n  xmlVersion === '1.1' ? regexes11 : regexes10;\n\n// ---------------------------------------------------------------------------\n// Boolean validators\n// ---------------------------------------------------------------------------\n\n/**\n * Returns true if the string is a valid XML Name.\n * Colons are allowed anywhere (Name production).\n * Used for: DOCTYPE entity names, notation names, DTD element declarations.\n */\nexport const name = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).name.test(str);\n\n/**\n * Returns true if the string is a valid NCName (Non-Colonized Name).\n * Colons are not permitted.\n * Used for: namespace prefixes, local names, SVG id attributes.\n */\nexport const ncName = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).ncName.test(str);\n\n/**\n * Returns true if the string is a valid QName (Qualified Name).\n * Allows exactly one colon as a prefix separator: prefix:localName.\n * Used for: element and attribute names in namespace-aware XML/SVG.\n */\nexport const qName = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).qName.test(str);\n\n/**\n * Returns true if the string is a valid NMToken.\n * Like Name but no restriction on the first character.\n * Used for: DTD NMTOKEN attribute values.\n */\nexport const nmToken = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).nmToken.test(str);\n\n/**\n * Returns true if the string is a valid NMTokens value.\n * A whitespace-separated list of NMToken values.\n * Used for: DTD NMTOKENS attribute values.\n */\nexport const nmTokens = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).nmTokens.test(str);\n\n// ---------------------------------------------------------------------------\n// Diagnostic validator\n// ---------------------------------------------------------------------------\n\nconst PRODUCTIONS = ['name', 'ncName', 'qName', 'nmToken', 'nmTokens'];\n\n/**\n * Validates a string against a named production and returns a detailed result.\n *\n * @param {string} str\n * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production\n * @param {{ xmlVersion?: '1.0'|'1.1' }} [opts]\n * @returns {{ valid: boolean, production: string, input: string, reason?: string, position?: number }}\n */\nexport const validate = (str, production, { xmlVersion = '1.0' } = {}) => {\n  if (!PRODUCTIONS.includes(production)) {\n    throw new TypeError(\n      `Unknown production \"${production}\". Must be one of: ${PRODUCTIONS.join(', ')}`\n    );\n  }\n\n  const validators = { name, ncName, qName, nmToken, nmTokens };\n  const isValid = validators[production](str, { xmlVersion });\n\n  if (isValid) return { valid: true, production, input: str };\n\n  let reason = 'Does not match the production rules';\n  let position;\n\n  if (str.length === 0) {\n    reason = 'Input is empty';\n  } else if (production === 'ncName' && str.includes(':')) {\n    position = str.indexOf(':');\n    reason = 'Colon is not allowed in NCName';\n  } else if (production === 'qName' && str.startsWith(':')) {\n    reason = 'QName cannot start with a colon';\n    position = 0;\n  } else if (production === 'qName' && str.endsWith(':')) {\n    reason = 'QName cannot end with a colon';\n    position = str.length - 1;\n  } else if (production === 'qName' && (str.match(/:/g) || []).length > 1) {\n    reason = 'QName can have at most one colon';\n    position = str.lastIndexOf(':');\n  } else if (\n    ['name', 'ncName', 'qName'].includes(production) &&\n    !/^[:A-Za-z_\\u00C0-\\uFFFD]/.test(str[0])\n  ) {\n    reason = `First character \"${str[0]}\" is not a valid NameStartChar`;\n    position = 0;\n  } else {\n    for (let i = 0; i < str.length; i++) {\n      if (!/[\\w\\-\\\\.:\\u00B7\\u00C0-\\uFFFD]/.test(str[i])) {\n        reason = `Character \"${str[i]}\" at position ${i} is not a valid NameChar`;\n        position = i;\n        break;\n      }\n    }\n  }\n\n  return { valid: false, production, input: str, reason, position };\n};\n\n// ---------------------------------------------------------------------------\n// Batch validator\n// ---------------------------------------------------------------------------\n\n/**\n * Validates an array of strings against a named production.\n *\n * @param {string[]} strings\n * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production\n * @param {{ xmlVersion?: '1.0'|'1.1' }} [opts]\n * @returns {Array<{ valid: boolean, production: string, input: string, reason?: string, position?: number }>}\n */\nexport const validateAll = (strings, production, opts = {}) =>\n  strings.map(str => validate(str, production, opts));\n\n// ---------------------------------------------------------------------------\n// Sanitizer\n// ---------------------------------------------------------------------------\n\n/**\n * Transforms an invalid string into the nearest valid XML name for the given production.\n *\n * @param {string} str\n * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production\n * @param {{ replacement?: string }} [opts]\n * @returns {string}\n */\nexport const sanitize = (str, production = 'name', { replacement = '_' } = {}) => {\n  if (!str) return replacement;\n\n  let result = str;\n\n  // Strip colons for NCName\n  if (production === 'ncName') {\n    result = result.replace(/:/g, '');\n  }\n\n  // Replace illegal characters\n  result = result.replace(/[^\\w\\-\\.:\\u00B7\\u00C0-\\uFFFD]/g, replacement);\n\n  // Fix invalid start character for Name / NCName / QName\n  if (production !== 'nmToken' && production !== 'nmTokens') {\n    if (/^[\\-\\.\\d]/.test(result)) {\n      result = replacement + result;\n    }\n  }\n\n  return result || replacement;\n};","import { qName as isName } from 'xml-naming';\n\nexport default class DocTypeReader {\n    constructor(options, xmlVersion) {\n        this.suppressValidationErr = !options;\n        this.options = options;\n        this.xmlVersion = xmlVersion || 1.0;\n    }\n\n    setXmlVersion(xmlVersion = 1.0) {\n        this.xmlVersion = xmlVersion;\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 != null &&\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                            //const escaped = entityName.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n                            entities[entityName] = val;\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        const startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i]) && xmlData[i] !== '\"' && xmlData[i] !== \"'\") {\n            i++;\n        }\n        let entityName = xmlData.substring(startIndex, i);\n\n        validateEntityName(entityName, { xmlVersion: this.xmlVersion });\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 != null &&\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\n        const startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            i++;\n        }\n        let notationName = xmlData.substring(startIndex, i);\n\n        !this.suppressValidationErr && validateEntityName(notationName, { xmlVersion: this.xmlVersion });\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        const startIndex = i;\n        while (i < xmlData.length && xmlData[i] !== startChar) {\n            i++;\n        }\n        identifierVal = xmlData.substring(startIndex, i);\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        const startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            i++;\n        }\n        let elementName = xmlData.substring(startIndex, i);\n\n        // Validate element name\n        if (!this.suppressValidationErr && !isName(elementName, { xmlVersion: this.xmlVersion })) {\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            const startIndex = i;\n            while (i < xmlData.length && xmlData[i] !== \")\") {\n                i++;\n            }\n            contentModel = xmlData.substring(startIndex, 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 startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            i++;\n        }\n        let elementName = xmlData.substring(startIndex, i);\n\n        // Validate element name\n        validateEntityName(elementName, { xmlVersion: this.xmlVersion })\n\n        // Skip whitespace after element name\n        i = skipWhitespace(xmlData, i);\n\n        // Read attribute name\n        startIndex = i;\n        while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n            i++;\n        }\n        let attributeName = xmlData.substring(startIndex, i);\n\n        // Validate attribute name\n        if (!validateEntityName(attributeName, { xmlVersion: this.xmlVersion })) {\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\n\n                const startIndex = i;\n                while (i < xmlData.length && xmlData[i] !== \"|\" && xmlData[i] !== \")\") {\n                    i++;\n                }\n                let notation = xmlData.substring(startIndex, i);\n\n                // Validate notation name\n                notation = notation.trim();\n                if (!validateEntityName(notation, { xmlVersion: this.xmlVersion })) {\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            const startIndex = i;\n            while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n                i++;\n            }\n            attributeType += xmlData.substring(startIndex, i);\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, xmlVersion) {\n    if (isName(name, { xmlVersion: xmlVersion }))\n        return name;\n    else\n        throw new Error(`Invalid entity name ${name}`);\n}","const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;\nconst binRegex = /^0b[01]+$/;\nconst octRegex = /^0o[0-7]+$/;\nconst numRegex = /^([\\-\\+])?(0*)([0-9]*(\\.[0-9]*)?)$/;\n\nconst consider = {\n    hex: true,\n    binary: false,\n    octal: false,\n    leadingZeros: true,\n    decimalPoint: \"\\.\",\n    eNotation: true,\n    //skipLike: /regex/,\n    infinity: \"original\", // \"null\", \"infinity\" (Infinity type), \"string\" (\"Infinity\" (the string literal))\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 (trimmedStr.length === 0) return str;\n    else if (options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;\n    else if (trimmedStr === \"0\") return 0;\n    else if (options.hex && hexRegex.test(trimmedStr)) {\n        return parse_int(trimmedStr, 16);\n    } else if (options.binary && binRegex.test(trimmedStr)) {\n        return parse_int(trimmedStr, 2);\n    } else if (options.octal && octRegex.test(trimmedStr)) {\n        return parse_int(trimmedStr, 8);\n    } else if (!isFinite(trimmedStr)) { //Infinity\n        return handleInfinity(str, Number(trimmedStr), options);\n    } else if (trimmedStr.includes('e') || trimmedStr.includes('E')) { //eNotation\n        return resolveEnotation(str, trimmedStr, options);\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 (leadingZeros.length > 0) {\n            // Has leading zeros — only accept if leadingZeros option allows it\n            if (options.leadingZeros && !eAdjacentToLeadingZeros) {\n                trimmedStr = (notation[1] || \"\") + notation[3];\n                return Number(trimmedStr);\n            } else return str;\n        } else {\n            // No leading zeros — always valid e-notation, parse it\n            return Number(trimmedStr);\n        }\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    const str = numStr.trim();\n    if (base === 2 || base === 8) numStr = str.substring(2);\n\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\n/**\n * Handle infinite values based on user option\n * @param {string} str - original input string\n * @param {number} num - parsed number (Infinity or -Infinity)\n * @param {object} options - user options\n * @returns {string|number|null} based on infinity option\n */\nfunction handleInfinity(str, num, options) {\n    const isPositive = num === Infinity;\n\n    switch (options.infinity.toLowerCase()) {\n        case \"null\":\n            return null;\n        case \"infinity\":\n            return num; // Return Infinity or -Infinity\n        case \"string\":\n            return isPositive ? \"Infinity\" : \"-Infinity\";\n        case \"original\":\n        default:\n            return str; // Return original string like \"1e1000\"\n    }\n}","import ExpressionSet from \"./ExpressionSet.js\";\n\n/**\n * MatcherView - A lightweight read-only view over a Matcher's internal state.\n *\n * Created once by Matcher and reused across all callbacks. Holds a direct\n * reference to the parent Matcher so it always reflects current parser state\n * with zero copying or freezing overhead.\n *\n * Users receive this via {@link Matcher#readOnly} or directly from parser\n * callbacks. It exposes all query and matching methods but has no mutation\n * methods — misuse is caught at the TypeScript level rather than at runtime.\n *\n * @example\n * const matcher = new Matcher();\n * const view = matcher.readOnly();\n *\n * matcher.push(\"root\", {});\n * view.getCurrentTag(); // \"root\"\n * view.getDepth();      // 1\n */\nexport class MatcherView {\n  /**\n   * @param {Matcher} matcher - The parent Matcher instance to read from.\n   */\n  constructor(matcher) {\n    this._matcher = matcher;\n  }\n\n  /**\n   * Get the path separator used by the parent matcher.\n   * @returns {string}\n   */\n  get separator() {\n    return this._matcher.separator;\n  }\n\n  /**\n   * Get current tag name.\n   * @returns {string|undefined}\n   */\n  getCurrentTag() {\n    const path = this._matcher.path;\n    return path.length > 0 ? path[path.length - 1].tag : undefined;\n  }\n\n  /**\n   * Get current namespace.\n   * @returns {string|undefined}\n   */\n  getCurrentNamespace() {\n    const path = this._matcher.path;\n    return path.length > 0 ? path[path.length - 1].namespace : undefined;\n  }\n\n  /**\n   * Get current node's attribute value.\n   * @param {string} attrName\n   * @returns {*}\n   */\n  getAttrValue(attrName) {\n    const path = this._matcher.path;\n    if (path.length === 0) return undefined;\n    return path[path.length - 1].values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute.\n   * @param {string} attrName\n   * @returns {boolean}\n   */\n  hasAttr(attrName) {\n    const path = this._matcher.path;\n    if (path.length === 0) return false;\n    const current = path[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    const path = this._matcher.path;\n    if (path.length === 0) return -1;\n    return path[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    const path = this._matcher.path;\n    if (path.length === 0) return -1;\n    return path[path.length - 1].counter ?? 0;\n  }\n\n  /**\n   * Get current node's sibling index (alias for getPosition).\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._matcher.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=true]\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    return this._matcher.toString(separator, includeNamespace);\n  }\n\n  /**\n   * Get path as array of tag names.\n   * @returns {string[]}\n   */\n  toArray() {\n    return this._matcher.path.map(n => n.tag);\n  }\n\n  /**\n   * Match current path against an Expression.\n   * @param {Expression} expression\n   * @returns {boolean}\n   */\n  matches(expression) {\n    return this._matcher.matches(expression);\n  }\n\n  /**\n   * Match any expression in the given set against the current path.\n   * @param {ExpressionSet} exprSet\n   * @returns {boolean}\n   */\n  matchesAny(exprSet) {\n    return exprSet.matchesAny(this._matcher);\n  }\n}\n\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 * Use {@link Matcher#readOnly} to obtain a {@link MatcherView} safe to pass to\n * user callbacks — it always reflects current state with no Proxy overhead.\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={}]\n   * @param {string} [options.separator='.'] - Default path separator\n   */\n  constructor(options = {}) {\n    this.separator = options.separator || '.';\n    this.path = [];\n    this.siblingStacks = [];\n    // Each path node: { tag, values, position, counter, namespace? }\n    // values only present for current (last) node\n    // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n    this._pathStringCache = null;\n    this._view = new MatcherView(this);\n  }\n\n  /**\n   * Push a new tag onto the path.\n   * @param {string} tagName\n   * @param {Object|null} [attrValues=null]\n   * @param {string|null} [namespace=null]\n   */\n  push(tagName, attrValues = null, namespace = null) {\n    this._pathStringCache = null;\n\n    // Remove values from previous current node (now becoming ancestor)\n    if (this.path.length > 0) {\n      this.path[this.path.length - 1].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    if (namespace !== null && namespace !== undefined) {\n      node.namespace = namespace;\n    }\n\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) return undefined;\n    this._pathStringCache = null;\n\n    const node = this.path.pop();\n\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\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\n   * @returns {*}\n   */\n  getAttrValue(attrName) {\n    if (this.path.length === 0) return undefined;\n    return this.path[this.path.length - 1].values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute.\n   * @param {string} attrName\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).\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=true]\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    const sep = separator || this.separator;\n    const isDefault = (sep === this.separator && includeNamespace === true);\n\n    if (isDefault) {\n      if (this._pathStringCache !== null) {\n        return this._pathStringCache;\n      }\n      const result = this.path.map(n =>\n        (n.namespace) ? `${n.namespace}:${n.tag}` : n.tag\n      ).join(sep);\n      this._pathStringCache = result;\n      return result;\n    }\n\n    return this.path.map(n =>\n      (includeNamespace && n.namespace) ? `${n.namespace}:${n.tag}` : 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._pathStringCache = null;\n    this.path = [];\n    this.siblingStacks = [];\n  }\n\n  /**\n   * Match current path against an Expression.\n   * @param {Expression} expression\n   * @returns {boolean}\n   */\n  matches(expression) {\n    const segments = expression.segments;\n\n    if (segments.length === 0) {\n      return false;\n    }\n\n    if (expression.hasDeepWildcard()) {\n      return this._matchWithDeepWildcard(segments);\n    }\n\n    return this._matchSimple(segments);\n  }\n\n  /**\n   * @private\n   */\n  _matchSimple(segments) {\n    if (this.path.length !== segments.length) {\n      return false;\n    }\n\n    for (let i = 0; i < segments.length; i++) {\n      if (!this._matchSegment(segments[i], this.path[i], i === this.path.length - 1)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * @private\n   */\n  _matchWithDeepWildcard(segments) {\n    let pathIdx = this.path.length - 1;\n    let segIdx = segments.length - 1;\n\n    while (segIdx >= 0 && pathIdx >= 0) {\n      const segment = segments[segIdx];\n\n      if (segment.type === 'deep-wildcard') {\n        segIdx--;\n\n        if (segIdx < 0) {\n          return true;\n        }\n\n        const nextSeg = segments[segIdx];\n        let found = false;\n\n        for (let i = pathIdx; i >= 0; i--) {\n          if (this._matchSegment(nextSeg, this.path[i], i === this.path.length - 1)) {\n            pathIdx = i - 1;\n            segIdx--;\n            found = true;\n            break;\n          }\n        }\n\n        if (!found) {\n          return false;\n        }\n      } else {\n        if (!this._matchSegment(segment, this.path[pathIdx], pathIdx === this.path.length - 1)) {\n          return false;\n        }\n        pathIdx--;\n        segIdx--;\n      }\n    }\n\n    return segIdx < 0;\n  }\n\n  /**\n   * @private\n   */\n  _matchSegment(segment, node, isCurrentNode) {\n    if (segment.tag !== '*' && segment.tag !== node.tag) {\n      return false;\n    }\n\n    if (segment.namespace !== undefined) {\n      if (segment.namespace !== '*' && segment.namespace !== node.namespace) {\n        return false;\n      }\n    }\n\n    if (segment.attrName !== undefined) {\n      if (!isCurrentNode) {\n        return false;\n      }\n\n      if (!node.values || !(segment.attrName in node.values)) {\n        return false;\n      }\n\n      if (segment.attrValue !== undefined) {\n        if (String(node.values[segment.attrName]) !== String(segment.attrValue)) {\n          return false;\n        }\n      }\n    }\n\n    if (segment.position !== undefined) {\n      if (!isCurrentNode) {\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' && counter !== segment.positionValue) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Match any expression in the given set against the current path.\n   * @param {ExpressionSet} exprSet\n   * @returns {boolean}\n   */\n  matchesAny(exprSet) {\n    return exprSet.matchesAny(this);\n  }\n\n  /**\n   * Create a snapshot of current state.\n   * @returns {Object}\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\n   */\n  restore(snapshot) {\n    this._pathStringCache = null;\n    this.path = snapshot.path.map(node => ({ ...node }));\n    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));\n  }\n\n  /**\n   * Return the read-only {@link MatcherView} for this matcher.\n   *\n   * The same instance is returned on every call — no allocation occurs.\n   * It always reflects the current parser state and is safe to pass to\n   * user callbacks without risk of accidental mutation.\n   *\n   * @returns {MatcherView}\n   *\n   * @example\n   * const view = matcher.readOnly();\n   * // pass view to callbacks — it stays in sync automatically\n   * view.matches(expr);       // ✓\n   * view.getCurrentTag();     // ✓\n   * // view.push(...)         // ✗ method does not exist — caught by TypeScript\n   */\n  readOnly() {\n    return this._view;\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 = {}, data) {\n    this.pattern = pattern;\n    this.separator = options.separator || '.';\n    this.segments = this._parse(pattern);\n    this.data = data;\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}","/**\n * ExpressionSet - An indexed collection of Expressions for efficient bulk matching\n *\n * Instead of iterating all expressions on every tag, ExpressionSet pre-indexes\n * them at insertion time by depth and terminal tag name. At match time, only\n * the relevant bucket is evaluated — typically reducing checks from O(E) to O(1)\n * lookup plus O(small bucket) matches.\n *\n * Three buckets are maintained:\n *  - `_byDepthAndTag`  — exact depth + exact tag name  (tightest, used first)\n *  - `_wildcardByDepth` — exact depth + wildcard tag `*` (depth-matched only)\n *  - `_deepWildcards`  — expressions containing `..`  (cannot be depth-indexed)\n *\n * @example\n * import { Expression, ExpressionSet } from 'fast-xml-tagger';\n *\n * // Build once at config time\n * const stopNodes = new ExpressionSet();\n * stopNodes.add(new Expression('root.users.user'));\n * stopNodes.add(new Expression('root.config.setting'));\n * stopNodes.add(new Expression('..script'));\n *\n * // Query on every tag — hot path\n * if (stopNodes.matchesAny(matcher)) { ... }\n */\nexport default class ExpressionSet {\n  constructor() {\n    /** @type {Map<string, import('./Expression.js').default[]>} depth:tag → expressions */\n    this._byDepthAndTag = new Map();\n\n    /** @type {Map<number, import('./Expression.js').default[]>} depth → wildcard-tag expressions */\n    this._wildcardByDepth = new Map();\n\n    /** @type {import('./Expression.js').default[]} expressions containing deep wildcard (..) */\n    this._deepWildcards = [];\n\n    /** @type {Set<string>} pattern strings already added — used for deduplication */\n    this._patterns = new Set();\n\n    /** @type {boolean} whether the set is sealed against further additions */\n    this._sealed = false;\n  }\n\n  /**\n   * Add an Expression to the set.\n   * Duplicate patterns (same pattern string) are silently ignored.\n   *\n   * @param {import('./Expression.js').default} expression - A pre-constructed Expression instance\n   * @returns {this} for chaining\n   * @throws {TypeError} if called after seal()\n   *\n   * @example\n   * set.add(new Expression('root.users.user'));\n   * set.add(new Expression('..script'));\n   */\n  add(expression) {\n    if (this._sealed) {\n      throw new TypeError(\n        'ExpressionSet is sealed. Create a new ExpressionSet to add more expressions.'\n      );\n    }\n\n    // Deduplicate by pattern string\n    if (this._patterns.has(expression.pattern)) return this;\n    this._patterns.add(expression.pattern);\n\n    if (expression.hasDeepWildcard()) {\n      this._deepWildcards.push(expression);\n      return this;\n    }\n\n    const depth = expression.length;\n    const lastSeg = expression.segments[expression.segments.length - 1];\n    const tag = lastSeg?.tag;\n\n    if (!tag || tag === '*') {\n      // Can index by depth but not by tag\n      if (!this._wildcardByDepth.has(depth)) this._wildcardByDepth.set(depth, []);\n      this._wildcardByDepth.get(depth).push(expression);\n    } else {\n      // Tightest bucket: depth + tag\n      const key = `${depth}:${tag}`;\n      if (!this._byDepthAndTag.has(key)) this._byDepthAndTag.set(key, []);\n      this._byDepthAndTag.get(key).push(expression);\n    }\n\n    return this;\n  }\n\n  /**\n   * Add multiple expressions at once.\n   *\n   * @param {import('./Expression.js').default[]} expressions - Array of Expression instances\n   * @returns {this} for chaining\n   *\n   * @example\n   * set.addAll([\n   *   new Expression('root.users.user'),\n   *   new Expression('root.config.setting'),\n   * ]);\n   */\n  addAll(expressions) {\n    for (const expr of expressions) this.add(expr);\n    return this;\n  }\n\n  /**\n   * Check whether a pattern string is already present in the set.\n   *\n   * @param {import('./Expression.js').default} expression\n   * @returns {boolean}\n   */\n  has(expression) {\n    return this._patterns.has(expression.pattern);\n  }\n\n  /**\n   * Number of expressions in the set.\n   * @type {number}\n   */\n  get size() {\n    return this._patterns.size;\n  }\n\n  /**\n   * Seal the set against further modifications.\n   * Useful to prevent accidental mutations after config is built.\n   * Calling add() or addAll() on a sealed set throws a TypeError.\n   *\n   * @returns {this}\n   */\n  seal() {\n    this._sealed = true;\n    return this;\n  }\n\n  /**\n   * Whether the set has been sealed.\n   * @type {boolean}\n   */\n  get isSealed() {\n    return this._sealed;\n  }\n\n  /**\n   * Test whether the matcher's current path matches any expression in the set.\n   *\n   * Evaluation order (cheapest → most expensive):\n   *  1. Exact depth + tag bucket  — O(1) lookup, typically 0–2 expressions\n   *  2. Depth-only wildcard bucket — O(1) lookup, rare\n   *  3. Deep-wildcard list         — always checked, but usually small\n   *\n   * @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)\n   * @returns {boolean} true if any expression matches the current path\n   *\n   * @example\n   * if (stopNodes.matchesAny(matcher)) {\n   *   // handle stop node\n   * }\n   */\n  matchesAny(matcher) {\n    return this.findMatch(matcher) !== null;\n  }\n  /**\n * Find and return the first Expression that matches the matcher's current path.\n *\n * Uses the same evaluation order as matchesAny (cheapest → most expensive):\n *  1. Exact depth + tag bucket\n *  2. Depth-only wildcard bucket\n *  3. Deep-wildcard list\n *\n * @param {import('./Matcher.js').default} matcher - Matcher instance (or readOnly view)\n * @returns {import('./Expression.js').default | null} the first matching Expression, or null\n *\n * @example\n * const expr = stopNodes.findMatch(matcher);\n * if (expr) {\n *   // access expr.config, expr.pattern, etc.\n * }\n */\n  findMatch(matcher) {\n    const depth = matcher.getDepth();\n    const tag = matcher.getCurrentTag();\n\n    // 1. Tightest bucket — most expressions live here\n    const exactKey = `${depth}:${tag}`;\n    const exactBucket = this._byDepthAndTag.get(exactKey);\n    if (exactBucket) {\n      for (let i = 0; i < exactBucket.length; i++) {\n        if (matcher.matches(exactBucket[i])) return exactBucket[i];\n      }\n    }\n\n    // 2. Depth-matched wildcard-tag expressions\n    const wildcardBucket = this._wildcardByDepth.get(depth);\n    if (wildcardBucket) {\n      for (let i = 0; i < wildcardBucket.length; i++) {\n        if (matcher.matches(wildcardBucket[i])) return wildcardBucket[i];\n      }\n    }\n\n    // 3. Deep wildcards — cannot be pre-filtered by depth or tag\n    for (let i = 0; i < this._deepWildcards.length; i++) {\n      if (matcher.matches(this._deepWildcards[i])) return this._deepWildcards[i];\n    }\n\n    return null;\n  }\n}\n","// ---------------------------------------------------------------------------\n// Complete HTML5 named entity reference\n// Organized by logical categories for easy maintenance and selective importing\n// ---------------------------------------------------------------------------\n\n/**\n * Basic Latin & Special Characters\n * @type {Record<string, string>}\n */\nexport const BASIC_LATIN = {\n  amp: '&',\n  AMP: '&',\n  lt: '<',\n  LT: '<',\n  gt: '>',\n  GT: '>',\n  quot: '\"',\n  QUOT: '\"',\n  apos: \"'\",\n  lsquo: '‘',\n  rsquo: '’',\n  ldquo: '“',\n  rdquo: '”',\n  lsquor: '‚',\n  rsquor: '’',\n  ldquor: '„',\n  bdquo: '„',\n  comma: ',',\n  period: '.',\n  colon: ':',\n  semi: ';',\n  excl: '!',\n  quest: '?',\n  num: '#',\n  dollar: '$',\n  percent: '%',\n  amp: '&',\n  ast: '*',\n  commat: '@',\n  lowbar: '_',\n  verbar: '|',\n  vert: '|',\n  sol: '/',\n  bsol: '\\\\',\n  lbrace: '{',\n  rbrace: '}',\n  lbrack: '[',\n  rbrack: ']',\n  lpar: '(',\n  rpar: ')',\n  nbsp: '\\u00a0',\n  iexcl: '¡',\n  cent: '¢',\n  pound: '£',\n  curren: '¤',\n  yen: '¥',\n  brvbar: '¦',\n  sect: '§',\n  uml: '¨',\n  copy: '©',\n  COPY: '©',\n  ordf: 'ª',\n  laquo: '«',\n  not: '¬',\n  shy: '\\u00ad',\n  reg: '®',\n  REG: '®',\n  macr: '¯',\n  deg: '°',\n  plusmn: '±',\n  sup2: '²',\n  sup3: '³',\n  acute: '´',\n  micro: 'µ',\n  para: '¶',\n  middot: '·',\n  cedil: '¸',\n  sup1: '¹',\n  ordm: 'º',\n  raquo: '»',\n  frac14: '¼',\n  frac12: '½',\n  half: '½',\n  frac34: '¾',\n  iquest: '¿',\n  times: '×',\n  div: '÷',\n  divide: '÷',\n};\n\n/**\n * Latin Extended & Accented Letters (A-Z)\n * @type {Record<string, string>}\n */\nexport const LATIN_ACCENTS = {\n  Agrave: 'À',\n  agrave: 'à',\n  Aacute: 'Á',\n  aacute: 'á',\n  Acirc: 'Â',\n  acirc: 'â',\n  Atilde: 'Ã',\n  atilde: 'ã',\n  Auml: 'Ä',\n  auml: 'ä',\n  Aring: 'Å',\n  aring: 'å',\n  AElig: 'Æ',\n  aelig: 'æ',\n  Ccedil: 'Ç',\n  ccedil: 'ç',\n  Egrave: 'È',\n  egrave: 'è',\n  Eacute: 'É',\n  eacute: 'é',\n  Ecirc: 'Ê',\n  ecirc: 'ê',\n  Euml: 'Ë',\n  euml: 'ë',\n  Igrave: 'Ì',\n  igrave: 'ì',\n  Iacute: 'Í',\n  iacute: 'í',\n  Icirc: 'Î',\n  icirc: 'î',\n  Iuml: 'Ï',\n  iuml: 'ï',\n  ETH: 'Ð',\n  eth: 'ð',\n  Ntilde: 'Ñ',\n  ntilde: 'ñ',\n  Ograve: 'Ò',\n  ograve: 'ò',\n  Oacute: 'Ó',\n  oacute: 'ó',\n  Ocirc: 'Ô',\n  ocirc: 'ô',\n  Otilde: 'Õ',\n  otilde: 'õ',\n  Ouml: 'Ö',\n  ouml: 'ö',\n  Oslash: 'Ø',\n  oslash: 'ø',\n  Ugrave: 'Ù',\n  ugrave: 'ù',\n  Uacute: 'Ú',\n  uacute: 'ú',\n  Ucirc: 'Û',\n  ucirc: 'û',\n  Uuml: 'Ü',\n  uuml: 'ü',\n  Yacute: 'Ý',\n  yacute: 'ý',\n  THORN: 'Þ',\n  thorn: 'þ',\n  szlig: 'ß',\n  yuml: 'ÿ',\n  Yuml: 'Ÿ',\n};\n\n/**\n * Latin Extended (Letters with diacritics)\n * @type {Record<string, string>}\n */\nexport const LATIN_EXTENDED = {\n  Amacr: 'Ā',\n  amacr: 'ā',\n  Abreve: 'Ă',\n  abreve: 'ă',\n  Aogon: 'Ą',\n  aogon: 'ą',\n  Cacute: 'Ć',\n  cacute: 'ć',\n  Ccirc: 'Ĉ',\n  ccirc: 'ĉ',\n  Cdot: 'Ċ',\n  cdot: 'ċ',\n  Ccaron: 'Č',\n  ccaron: 'č',\n  Dcaron: 'Ď',\n  dcaron: 'ď',\n  Dstrok: 'Đ',\n  dstrok: 'đ',\n  Emacr: 'Ē',\n  emacr: 'ē',\n  Ecaron: 'Ě',\n  ecaron: 'ě',\n  Edot: 'Ė',\n  edot: 'ė',\n  Eogon: 'Ę',\n  eogon: 'ę',\n  Gcirc: 'Ĝ',\n  gcirc: 'ĝ',\n  Gbreve: 'Ğ',\n  gbreve: 'ğ',\n  Gdot: 'Ġ',\n  gdot: 'ġ',\n  Gcedil: 'Ģ',\n  Hcirc: 'Ĥ',\n  hcirc: 'ĥ',\n  Hstrok: 'Ħ',\n  hstrok: 'ħ',\n  Itilde: 'Ĩ',\n  itilde: 'ĩ',\n  Imacr: 'Ī',\n  imacr: 'ī',\n  Iogon: 'Į',\n  iogon: 'į',\n  Idot: 'İ',\n  IJlig: 'IJ',\n  ijlig: 'ij',\n  Jcirc: 'Ĵ',\n  jcirc: 'ĵ',\n  Kcedil: 'Ķ',\n  kcedil: 'ķ',\n  kgreen: 'ĸ',\n  Lacute: 'Ĺ',\n  lacute: 'ĺ',\n  Lcedil: 'Ļ',\n  lcedil: 'ļ',\n  Lcaron: 'Ľ',\n  lcaron: 'ľ',\n  Lmidot: 'Ŀ',\n  lmidot: 'ŀ',\n  Lstrok: 'Ł',\n  lstrok: 'ł',\n  Nacute: 'Ń',\n  nacute: 'ń',\n  Ncaron: 'Ň',\n  ncaron: 'ň',\n  Ncedil: 'Ņ',\n  ncedil: 'ņ',\n  ENG: 'Ŋ',\n  eng: 'ŋ',\n  Omacr: 'Ō',\n  omacr: 'ō',\n  Odblac: 'Ő',\n  odblac: 'ő',\n  OElig: 'Œ',\n  oelig: 'œ',\n  Racute: 'Ŕ',\n  racute: 'ŕ',\n  Rcaron: 'Ř',\n  rcaron: 'ř',\n  Rcedil: 'Ŗ',\n  rcedil: 'ŗ',\n  Sacute: 'Ś',\n  sacute: 'ś',\n  Scirc: 'Ŝ',\n  scirc: 'ŝ',\n  Scedil: 'Ş',\n  scedil: 'ş',\n  Scaron: 'Š',\n  scaron: 'š',\n  Tcedil: 'Ţ',\n  tcedil: 'ţ',\n  Tcaron: 'Ť',\n  tcaron: 'ť',\n  Tstrok: 'Ŧ',\n  tstrok: 'ŧ',\n  Utilde: 'Ũ',\n  utilde: 'ũ',\n  Umacr: 'Ū',\n  umacr: 'ū',\n  Ubreve: 'Ŭ',\n  ubreve: 'ŭ',\n  Uring: 'Ů',\n  uring: 'ů',\n  Udblac: 'Ű',\n  udblac: 'ű',\n  Uogon: 'Ų',\n  uogon: 'ų',\n  Wcirc: 'Ŵ',\n  wcirc: 'ŵ',\n  Ycirc: 'Ŷ',\n  ycirc: 'ŷ',\n  Zacute: 'Ź',\n  zacute: 'ź',\n  Zdot: 'Ż',\n  zdot: 'ż',\n  Zcaron: 'Ž',\n  zcaron: 'ž',\n};\n\n/**\n * Greek Letters\n * @type {Record<string, string>}\n */\nexport const GREEK = {\n  Alpha: 'Α',\n  alpha: 'α',\n  Beta: 'Β',\n  beta: 'β',\n  Gamma: 'Γ',\n  gamma: 'γ',\n  Delta: 'Δ',\n  delta: 'δ',\n  Epsilon: 'Ε',\n  epsilon: 'ε',\n  epsiv: 'ϵ',\n  varepsilon: 'ϵ',\n  Zeta: 'Ζ',\n  zeta: 'ζ',\n  Eta: 'Η',\n  eta: 'η',\n  Theta: 'Θ',\n  theta: 'θ',\n  thetasym: 'ϑ',\n  vartheta: 'ϑ',\n  Iota: 'Ι',\n  iota: 'ι',\n  Kappa: 'Κ',\n  kappa: 'κ',\n  kappav: 'ϰ',\n  varkappa: 'ϰ',\n  Lambda: 'Λ',\n  lambda: 'λ',\n  Mu: 'Μ',\n  mu: 'μ',\n  Nu: 'Ν',\n  nu: 'ν',\n  Xi: 'Ξ',\n  xi: 'ξ',\n  Omicron: 'Ο',\n  omicron: 'ο',\n  Pi: 'Π',\n  pi: 'π',\n  piv: 'ϖ',\n  varpi: 'ϖ',\n  Rho: 'Ρ',\n  rho: 'ρ',\n  rhov: 'ϱ',\n  varrho: 'ϱ',\n  Sigma: 'Σ',\n  sigma: 'σ',\n  sigmaf: 'ς',\n  sigmav: 'ς',\n  varsigma: 'ς',\n  Tau: 'Τ',\n  tau: 'τ',\n  Upsilon: 'Υ',\n  upsilon: 'υ',\n  upsi: 'υ',\n  Upsi: 'ϒ',\n  upsih: 'ϒ',\n  Phi: 'Φ',\n  phi: 'φ',\n  phiv: 'ϕ',\n  varphi: 'ϕ',\n  Chi: 'Χ',\n  chi: 'χ',\n  Psi: 'Ψ',\n  psi: 'ψ',\n  Omega: 'Ω',\n  omega: 'ω',\n  ohm: 'Ω',\n  Gammad: 'Ϝ',\n  gammad: 'ϝ',\n  digamma: 'ϝ',\n};\n\n/**\n * Cyrillic Letters\n * @type {Record<string, string>}\n */\nexport const CYRILLIC = {\n  Afr: '𝔄',\n  afr: '𝔞',\n  Acy: 'А',\n  acy: 'а',\n  Bcy: 'Б',\n  bcy: 'б',\n  Vcy: 'В',\n  vcy: 'в',\n  Gcy: 'Г',\n  gcy: 'г',\n  Dcy: 'Д',\n  dcy: 'д',\n  IEcy: 'Е',\n  iecy: 'е',\n  IOcy: 'Ё',\n  iocy: 'ё',\n  ZHcy: 'Ж',\n  zhcy: 'ж',\n  Zcy: 'З',\n  zcy: 'з',\n  Icy: 'И',\n  icy: 'и',\n  Jcy: 'Й',\n  jcy: 'й',\n  Kcy: 'К',\n  kcy: 'к',\n  Lcy: 'Л',\n  lcy: 'л',\n  Mcy: 'М',\n  mcy: 'м',\n  Ncy: 'Н',\n  ncy: 'н',\n  Ocy: 'О',\n  ocy: 'о',\n  Pcy: 'П',\n  pcy: 'п',\n  Rcy: 'Р',\n  rcy: 'р',\n  Scy: 'С',\n  scy: 'с',\n  Tcy: 'Т',\n  tcy: 'т',\n  Ucy: 'У',\n  ucy: 'у',\n  Fcy: 'Ф',\n  fcy: 'ф',\n  KHcy: 'Х',\n  khcy: 'х',\n  TScy: 'Ц',\n  tscy: 'ц',\n  CHcy: 'Ч',\n  chcy: 'ч',\n  SHcy: 'Ш',\n  shcy: 'ш',\n  SHCHcy: 'Щ',\n  shchcy: 'щ',\n  HARDcy: 'Ъ',\n  hardcy: 'ъ',\n  Ycy: 'Ы',\n  ycy: 'ы',\n  SOFTcy: 'Ь',\n  softcy: 'ь',\n  Ecy: 'Э',\n  ecy: 'э',\n  YUcy: 'Ю',\n  yucy: 'ю',\n  YAcy: 'Я',\n  yacy: 'я',\n  DJcy: 'Ђ',\n  djcy: 'ђ',\n  GJcy: 'Ѓ',\n  gjcy: 'ѓ',\n  Jukcy: 'Є',\n  jukcy: 'є',\n  DScy: 'Ѕ',\n  dscy: 'ѕ',\n  Iukcy: 'І',\n  iukcy: 'і',\n  YIcy: 'Ї',\n  yicy: 'ї',\n  Jsercy: 'Ј',\n  jsercy: 'ј',\n  LJcy: 'Љ',\n  ljcy: 'љ',\n  NJcy: 'Њ',\n  njcy: 'њ',\n  TSHcy: 'Ћ',\n  tshcy: 'ћ',\n  KJcy: 'Ќ',\n  kjcy: 'ќ',\n  Ubrcy: 'Ў',\n  ubrcy: 'ў',\n  DZcy: 'Џ',\n  dzcy: 'џ',\n};\n\n/**\n * Mathematical Operators & Relations\n * @type {Record<string, string>}\n */\nexport const MATH = {\n  plus: '+',\n  minus: '−',\n  mnplus: '∓',\n  mp: '∓',\n  pm: '±',\n  times: '×',\n  div: '÷',\n  divide: '÷',\n  sdot: '⋅',\n  star: '☆',\n  starf: '★',\n  bigstar: '★',\n  lowast: '∗',\n  ast: '*',\n  midast: '*',\n  compfn: '∘',\n  smallcircle: '∘',\n  bullet: '•',\n  bull: '•',\n  nbsp: '\\u00a0',\n  hellip: '…',\n  mldr: '…',\n  prime: '′',\n  Prime: '″',\n  tprime: '‴',\n  bprime: '‵',\n  backprime: '‵',\n  minus: '−',\n  minusd: '∸',\n  dotminus: '∸',\n  plusdo: '∔',\n  dotplus: '∔',\n  plusmn: '±',\n  minusplus: '∓',\n  mnplus: '∓',\n  mp: '∓',\n  setminus: '∖',\n  smallsetminus: '∖',\n  Backslash: '∖',\n  setmn: '∖',\n  ssetmn: '∖',\n  lowbar: '_',\n  verbar: '|',\n  vert: '|',\n  VerticalLine: '|',\n  colon: ':',\n  Colon: '∷',\n  Proportion: '∷',\n  ratio: '∶',\n  equals: '=',\n  ne: '≠',\n  nequiv: '≢',\n  equiv: '≡',\n  Congruent: '≡',\n  sim: '∼',\n  thicksim: '∼',\n  thksim: '∼',\n  sime: '≃',\n  simeq: '≃',\n  TildeEqual: '≃',\n  asymp: '≈',\n  approx: '≈',\n  thickapprox: '≈',\n  thkap: '≈',\n  TildeTilde: '≈',\n  ncong: '≇',\n  cong: '≅',\n  TildeFullEqual: '≅',\n  asympeq: '≍',\n  CupCap: '≍',\n  bump: '≎',\n  Bumpeq: '≎',\n  HumpDownHump: '≎',\n  bumpe: '≏',\n  bumpeq: '≏',\n  HumpEqual: '≏',\n  dotminus: '∸',\n  minusd: '∸',\n  plusdo: '∔',\n  dotplus: '∔',\n  le: '≤',\n  LessEqual: '≤',\n  ge: '≥',\n  GreaterEqual: '≥',\n  lesseqgtr: '⋚',\n  lesseqqgtr: '⪋',\n  greater: '>',\n  less: '<',\n};\n\n/**\n * Mathematical Operators (Advanced)\n * @type {Record<string, string>}\n */\nexport const MATH_ADVANCED = {\n  alefsym: 'ℵ',\n  aleph: 'ℵ',\n  beth: 'ℶ',\n  gimel: 'ℷ',\n  daleth: 'ℸ',\n  forall: '∀',\n  ForAll: '∀',\n  part: '∂',\n  PartialD: '∂',\n  exist: '∃',\n  Exists: '∃',\n  nexist: '∄',\n  nexists: '∄',\n  empty: '∅',\n  emptyset: '∅',\n  emptyv: '∅',\n  varnothing: '∅',\n  nabla: '∇',\n  Del: '∇',\n  isin: '∈',\n  isinv: '∈',\n  in: '∈',\n  Element: '∈',\n  notin: '∉',\n  notinva: '∉',\n  ni: '∋',\n  niv: '∋',\n  SuchThat: '∋',\n  ReverseElement: '∋',\n  notni: '∌',\n  notniva: '∌',\n  prod: '∏',\n  Product: '∏',\n  coprod: '∐',\n  Coproduct: '∐',\n  sum: '∑',\n  Sum: '∑',\n  minus: '−',\n  mp: '∓',\n  plusdo: '∔',\n  dotplus: '∔',\n  setminus: '∖',\n  lowast: '∗',\n  radic: '√',\n  Sqrt: '√',\n  prop: '∝',\n  propto: '∝',\n  Proportional: '∝',\n  varpropto: '∝',\n  infin: '∞',\n  infintie: '⧝',\n  ang: '∠',\n  angle: '∠',\n  angmsd: '∡',\n  measuredangle: '∡',\n  angsph: '∢',\n  mid: '∣',\n  VerticalBar: '∣',\n  nmid: '∤',\n  nsmid: '∤',\n  npar: '∦',\n  parallel: '∥',\n  spar: '∥',\n  nparallel: '∦',\n  nspar: '∦',\n  and: '∧',\n  wedge: '∧',\n  or: '∨',\n  vee: '∨',\n  cap: '∩',\n  cup: '∪',\n  int: '∫',\n  Integral: '∫',\n  conint: '∮',\n  ContourIntegral: '∮',\n  Conint: '∯',\n  DoubleContourIntegral: '∯',\n  Cconint: '∰',\n  there4: '∴',\n  therefore: '∴',\n  Therefore: '∴',\n  becaus: '∵',\n  because: '∵',\n  Because: '∵',\n  ratio: '∶',\n  Proportion: '∷',\n  minusd: '∸',\n  dotminus: '∸',\n  mDDot: '∺',\n  homtht: '∻',\n  sim: '∼',\n  bsimg: '∽',\n  backsim: '∽',\n  ac: '∾',\n  mstpos: '∾',\n  acd: '∿',\n  VerticalTilde: '≀',\n  wr: '≀',\n  wreath: '≀',\n  nsime: '≄',\n  nsimeq: '≄',\n  nsimeq: '≄',\n  ncong: '≇',\n  simne: '≆',\n  ncongdot: '⩭̸',\n  ngsim: '≵',\n  nsim: '≁',\n  napprox: '≉',\n  nap: '≉',\n  ngeq: '≱',\n  nge: '≱',\n  nleq: '≰',\n  nle: '≰',\n  ngtr: '≯',\n  ngt: '≯',\n  nless: '≮',\n  nlt: '≮',\n  nprec: '⊀',\n  npr: '⊀',\n  nsucc: '⊁',\n  nsc: '⊁',\n};\n\n/**\n * Arrows\n * @type {Record<string, string>}\n */\nexport const ARROWS = {\n  larr: '←',\n  leftarrow: '←',\n  LeftArrow: '←',\n  uarr: '↑',\n  uparrow: '↑',\n  UpArrow: '↑',\n  rarr: '→',\n  rightarrow: '→',\n  RightArrow: '→',\n  darr: '↓',\n  downarrow: '↓',\n  DownArrow: '↓',\n  harr: '↔',\n  leftrightarrow: '↔',\n  LeftRightArrow: '↔',\n  varr: '↕',\n  updownarrow: '↕',\n  UpDownArrow: '↕',\n  nwarr: '↖',\n  nwarrow: '↖',\n  UpperLeftArrow: '↖',\n  nearr: '↗',\n  nearrow: '↗',\n  UpperRightArrow: '↗',\n  searr: '↘',\n  searrow: '↘',\n  LowerRightArrow: '↘',\n  swarr: '↙',\n  swarrow: '↙',\n  LowerLeftArrow: '↙',\n  lArr: '⇐',\n  Leftarrow: '⇐',\n  uArr: '⇑',\n  Uparrow: '⇑',\n  rArr: '⇒',\n  Rightarrow: '⇒',\n  dArr: '⇓',\n  Downarrow: '⇓',\n  hArr: '⇔',\n  Leftrightarrow: '⇔',\n  iff: '⇔',\n  vArr: '⇕',\n  Updownarrow: '⇕',\n  lAarr: '⇚',\n  Lleftarrow: '⇚',\n  rAarr: '⇛',\n  Rrightarrow: '⇛',\n  lrarr: '⇆',\n  leftrightarrows: '⇆',\n  rlarr: '⇄',\n  rightleftarrows: '⇄',\n  lrhar: '⇋',\n  leftrightharpoons: '⇋',\n  ReverseEquilibrium: '⇋',\n  rlhar: '⇌',\n  rightleftharpoons: '⇌',\n  Equilibrium: '⇌',\n  udarr: '⇅',\n  UpArrowDownArrow: '⇅',\n  duarr: '⇵',\n  DownArrowUpArrow: '⇵',\n  llarr: '⇇',\n  leftleftarrows: '⇇',\n  rrarr: '⇉',\n  rightrightarrows: '⇉',\n  ddarr: '⇊',\n  downdownarrows: '⇊',\n  har: '↽',\n  lhard: '↽',\n  leftharpoondown: '↽',\n  lharu: '↼',\n  leftharpoonup: '↼',\n  rhard: '⇁',\n  rightharpoondown: '⇁',\n  rharu: '⇀',\n  rightharpoonup: '⇀',\n  lsh: '↰',\n  Lsh: '↰',\n  rsh: '↱',\n  Rsh: '↱',\n  ldsh: '↲',\n  rdsh: '↳',\n  hookleftarrow: '↩',\n  hookrightarrow: '↪',\n  mapstoleft: '↤',\n  mapstoup: '↥',\n  map: '↦',\n  mapsto: '↦',\n  mapstodown: '↧',\n  crarr: '↵',\n  nwarrow: '↖',\n  nearrow: '↗',\n  searrow: '↘',\n  swarrow: '↙',\n  nleftarrow: '↚',\n  nleftrightarrow: '↮',\n  nrightarrow: '↛',\n  nrarr: '↛',\n  larrtl: '↢',\n  rarrtl: '↣',\n  leftarrowtail: '↢',\n  rightarrowtail: '↣',\n  twoheadleftarrow: '↞',\n  twoheadrightarrow: '↠',\n  Larr: '↞',\n  Rarr: '↠',\n  larrhk: '↩',\n  rarrhk: '↪',\n  larrlp: '↫',\n  looparrowleft: '↫',\n  rarrlp: '↬',\n  looparrowright: '↬',\n  harrw: '↭',\n  leftrightsquigarrow: '↭',\n  nrarrw: '↝̸',\n  rarrw: '↝',\n  rightsquigarrow: '↝',\n  larrbfs: '⤟',\n  rarrbfs: '⤠',\n  nvHarr: '⤄',\n  nvlArr: '⤂',\n  nvrArr: '⤃',\n  larrfs: '⤝',\n  rarrfs: '⤞',\n  Map: '⤅',\n  larrsim: '⥳',\n  rarrsim: '⥴',\n  harrcir: '⥈',\n  Uarrocir: '⥉',\n  lurdshar: '⥊',\n  ldrdhar: '⥧',\n  ldrushar: '⥋',\n  rdldhar: '⥩',\n  lrhard: '⥭',\n  rlhar: '⇌',\n  uharr: '↾',\n  uharl: '↿',\n  dharr: '⇂',\n  dharl: '⇃',\n  Uarr: '↟',\n  Darr: '↡',\n  zigrarr: '⇝',\n  nwArr: '⇖',\n  neArr: '⇗',\n  seArr: '⇘',\n  swArr: '⇙',\n  nharr: '↮',\n  nhArr: '⇎',\n  nlarr: '↚',\n  nlArr: '⇍',\n  nrarr: '↛',\n  nrArr: '⇏',\n  larrb: '⇤',\n  LeftArrowBar: '⇤',\n  rarrb: '⇥',\n  RightArrowBar: '⇥',\n};\n\n/**\n * Geometric Shapes\n * @type {Record<string, string>}\n */\nexport const SHAPES = {\n  square: '□',\n  Square: '□',\n  squ: '□',\n  squf: '▪',\n  squarf: '▪',\n  blacksquar: '▪',\n  blacksquare: '▪',\n  FilledVerySmallSquare: '▪',\n  blk34: '▓',\n  blk12: '▒',\n  blk14: '░',\n  block: '█',\n  srect: '▭',\n  rect: '▭',\n  sdot: '⋅',\n  sdotb: '⊡',\n  dotsquare: '⊡',\n  triangle: '▵',\n  tri: '▵',\n  trine: '▵',\n  utri: '▵',\n  triangledown: '▿',\n  dtri: '▿',\n  tridown: '▿',\n  triangleleft: '◃',\n  ltri: '◃',\n  triangleright: '▹',\n  rtri: '▹',\n  blacktriangle: '▴',\n  utrif: '▴',\n  blacktriangledown: '▾',\n  dtrif: '▾',\n  blacktriangleleft: '◂',\n  ltrif: '◂',\n  blacktriangleright: '▸',\n  rtrif: '▸',\n  loz: '◊',\n  lozenge: '◊',\n  blacklozenge: '⧫',\n  lozf: '⧫',\n  bigcirc: '◯',\n  xcirc: '◯',\n  circ: 'ˆ',\n  Circle: '○',\n  cir: '○',\n  o: '○',\n  bullet: '•',\n  bull: '•',\n  hellip: '…',\n  mldr: '…',\n  nldr: '‥',\n  boxh: '─',\n  HorizontalLine: '─',\n  boxv: '│',\n  boxdr: '┌',\n  boxdl: '┐',\n  boxur: '└',\n  boxul: '┘',\n  boxvr: '├',\n  boxvl: '┤',\n  boxhd: '┬',\n  boxhu: '┴',\n  boxvh: '┼',\n  boxH: '═',\n  boxV: '║',\n  boxdR: '╒',\n  boxDr: '╓',\n  boxDR: '╔',\n  boxDl: '╕',\n  boxdL: '╖',\n  boxDL: '╗',\n  boxuR: '╘',\n  boxUr: '╙',\n  boxUR: '╚',\n  boxUl: '╜',\n  boxuL: '╛',\n  boxUL: '╝',\n  boxvR: '╞',\n  boxVr: '╟',\n  boxVR: '╠',\n  boxVl: '╢',\n  boxvL: '╡',\n  boxVL: '╣',\n  boxHd: '╤',\n  boxhD: '╥',\n  boxHD: '╦',\n  boxHu: '╧',\n  boxhU: '╨',\n  boxHU: '╩',\n  boxvH: '╪',\n  boxVh: '╫',\n  boxVH: '╬',\n};\n\n/**\n * Punctuation & Diacritics\n * @type {Record<string, string>}\n */\nexport const PUNCTUATION = {\n  excl: '!',\n  iexcl: '¡',\n  brvbar: '¦',\n  sect: '§',\n  uml: '¨',\n  copy: '©',\n  ordf: 'ª',\n  laquo: '«',\n  not: '¬',\n  shy: '\\u00ad',\n  reg: '®',\n  macr: '¯',\n  deg: '°',\n  plusmn: '±',\n  sup2: '²',\n  sup3: '³',\n  acute: '´',\n  micro: 'µ',\n  para: '¶',\n  middot: '·',\n  cedil: '¸',\n  sup1: '¹',\n  ordm: 'º',\n  raquo: '»',\n  frac14: '¼',\n  frac12: '½',\n  frac34: '¾',\n  iquest: '¿',\n  nbsp: '\\u00a0',\n  comma: ',',\n  period: '.',\n  colon: ':',\n  semi: ';',\n  vert: '|',\n  Verbar: '‖',\n  verbar: '|',\n  dblac: '˝',\n  circ: 'ˆ',\n  caron: 'ˇ',\n  breve: '˘',\n  dot: '˙',\n  ring: '˚',\n  ogon: '˛',\n  tilde: '˜',\n  DiacriticalGrave: '`',\n  DiacriticalAcute: '´',\n  DiacriticalTilde: '˜',\n  DiacriticalDot: '˙',\n  DiacriticalDoubleAcute: '˝',\n  grave: '`',\n  acute: '´',\n};\n\n/**\n * Currency Symbols\n * @type {Record<string, string>}\n */\nexport const CURRENCY = {\n  cent: '¢',\n  pound: '£',\n  curren: '¤',\n  yen: '¥',\n  euro: '€',\n  dollar: '$',\n  euro: '€',\n  fnof: 'ƒ',\n  inr: '₹',\n  af: '؋',\n  birr: 'ብር',\n  peso: '₱',\n  rub: '₽',\n  won: '₩',\n  yuan: '¥',\n  cedil: '¸',\n};\n\n/**\n * Fractions\n * @type {Record<string, string>}\n */\nexport const FRACTIONS = {\n  frac12: '½',\n  half: '½',\n  frac13: '⅓',\n  frac14: '¼',\n  frac15: '⅕',\n  frac16: '⅙',\n  frac18: '⅛',\n  frac23: '⅔',\n  frac25: '⅖',\n  frac34: '¾',\n  frac35: '⅗',\n  frac38: '⅜',\n  frac45: '⅘',\n  frac56: '⅚',\n  frac58: '⅝',\n  frac78: '⅞',\n  frasl: '⁄',\n};\n\n/**\n * Miscellaneous Symbols\n * @type {Record<string, string>}\n */\nexport const MISC_SYMBOLS = {\n  trade: '™',\n  TRADE: '™',\n  telrec: '⌕',\n  target: '⌖',\n  ulcorn: '⌜',\n  ulcorner: '⌜',\n  urcorn: '⌝',\n  urcorner: '⌝',\n  dlcorn: '⌞',\n  llcorner: '⌞',\n  drcorn: '⌟',\n  lrcorner: '⌟',\n  intercal: '⊺',\n  intcal: '⊺',\n  oplus: '⊕',\n  CirclePlus: '⊕',\n  ominus: '⊖',\n  CircleMinus: '⊖',\n  otimes: '⊗',\n  CircleTimes: '⊗',\n  osol: '⊘',\n  odot: '⊙',\n  CircleDot: '⊙',\n  oast: '⊛',\n  circledast: '⊛',\n  odash: '⊝',\n  circleddash: '⊝',\n  ocirc: '⊚',\n  circledcirc: '⊚',\n  boxplus: '⊞',\n  plusb: '⊞',\n  boxminus: '⊟',\n  minusb: '⊟',\n  boxtimes: '⊠',\n  timesb: '⊠',\n  boxdot: '⊡',\n  sdotb: '⊡',\n  veebar: '⊻',\n  vee: '∨',\n  barvee: '⊽',\n  and: '∧',\n  wedge: '∧',\n  Cap: '⋒',\n  Cup: '⋓',\n  Fork: '⋔',\n  pitchfork: '⋔',\n  epar: '⋕',\n  ltlarr: '⥶',\n  nvap: '≍⃒',\n  nvsim: '∼⃒',\n  nvge: '≥⃒',\n  nvle: '≤⃒',\n  nvlt: '<⃒',\n  nvgt: '>⃒',\n  nvltrie: '⊴⃒',\n  nvrtrie: '⊵⃒',\n  Vdash: '⊩',\n  dashv: '⊣',\n  vDash: '⊨',\n  Vdash: '⊩',\n  Vvdash: '⊪',\n  nvdash: '⊬',\n  nvDash: '⊭',\n  nVdash: '⊮',\n  nVDash: '⊯',\n};\n\n/**\n * All entities combined (if you need everything)\n * @type {Record<string, string>}\n */\nexport const ALL_ENTITIES = {\n  ...BASIC_LATIN,\n  ...LATIN_ACCENTS,\n  ...LATIN_EXTENDED,\n  ...GREEK,\n  ...CYRILLIC,\n  ...MATH,\n  ...MATH_ADVANCED,\n  ...ARROWS,\n  ...SHAPES,\n  ...PUNCTUATION,\n  ...CURRENCY,\n  ...FRACTIONS,\n  ...MISC_SYMBOLS,\n};\n\nexport const XML = {\n  amp: \"&\",\n  apos: \"'\",\n  gt: \">\",\n  lt: \"<\",\n  quot: \"\\\"\"\n}\nexport const COMMON_HTML = {\n  nbsp: '\\u00a0',\n  copy: '\\u00a9',\n  reg: '\\u00ae',\n  trade: '\\u2122',\n  mdash: '\\u2014',\n  ndash: '\\u2013',\n  hellip: '\\u2026',\n  laquo: '\\u00ab',\n  raquo: '\\u00bb',\n  lsquo: '\\u2018',\n  rsquo: '\\u2019',\n  ldquo: '\\u201c',\n  rdquo: '\\u201d',\n  bull: '\\u2022',\n  para: '\\u00b6',\n  sect: '\\u00a7',\n  deg: '\\u00b0',\n  frac12: '\\u00bd',\n  frac14: '\\u00bc',\n  frac34: '\\u00be',\n}\n// ---------------------------------------------------------------------------\n// Note: NUMERIC_ENTITIES (&#NNN; / &#xHH;) are handled by the scanner directly\n// via String.fromCodePoint() without any map lookup.\n// ---------------------------------------------------------------------------","// ---------------------------------------------------------------------------\n// Built-in named entity map  (name → replacement string)\n// No regex, no {regex,val} objects — just flat key/value pairs.\n// ---------------------------------------------------------------------------\n\nimport { XML as DEFAULT_XML_ENTITIES } from \"./entities.js\"\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nconst SPECIAL_CHARS = new Set('!?\\\\\\\\/[]$%{}^&*()<>|+');\n\n/**\n * Validate that an entity name contains no dangerous characters.\n * @param {string} name\n * @returns {string} the name, unchanged\n * @throws {Error} on invalid characters\n */\nfunction validateEntityName(name) {\n  if (name[0] === '#') {\n    throw new Error(`[EntityReplacer] Invalid character '#' in entity name: \"${name}\"`);\n  }\n  for (const ch of name) {\n    if (SPECIAL_CHARS.has(ch)) {\n      throw new Error(`[EntityReplacer] Invalid character '${ch}' in entity name: \"${name}\"`);\n    }\n  }\n  return name;\n}\n\n/**\n * Merge one or more entity maps into a flat name→string map.\n * Accepts either:\n *   - plain string values:             { amp: '&' }\n *   - legacy {regex,val} / {regx,val}: { lt: { regex: /.../, val: '<' } }\n *\n * Values containing '&' are skipped (recursive expansion risk).\n *\n * @param {...object} maps\n * @returns {Record<string, string>}\n */\nfunction mergeEntityMaps(...maps) {\n  const out = Object.create(null);\n  for (const map of maps) {\n    if (!map) continue;\n    for (const key of Object.keys(map)) {\n      const raw = map[key];\n      if (typeof raw === 'string') {\n        out[key] = raw;\n      } else if (raw && typeof raw === 'object' && raw.val !== undefined) {\n        // Legacy {regex,val} or {regx,val} — extract the string val only\n        const val = raw.val;\n        if (typeof val === 'string') {\n          out[key] = val;\n        }\n        // function vals are not supported in the scanner — skip\n      }\n    }\n  }\n  return out;\n}\n\n// ---------------------------------------------------------------------------\n// applyLimitsTo helpers\n// ---------------------------------------------------------------------------\n\nconst LIMIT_TIER_EXTERNAL = 'external'; // input/runtime + persistent external maps\nconst LIMIT_TIER_BASE = 'base';     // DEFAULT_XML_ENTITIES + namedEntities (system) maps\nconst LIMIT_TIER_ALL = 'all';      // every entity regardless of tier\n\n/**\n * Resolve `applyLimitsTo` option into a normalised Set of tier strings.\n * Accepted values: 'external' | 'base' | 'all' | string[]\n * Default: 'external' (only untrusted injected entities are counted).\n * @param {string|string[]|undefined} raw\n * @returns {Set<string>}\n */\nfunction parseLimitTiers(raw) {\n  if (!raw || raw === LIMIT_TIER_EXTERNAL) return new Set([LIMIT_TIER_EXTERNAL]);\n  if (raw === LIMIT_TIER_ALL) return new Set([LIMIT_TIER_ALL]);\n  if (raw === LIMIT_TIER_BASE) return new Set([LIMIT_TIER_BASE]);\n  if (Array.isArray(raw)) return new Set(raw);\n  return new Set([LIMIT_TIER_EXTERNAL]); // safe default for unrecognised values\n}\n\n// ---------------------------------------------------------------------------\n// NCR (Numeric Character Reference) classification\n// ---------------------------------------------------------------------------\n\n// Severity order — higher number = stricter action.\n// Used to enforce minimum action levels for specific codepoint ranges.\nconst NCR_LEVEL = Object.freeze({ allow: 0, leave: 1, remove: 2, throw: 3 });\n\n// XML 1.0 §2.2: allowed chars are #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]\n// Restricted C0: U+0001–U+001F excluding U+0009, U+000A, U+000D\nconst XML10_ALLOWED_C0 = new Set([0x09, 0x0A, 0x0D]);\n\n/**\n * Parse the `ncr` constructor option into flat, hot-path-friendly fields.\n * @param {object|undefined} ncr\n * @returns {{ xmlVersion: number, onLevel: number, nullLevel: number }}\n */\nfunction parseNCRConfig(ncr) {\n  if (!ncr) {\n    return { xmlVersion: 1.0, onLevel: NCR_LEVEL.allow, nullLevel: NCR_LEVEL.remove };\n  }\n  const xmlVersion = ncr.xmlVersion === 1.1 ? 1.1 : 1.0;\n  const onLevel = NCR_LEVEL[ncr.onNCR] ?? NCR_LEVEL.allow;\n  const nullLevel = NCR_LEVEL[ncr.nullNCR] ?? NCR_LEVEL.remove;\n  // 'allow' is not meaningful for null — clamp to at least 'remove'\n  const clampedNull = Math.max(nullLevel, NCR_LEVEL.remove);\n  return { xmlVersion, onLevel, nullLevel: clampedNull };\n}\n\n// ---------------------------------------------------------------------------\n// EntityReplacer\n// ---------------------------------------------------------------------------\n\n/**\n * Single-pass, zero-regex entity replacer for XML/HTML content.\n *\n * Algorithm: scan the string once for '&', read to ';', resolve via map\n * or direct codepoint conversion, build output chunks, join once at the end.\n *\n * Entity lookup priority (highest → lowest):\n *   1. input / runtime  (DOCTYPE entities for current document)\n *   2. persistent external (survive across documents)\n *   3. base named map   (DEFAULT_XML_ENTITIES + user-supplied namedEntities)\n *\n * Both input and external resolve as the 'external' tier for limit purposes.\n * Base map entities resolve as the 'base' tier.\n *\n * Numeric / hex references (&#NNN; / &#xHH;) are resolved directly via\n * String.fromCodePoint() — no map needed. They count as 'base' tier.\n *\n * @example\n * const replacer = new EntityReplacer({ namedEntities: COMMON_HTML });\n * replacer.setExternalEntities({ brand: 'Acme' });\n *\n * const instance = replacer.reset();\n * instance.addInputEntities({ version: '1.0' });\n * instance.encode('&brand; v&version; &lt;'); // 'Acme v1.0 <'\n */\nexport default class EntityDecoder {\n  /**\n   * @param {object} [options]\n   * @param {object|null}  [options.namedEntities]        — extra named entities merged into base map\n   * @param {object}  [options.limit]                 — security limits\n   * @param {number}       [options.limit.maxTotalExpansions=0]  — 0 = unlimited\n   * @param {number}       [options.limit.maxExpandedLength=0]   — 0 = unlimited\n   * @param {'external'|'base'|'all'|string[]} [options.limit.applyLimitsTo='external']\n   *   Which entity tiers count against the security limits:\n   *   - 'external' (default) — only input/runtime + persistent external entities\n   *   - 'base'               — only DEFAULT_XML_ENTITIES + namedEntities\n   *   - 'all'                — every entity regardless of tier\n   *   - string[]             — explicit combination, e.g. ['external', 'base']\n   * @param {((resolved: string, original: string) => string)|null} [options.postCheck=null]\n   * @param {string[]} [options.remove=[]] — entity names (e.g. ['nbsp', '#13']) to delete (replace with empty string)\n   * @param {string[]} [options.leave=[]]  — entity names to keep as literal (unchanged in output)\n   * @param {object}   [options.ncr]       — Numeric Character Reference controls\n   * @param {1.0|1.1}  [options.ncr.xmlVersion=1.0]\n   *   XML version governing which codepoint ranges are restricted:\n   *   - 1.0 — C0 controls U+0001–U+001F (except U+0009/000A/000D) are prohibited\n   *   - 1.1 — C0 controls are allowed when written as NCRs; C1 (U+007F–U+009F) decoded as-is\n   * @param {'allow'|'leave'|'remove'|'throw'} [options.ncr.onNCR='allow']\n   *   Base action for numeric references. Severity order: allow < leave < remove < throw.\n   *   For codepoint ranges that carry a minimum level (surrogates → remove, XML 1.0 C0 → remove),\n   *   the effective action is max(onNCR, rangeMinimum).\n   * @param {'remove'|'throw'} [options.ncr.nullNCR='remove']\n   *   Action for U+0000 (null). 'allow' and 'leave' are clamped to 'remove' since null is never safe.\n   */\n  constructor(options = {}) {\n    this._limit = options.limit || {};\n    this._maxTotalExpansions = this._limit.maxTotalExpansions || 0;\n    this._maxExpandedLength = this._limit.maxExpandedLength || 0;\n    this._postCheck = typeof options.postCheck === 'function' ? options.postCheck : r => r;\n    this._limitTiers = parseLimitTiers(this._limit.applyLimitsTo ?? LIMIT_TIER_EXTERNAL);\n    this._numericAllowed = options.numericAllowed ?? true;\n    // Base map: DEFAULT_XML_ENTITIES + user-supplied extras. Immutable after construction.\n    this._baseMap = mergeEntityMaps(DEFAULT_XML_ENTITIES, options.namedEntities || null);\n\n    // Persistent external entities — survive across documents.\n    // Stored as a separate map so reset() never touches them.\n    /** @type {Record<string, string>} */\n    this._externalMap = Object.create(null);\n\n    // Input / runtime entities — current document only, wiped on reset().\n    /** @type {Record<string, string>} */\n    this._inputMap = Object.create(null);\n\n    // Per-document counters\n    this._totalExpansions = 0;\n    this._expandedLength = 0;\n\n    // --- New: remove / leave sets ---\n    /** @type {Set<string>} */\n    this._removeSet = new Set(options.remove && Array.isArray(options.remove) ? options.remove : []);\n    /** @type {Set<string>} */\n    this._leaveSet = new Set(options.leave && Array.isArray(options.leave) ? options.leave : []);\n\n    // --- NCR config (parsed into flat fields for hot-path speed) ---\n    const ncrCfg = parseNCRConfig(options.ncr);\n    this._ncrXmlVersion = ncrCfg.xmlVersion;\n    this._ncrOnLevel = ncrCfg.onLevel;\n    this._ncrNullLevel = ncrCfg.nullLevel;\n  }\n\n  // -------------------------------------------------------------------------\n  // Persistent external entity registration\n  // -------------------------------------------------------------------------\n\n  /**\n   * Replace the full set of persistent external entities.\n   * All keys are validated — throws on invalid characters.\n   * @param {Record<string, string | { regex?: RegExp, val: string }>} map\n   */\n  setExternalEntities(map) {\n    if (map) {\n      for (const key of Object.keys(map)) {\n        validateEntityName(key);\n      }\n    }\n    this._externalMap = mergeEntityMaps(map);\n  }\n\n  /**\n   * Add a single persistent external entity.\n   * @param {string} key\n   * @param {string} value\n   */\n  addExternalEntity(key, value) {\n    validateEntityName(key);\n    if (typeof value === 'string' && value.indexOf('&') === -1) {\n      this._externalMap[key] = value;\n    }\n  }\n\n  // -------------------------------------------------------------------------\n  // Input / runtime entity registration (per document)\n  // -------------------------------------------------------------------------\n\n  /**\n   * Inject DOCTYPE entities for the current document.\n   * Also resets per-document expansion counters.\n   * @param {Record<string, string | { regx?: RegExp, regex?: RegExp, val: string }>} map\n   */\n  addInputEntities(map) {\n    this._totalExpansions = 0;\n    this._expandedLength = 0;\n    this._inputMap = mergeEntityMaps(map);\n  }\n\n  // -------------------------------------------------------------------------\n  // Per-document reset\n  // -------------------------------------------------------------------------\n\n  /**\n   * Wipe input/runtime entities and reset counters.\n   * Call this before processing each new document.\n   * @returns {this}\n   */\n  reset() {\n    this._inputMap = Object.create(null);\n    this._totalExpansions = 0;\n    this._expandedLength = 0;\n    return this;\n  }\n\n  // -------------------------------------------------------------------------\n  // XML version (can be set after construction, e.g. once parser reads <?xml?>)\n  // -------------------------------------------------------------------------\n\n  /**\n   * Update the XML version used for NCR classification.\n   * Call this as soon as the document's `<?xml version=\"...\">` declaration is parsed.\n   * @param {1.0|1.1|number} version\n   */\n  setXmlVersion(version) {\n    this._ncrXmlVersion = version === 1.1 ? 1.1 : 1.0;\n  }\n\n  // -------------------------------------------------------------------------\n  // Primary API\n  // -------------------------------------------------------------------------\n\n  /**\n   * Replace all entity references in `str` in a single pass.\n   *\n   * @param {string} str\n   * @returns {string}\n   */\n  decode(str) {\n    if (typeof str !== 'string' || str.length === 0) return str;\n    //TODO: check if needed\n    //if (str.indexOf('&') === -1) return str; // fast path — no entities at all\n\n    const original = str;\n    const chunks = [];\n    const len = str.length;\n    let last = 0; // start of next unprocessed literal chunk\n    let i = 0;\n\n    const limitExpansions = this._maxTotalExpansions > 0;\n    const limitLength = this._maxExpandedLength > 0;\n    const checkLimits = limitExpansions || limitLength;\n\n    while (i < len) {\n      // Scan forward to next '&'\n      if (str.charCodeAt(i) !== 38 /* '&' */) { i++; continue; }\n\n      // --- Found '&' at position i ---\n\n      // Scan forward to ';'\n      let j = i + 1;\n      while (j < len && str.charCodeAt(j) !== 59 /* ';' */ && (j - i) <= 32) j++;\n\n      if (j >= len || str.charCodeAt(j) !== 59) {\n        // No closing ';' within window — treat '&' as literal\n        i++;\n        continue;\n      }\n\n      // Raw token between '&' and ';' (exclusive)\n      const token = str.slice(i + 1, j);\n      if (token.length === 0) { i++; continue; }\n\n      let replacement;\n      let tier; // which limit tier this entity belongs to\n\n      if (this._removeSet.has(token)) {\n        // Remove entity: replace with empty string\n        replacement = '';\n        // If entity was unknown (replacement undefined), we still need a tier for limits.\n        // Treat as external tier because it's user-directed removal of an unknown reference.\n        if (tier === undefined) {\n          tier = LIMIT_TIER_EXTERNAL;\n        }\n      } else if (this._leaveSet.has(token)) {\n        // Do not replace — keep original &token; as literal\n        i++;\n        continue;\n      } else if (token.charCodeAt(0) === 35 /* '#' */) {\n        // ---- Numeric / NCR reference ----\n        // NCR classification always runs first — prohibited codepoints must be\n        // caught regardless of numericAllowed.\n        const ncrResult = this._resolveNCR(token);\n        if (ncrResult === undefined) {\n          // 'leave' action — keep original &token; as-is\n          i++;\n          continue;\n        }\n        replacement = ncrResult; // '' for remove, char string for allow\n        tier = LIMIT_TIER_BASE;\n      } else {\n        // ---- Named reference ----\n        const resolved = this._resolveName(token);\n        replacement = resolved?.value;\n        tier = resolved?.tier;\n      }\n\n      if (replacement === undefined) {\n        // Unknown entity — leave as-is, advance past '&' only\n        i++;\n        continue;\n      }\n\n      // Flush literal chunk before this entity\n      if (i > last) chunks.push(str.slice(last, i));\n      chunks.push(replacement);\n      last = j + 1; // skip past ';'\n      i = last;\n\n      // Apply expansion limits only if this tier is being tracked\n      if (checkLimits && this._tierCounts(tier)) {\n        if (limitExpansions) {\n          this._totalExpansions++;\n          if (this._totalExpansions > this._maxTotalExpansions) {\n            throw new Error(\n              `[EntityReplacer] Entity expansion count limit exceeded: ` +\n              `${this._totalExpansions} > ${this._maxTotalExpansions}`\n            );\n          }\n        }\n        if (limitLength) {\n          // delta: replacement.length minus the raw &token; length (token.length + 2 for '&' and ';')\n          const delta = replacement.length - (token.length + 2);\n          if (delta > 0) {\n            this._expandedLength += delta;\n            if (this._expandedLength > this._maxExpandedLength) {\n              throw new Error(\n                `[EntityReplacer] Expanded content length limit exceeded: ` +\n                `${this._expandedLength} > ${this._maxExpandedLength}`\n              );\n            }\n          }\n        }\n      }\n    }\n\n    // Flush trailing literal\n    if (last < len) chunks.push(str.slice(last));\n\n    // If nothing was replaced, chunks is empty — return original\n    const result = chunks.length === 0 ? str : chunks.join('');\n\n    return this._postCheck(result, original);\n  }\n\n  // -------------------------------------------------------------------------\n  // Private: limit tier check\n  // -------------------------------------------------------------------------\n\n  /**\n   * Returns true if a resolved entity of the given tier should count\n   * against the expansion/length limits.\n   * @param {string} tier  — LIMIT_TIER_EXTERNAL | LIMIT_TIER_BASE\n   * @returns {boolean}\n   */\n  _tierCounts(tier) {\n    if (this._limitTiers.has(LIMIT_TIER_ALL)) return true;\n    return this._limitTiers.has(tier);\n  }\n\n  // -------------------------------------------------------------------------\n  // Private: entity resolution\n  // -------------------------------------------------------------------------\n\n  /**\n   * Resolve a named entity token (without & and ;).\n   * Priority: inputMap > externalMap > baseMap\n   * Returns the resolved value tagged with its limit tier.\n   *\n   * @param {string} name\n   * @returns {{ value: string, tier: string }|undefined}\n   */\n  _resolveName(name) {\n    // input and external both count as 'external' tier for limit purposes —\n    // they are injected at runtime and are the untrusted surface.\n    if (name in this._inputMap) return { value: this._inputMap[name], tier: LIMIT_TIER_EXTERNAL };\n    if (name in this._externalMap) return { value: this._externalMap[name], tier: LIMIT_TIER_EXTERNAL };\n    if (name in this._baseMap) return { value: this._baseMap[name], tier: LIMIT_TIER_BASE };\n    return undefined;\n  }\n\n  /**\n   * Classify a codepoint and return the minimum action level that must be applied.\n   * Returns -1 when no minimum is imposed (normal allow path).\n   *\n   * Ranges checked (in priority order):\n   *   1. U+0000            — null, governed by nullNCR (always ≥ remove)\n   *   2. U+D800–U+DFFF     — surrogates, always prohibited (min: remove)\n   *   3. U+0001–U+001F \\ {0x09,0x0A,0x0D}  — XML 1.0 restricted C0 (min: remove)\n   *      (skipped in XML 1.1 — C0 controls are allowed when written as NCRs)\n   *\n   * @param {number} cp  — codepoint\n   * @returns {number}   — minimum NCR_LEVEL value, or -1 for no restriction\n   */\n  _classifyNCR(cp) {\n    // 1. Null\n    if (cp === 0) return this._ncrNullLevel;\n\n    // 2. Surrogates — always prohibited, minimum 'remove'\n    if (cp >= 0xD800 && cp <= 0xDFFF) return NCR_LEVEL.remove;\n\n    // 3. XML 1.0 restricted C0 controls\n    if (this._ncrXmlVersion === 1.0) {\n      if (cp >= 0x01 && cp <= 0x1F && !XML10_ALLOWED_C0.has(cp)) return NCR_LEVEL.remove;\n    }\n\n    return -1; // no restriction\n  }\n\n  /**\n   * Execute a resolved NCR action.\n   *\n   * @param {number} action   — NCR_LEVEL value\n   * @param {string} token    — raw token (e.g. '#38') for error messages\n   * @param {number} cp       — codepoint, used only for error messages\n   * @returns {string|undefined}\n   *   - decoded character string  → 'allow'\n   *   - ''                        → 'remove'\n   *   - undefined                 → 'leave' (caller must skip past '&' only)\n   *   - throws Error              → 'throw'\n   */\n  _applyNCRAction(action, token, cp) {\n    switch (action) {\n      case NCR_LEVEL.allow: return String.fromCodePoint(cp);\n      case NCR_LEVEL.remove: return '';\n      case NCR_LEVEL.leave: return undefined; // signal: keep literal\n      case NCR_LEVEL.throw:\n        throw new Error(\n          `[EntityDecoder] Prohibited numeric character reference ` +\n          `&${token}; (U+${cp.toString(16).toUpperCase().padStart(4, '0')})`\n        );\n      default: return String.fromCodePoint(cp);\n    }\n  }\n\n  /**\n   * Full NCR resolution pipeline for a numeric token.\n   *\n   * Steps:\n   *   1. Parse the codepoint (decimal or hex).\n   *   2. Validate the raw codepoint range (NaN, <0, >0x10FFFF).\n   *   3. If numericAllowed is false and no minimum restriction applies → leave as-is.\n   *   4. Classify the codepoint to find the minimum required action level.\n   *   5. Resolve effective action = max(onNCR, minimum).\n   *   6. Apply and return.\n   *\n   * @param {string} token  — e.g. '#38', '#x26', '#X26'\n   * @returns {string|undefined}\n   *   - string (incl. '')  — replacement ('' = remove)\n   *   - undefined          — leave original &token; as-is\n   */\n  _resolveNCR(token) {\n    // Step 1: parse codepoint\n    const second = token.charCodeAt(1);\n    let cp;\n    if (second === 120 /* x */ || second === 88 /* X */) {\n      cp = parseInt(token.slice(2), 16);\n    } else {\n      cp = parseInt(token.slice(1), 10);\n    }\n\n    // Step 2: out-of-range → leave as-is unconditionally\n    if (Number.isNaN(cp) || cp < 0 || cp > 0x10FFFF) return undefined;\n\n    // Step 3: classify to get minimum action level\n    const minimum = this._classifyNCR(cp);\n\n    // Step 4: if numericAllowed is false and no hard minimum → leave\n    if (!this._numericAllowed && minimum < NCR_LEVEL.remove) return undefined;\n\n    // Step 5: effective action = max(configured onNCR, range minimum)\n    const effective = minimum === -1\n      ? this._ncrOnLevel\n      : Math.max(this._ncrOnLevel, minimum);\n\n    // Step 6: apply\n    return this._applyNCRAction(effective, token, cp);\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';\nimport { ExpressionSet } from 'path-expression-matcher';\nimport { EntityDecoder, XML, CURRENCY, COMMON_HTML } from '@nodable/entities';\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, externalEntities) {\n    this.options = options;\n    this.currentNode = null;\n    this.tagsNodeStack = [];\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    let namedEntities = { ...XML };\n    if (this.options.entityDecoder) {\n      this.entityDecoder = this.options.entityDecoder\n    } else {\n      if (typeof this.options.htmlEntities === \"object\") namedEntities = this.options.htmlEntities;\n      else if (this.options.htmlEntities === true) namedEntities = { ...COMMON_HTML, ...CURRENCY };\n      this.entityDecoder = new EntityDecoder({\n        namedEntities: { ...namedEntities, ...externalEntities },\n        numericAllowed: this.options.htmlEntities,\n        limit: {\n          maxTotalExpansions: this.options.processEntities.maxTotalExpansions,\n          maxExpandedLength: this.options.processEntities.maxExpandedLength,\n          applyLimitsTo: this.options.processEntities.appliesTo,\n        }\n        //postCheck: resolved => resolved\n      });\n    }\n\n    // Initialize path matcher for path-expression-matcher\n    this.matcher = new Matcher();\n    this.readonlyMatcher = this.matcher.readOnly();\n\n    // Flag to track if current node is a stop node (optimization)\n    this.isCurrentNodeStopNode = false;\n\n    // Pre-compile stopNodes expressions\n    this.stopNodeExpressionsSet = new ExpressionSet();\n    const stopNodesOpts = this.options.stopNodes;\n    if (stopNodesOpts && stopNodesOpts.length > 0) {\n      for (let i = 0; i < stopNodesOpts.length; i++) {\n        const stopNodeExp = stopNodesOpts[i];\n        if (typeof stopNodeExp === 'string') {\n          // Convert string to Expression object\n          this.stopNodeExpressionsSet.add(new Expression(stopNodeExp));\n        } else if (stopNodeExp instanceof Expression) {\n          // Already an Expression object\n          this.stopNodeExpressionsSet.add(stopNodeExp);\n        }\n      }\n      this.stopNodeExpressionsSet.seal();\n    }\n  }\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  const options = this.options;\n  if (val !== undefined) {\n    if (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 = options.jPath ? jPath.toString() : jPath;\n      const newval = 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 (options.trimValues) {\n        return parseValue(val, options.parseTagValue, options.numberParseOptions);\n      } else {\n        const trimmedVal = val.trim();\n        if (trimmedVal === val) {\n          return parseValue(val, options.parseTagValue, 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, force = false) {\n  const options = this.options;\n  if (force === true || (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    // Pre-process values once: trim + entity replacement\n    // Reused in both matcher update and second pass\n    const processedVals = new Array(len);\n    let hasRawAttrs = false;\n    const rawAttrsForMatcher = {};\n\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 val = oldVal;\n        if (options.trimValues) val = val.trim();\n        val = this.replaceEntitiesValue(val, tagName, this.readonlyMatcher);\n        processedVals[i] = val;\n\n        rawAttrsForMatcher[attrName] = val;\n        hasRawAttrs = true;\n      }\n    }\n\n    // Update matcher ONCE before second pass, if applicable\n    if (hasRawAttrs && typeof jPath === 'object' && jPath.updateCurrent) {\n      jPath.updateCurrent(rawAttrsForMatcher);\n    }\n\n    // Hoist toString() once — path doesn't change during attribute processing\n    const jPathStr = options.jPath ? jPath.toString() : this.readonlyMatcher;\n\n    // Second pass: apply processors, build final attrs\n    let hasAttrs = false;\n    for (let i = 0; i < len; i++) {\n      const attrName = this.resolveNameSpace(matches[i][1]);\n\n      if (this.ignoreAttributesFn(attrName, jPathStr)) continue;\n\n      let aName = options.attributeNamePrefix + attrName;\n\n      if (attrName.length) {\n        if (options.transformAttributeName) {\n          aName = options.transformAttributeName(aName);\n        }\n        aName = sanitizeName(aName, options);\n\n        if (matches[i][4] !== undefined) {\n          // Reuse already-processed value — no double entity replacement\n          const oldVal = processedVals[i];\n\n          const newVal = options.attributeValueProcessor(attrName, oldVal, jPathStr);\n          if (newVal === null || newVal === undefined) {\n            attrs[aName] = oldVal;\n          } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {\n            attrs[aName] = newVal;\n          } else {\n            attrs[aName] = parseValue(oldVal, options.parseAttributeValue, options.numberParseOptions);\n          }\n          hasAttrs = true;\n        } else if (options.allowBooleanAttributes) {\n          attrs[aName] = true;\n          hasAttrs = true;\n        }\n      }\n    }\n\n    if (!hasAttrs) return;\n\n    if (options.attributesGroupName && !options.preserveOrder) {\n      const attrCollection = {};\n      attrCollection[options.attributesGroupName] = attrs;\n      return attrCollection;\n    }\n    return attrs;\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  this.entityDecoder.reset();\n\n  // Reset entity expansion counters for this document\n  this.entityExpansionCount = 0;\n  this.currentExpandedLength = 0;\n  const options = this.options;\n  const docTypeReader = new DocTypeReader(options.processEntities);\n  const xmlLen = xmlData.length;\n  for (let i = 0; i < xmlLen; 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      const c1 = xmlData.charCodeAt(i + 1);\n      if (c1 === 47) {//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 (options.removeNSPrefix) {\n          const colonIndex = tagName.indexOf(\":\");\n          if (colonIndex !== -1) {\n            tagName = tagName.substr(colonIndex + 1);\n          }\n        }\n\n        tagName = transformTagName(options.transformTagName, tagName, \"\", options).tagName;\n\n        if (currentNode) {\n          textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);\n        }\n\n        //check if last tag of nested tag was unpaired tag\n        const lastTagName = this.matcher.getCurrentTag();\n        if (tagName && options.unpairedTagsSet.has(tagName)) {\n          throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);\n        }\n        if (lastTagName && options.unpairedTagsSet.has(lastTagName)) {\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 (c1 === 63) { //'?'\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.readonlyMatcher);\n        const attsMap = this.buildAttributesMap(tagData.tagExp, this.matcher, tagData.tagName, true);\n        if (attsMap) {\n          const ver = attsMap[this.options.attributeNamePrefix + \"version\"];\n          this.entityDecoder.setXmlVersion(Number(ver) || 1.0);\n          docTypeReader.setXmlVersion(Number(ver) || 1.0);\n        }\n        if ((options.ignoreDeclaration && tagData.tagName === \"?xml\") || options.ignorePiTags) {\n          //do nothing\n        } else {\n\n          const childNode = new xmlNode(tagData.tagName);\n          childNode.add(options.textNodeName, \"\");\n\n          if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent && options.ignoreAttributes !== true) {\n            childNode[\":@\"] = attsMap\n          }\n          this.addChild(currentNode, childNode, this.readonlyMatcher, i);\n        }\n\n\n        i = tagData.closeIndex + 1;\n      } else if (c1 === 33\n        && xmlData.charCodeAt(i + 2) === 45\n        && xmlData.charCodeAt(i + 3) === 45) { //'!--'\n        const endIndex = findClosingIndex(xmlData, \"-->\", i + 4, \"Comment is not closed.\")\n        if (options.commentPropName) {\n          const comment = xmlData.substring(i + 4, endIndex - 2);\n\n          textData = this.saveTextToParentTag(textData, currentNode, this.readonlyMatcher);\n\n          currentNode.add(options.commentPropName, [{ [options.textNodeName]: comment }]);\n        }\n        i = endIndex;\n      } else if (c1 === 33\n        && xmlData.charCodeAt(i + 2) === 68) { //'!D'\n        const result = docTypeReader.readDocType(xmlData, i);\n        this.entityDecoder.addInputEntities(result.entities);\n        i = result.i;\n      } else if (c1 === 33\n        && xmlData.charCodeAt(i + 2) === 91) { // '!['\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.readonlyMatcher);\n\n        let val = this.parseTextData(tagExp, currentNode.tagname, this.readonlyMatcher, true, false, true, true);\n        if (val == undefined) val = \"\";\n\n        //cdata should be set even if it is 0 length string\n        if (options.cdataPropName) {\n          currentNode.add(options.cdataPropName, [{ [options.textNodeName]: tagExp }]);\n        } else {\n          currentNode.add(options.textNodeName, val);\n        }\n\n        i = closeIndex + 2;\n      } else {//Opening tag\n        let result = readTagExp(xmlData, i, 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(xmlLen, 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(options.transformTagName, tagName, tagExp, options));\n\n        if (options.strictReservedNames &&\n          (tagName === options.commentPropName\n            || tagName === options.cdataPropName\n            || tagName === options.textNodeName\n            || tagName === options.attributesGroupName\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.readonlyMatcher, false);\n          }\n        }\n\n        //check if last tag was unpaired tag\n        const lastTag = currentNode;\n        if (lastTag && options.unpairedTagsSet.has(lastTag.tagname)) {\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            //TODO: seems a performance overhead\n            rawAttrs = extractRawAttributes(prefixedAttrs, 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();\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 (options.unpairedTagsSet.has(tagName)) {\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(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.readonlyMatcher, startIndex);\n        } else {\n          //selfClosing tag\n          if (isSelfClosing) {\n            ({ tagName, tagExp } = transformTagName(options.transformTagName, tagName, tagExp, options));\n\n            const childNode = new xmlNode(tagName);\n            if (prefixedAttrs) {\n              childNode[\":@\"] = prefixedAttrs;\n            }\n            this.addChild(currentNode, childNode, this.readonlyMatcher, startIndex);\n            this.matcher.pop(); // Pop self-closing tag\n            this.isCurrentNodeStopNode = false; // Reset flag\n          }\n          else if (options.unpairedTagsSet.has(tagName)) {//unpaired tag\n            const childNode = new xmlNode(tagName);\n            if (prefixedAttrs) {\n              childNode[\":@\"] = prefixedAttrs;\n            }\n            this.addChild(currentNode, childNode, this.readonlyMatcher, 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 > 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.readonlyMatcher, 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  return this.entityDecoder.decode(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/**\n * @param {Array<Expression>} stopNodeExpressions - Array of compiled Expression objects\n * @param {Matcher} matcher - Current path matcher\n */\nfunction isItStopNode() {\n  if (this.stopNodeExpressionsSet.size === 0) return false;\n\n  return this.matcher.matchesAny(this.stopNodeExpressionsSet);\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  //TODO: ignore boolean attributes in tag expression\n  //TODO: if ignore attributes, dont read full attribute expression but the end. But read for xml declaration\n  let attrBoundary = 0;\n  const len = xmlData.length;\n  const closeCode0 = closingChar.charCodeAt(0);\n  const closeCode1 = closingChar.length > 1 ? closingChar.charCodeAt(1) : -1;\n\n  let result = '';\n  let segmentStart = i;\n\n  for (let index = i; index < len; index++) {\n    const code = xmlData.charCodeAt(index);\n\n    if (attrBoundary) {\n      if (code === attrBoundary) attrBoundary = 0;\n    } else if (code === 34 || code === 39) { // \" or '\n      attrBoundary = code;\n    } else if (code === closeCode0) {\n      if (closeCode1 !== -1) {\n        if (xmlData.charCodeAt(index + 1) === closeCode1) {\n          result += xmlData.substring(segmentStart, index);\n          return { data: result, index };\n        }\n      } else {\n        result += xmlData.substring(segmentStart, index);\n        return { data: result, index };\n      }\n    } else if (code === 9 && !attrBoundary) { // \\t - only replace with space outside attribute values\n      // Flush accumulated segment, add space, start new segment\n      result += xmlData.substring(segmentStart, index) + ' ';\n      segmentStart = index + 1;\n    }\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 findClosingChar(xmlData, char, i, errMsg) {\n  const closingIndex = xmlData.indexOf(char, i);\n  if (closingIndex === -1) throw new Error(errMsg);\n  return closingIndex; // no offset needed\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  const xmllen = xmlData.length;\n  for (; i < xmllen; i++) {\n    if (xmlData[i] === \"<\") {\n      const c1 = xmlData.charCodeAt(i + 1);\n      if (c1 === 47) {//close tag '/'\n        const closeIndex = findClosingChar(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 (c1 === 63) { //?\n        const closeIndex = findClosingIndex(xmlData, \"?>\", i + 1, \"StopNode is not closed.\")\n        i = closeIndex;\n      } else if (c1 === 33\n        && xmlData.charCodeAt(i + 2) === 45\n        && xmlData.charCodeAt(i + 3) === 45) { // '!--'\n        const closeIndex = findClosingIndex(xmlData, \"-->\", i + 3, \"StopNode is not closed.\")\n        i = closeIndex;\n      } else if (c1 === 33\n        && xmlData.charCodeAt(i + 2) === 91) { // '!['\n        const closeIndex = findClosingIndex(xmlData, \"]]>\", i, \"StopNode is not closed.\") - 2;\n        i = closeIndex;\n      } else {\n        const tagData = readTagExp(xmlData, i, false)\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, readonlyMatcher) {\n  return compress(node, options, matcher, readonlyMatcher);\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, readonlyMatcher) {\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, readonlyMatcher);\n      const isLeaf = isLeafTag(val, options);\n\n      if (Object.keys(val).length === 0 && options.alwaysCreateTextNode) {\n        val[options.textNodeName] = \"\";\n      }\n\n      if (tagObj[\":@\"]) {\n        assignAttributes(val, tagObj[\":@\"], readonlyMatcher, 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 readonlyMatcher based on options.jPath setting\n        const jPathOrMatcher = options.jPath ? readonlyMatcher.toString() : readonlyMatcher;\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, readonlyMatcher, 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        ? readonlyMatcher.toString() + \".\" + rawAttrName\n        : readonlyMatcher;\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, this.externalEntities);\n        // orderedObjParser.entityDecoder.setExternalEntities(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, orderedObjParser.readonlyMatcher);\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\nexport function safeComment(val) {\n  return String(val)\n    .replace(/--/g, '- -')   // -- is illegal anywhere in comment content\n    .replace(/--/g, '- -')   // handle the scenario when 2 consiucative dashes appears \n    .replace(/-$/, '- ');    // trailing - would form -- with the closing -->\n}\n\nexport function safeCdata(val) {\n  return String(val).replace(/\\]\\]>/g, ']]]]><![CDATA[>')\n}\n\nexport function escapeAttribute(val) {\n  return String(val).replace(/\"/g, '&quot;').replace(/'/g, '&apos;')\n}","import { Expression, Matcher } from 'path-expression-matcher';\nimport { safeComment, safeCdata, escapeAttribute } from \"./util.js\";\nimport { qName } from 'xml-naming';\n\nconst EOL = \"\\n\";\n\n/**\n * Detect XML version from the first element of the ordered array input.\n * The first element must be a ?xml processing instruction with a version attribute.\n * Returns '1.0' if not found.\n *\n * @param {array}  jArray\n * @param {object} options\n */\nfunction detectXmlVersionFromArray(jArray, options) {\n    if (!Array.isArray(jArray) || jArray.length === 0) return '1.0';\n    const first = jArray[0];\n    const firstKey = propName(first);\n    if (firstKey === '?xml') {\n        const attrs = first[':@'];\n        if (attrs) {\n            const versionKey = options.attributeNamePrefix + 'version';\n            if (attrs[versionKey]) return attrs[versionKey];\n        }\n    }\n    return '1.0';\n}\n\n/**\n * Resolve a tag or attribute name through sanitizeName if configured.\n * Validation via xml-naming's qName is performed first; the sanitizeName\n * callback is invoked only when the name is invalid. If sanitizeName is\n * false (default), no validation occurs and the name is used as-is.\n *\n * @param {string}  name        - raw name from the JS object\n * @param {boolean} isAttribute - true when resolving an attribute name\n * @param {object}  options\n * @param {Matcher} matcher     - current matcher state (readonly from callback perspective)\n * @param {string}  xmlVersion  - '1.0' or '1.1', forwarded to xml-naming\n */\nfunction resolveTagName(name, isAttribute, options, matcher, xmlVersion) {\n    if (!options.sanitizeName) return name;\n    if (qName(name, { xmlVersion })) return name;\n    return options.sanitizeName(name, { isAttribute, matcher: matcher.readOnly() });\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) {\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    // Detect XML version for use in name validation\n    const xmlVersion = detectXmlVersionFromArray(jArray, options);\n\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n\n    return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions, xmlVersion);\n}\n\nfunction arrToStr(arr, options, indentation, matcher, stopNodeExpressions, xmlVersion) {\n    let xmlStr = \"\";\n    let isPreviousElementTag = false;\n\n    if (options.maxNestedTags && matcher.getDepth() > options.maxNestedTags) {\n        throw new Error(\"Maximum nested tags exceeded\");\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 rawTagName = propName(tagObj);\n        if (rawTagName === undefined) continue;\n\n        // Special names are exempt from sanitizeName: internal conventions and PI tags\n        // are not user-supplied XML element names.\n        const isSpecialName = rawTagName === options.textNodeName\n            || rawTagName === options.cdataPropName\n            || rawTagName === options.commentPropName\n            || rawTagName[0] === '?';\n\n        // Resolve tag name (may transform it; may throw for invalid names)\n        const tagName = isSpecialName\n            ? rawTagName\n            : resolveTagName(rawTagName, false, options, matcher, xmlVersion);\n\n        // Extract attributes from \":@\" property\n        const attrValues = extractAttributeValues(tagObj[\":@\"], options);\n\n        // Push resolved 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[rawTagName];\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            const val = tagObj[rawTagName][0][options.textNodeName];\n            const safeVal = safeCdata(val);\n            xmlStr += `<![CDATA[${safeVal}]]>`;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.commentPropName) {\n            const val = tagObj[rawTagName][0][options.textNodeName];\n            const safeVal = safeComment(val);\n            xmlStr += indentation + `<!--${safeVal}-->`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        } else if (tagName[0] === \"?\") {\n            const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode, matcher, xmlVersion);\n            const tempInd = tagName === \"?xml\" ? \"\" : indentation;\n            // Text node content on PI/XML declaration tags is intentionally ignored.\n            // Only attributes are valid on these tags per the XML spec.\n            xmlStr += tempInd + `<${tagName}${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, matcher, xmlVersion);\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[rawTagName], options);\n        } else {\n            tagValue = arrToStr(tagObj[rawTagName], options, newIdentation, matcher, stopNodeExpressions, xmlVersion);\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] = escapeAttribute(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 — no sanitizeName, content is raw\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)}=\"${escapeAttribute(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\n/**\n * Build attribute string, resolving attribute names through sanitizeName when configured.\n * Accepts matcher so the callback has path context.\n */\nfunction attr_to_str(attrMap, options, isStopNode, matcher, xmlVersion) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n\n            // Strip prefix to get the clean XML attribute name, then optionally sanitize it\n            const cleanAttrName = attr.substr(options.attributeNamePrefix.length);\n            const resolvedAttrName = isStopNode\n                ? cleanAttrName  // stopNodes are raw — skip sanitizeName for attr names too\n                : resolveTagName(cleanAttrName, true, options, matcher, xmlVersion);\n\n            let attrVal;\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 += ` ${resolvedAttrName}`;\n            } else {\n                attrStr += ` ${resolvedAttrName}=\"${escapeAttribute(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';\nimport { safeComment, safeCdata, escapeAttribute } from './util.js';\nimport { qName } from 'xml-naming';\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  maxNestedTags: 100,\n  jPath: true,  // When true, callbacks receive string jPath; when false, receive Matcher instance\n  sanitizeName: false  // false = allow all names as-is (default, backward-compatible).\n  // Set to a function (name, { isAttribute, matcher }) => string to\n  // validate/sanitize tag and attribute names. Throw inside the function\n  // to reject an invalid name.\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\n/**\n * Detect XML version from the ?xml declaration at the root of a plain-object input.\n * Checks both attributesGroupName and flat attribute forms.\n * Returns '1.0' if no declaration is found.\n */\nfunction detectXmlVersionFromObj(jObj, options) {\n  const decl = jObj['?xml'];\n  if (decl && typeof decl === 'object') {\n    // attributesGroupName path e.g. { '$$': { '@_version': '1.1' } }\n    if (options.attributesGroupName && decl[options.attributesGroupName]) {\n      const v = decl[options.attributesGroupName][options.attributeNamePrefix + 'version'];\n      if (v) return v;\n    }\n    // flat attribute path e.g. { '@_version': '1.1' }\n    const v = decl[options.attributeNamePrefix + 'version'];\n    if (v) return v;\n  }\n  return '1.0';\n}\n\n/**\n * Resolve a tag or attribute name through sanitizeName if configured.\n * Validation via xml-naming's qName is performed first; the sanitizeName\n * callback is invoked only when the name is invalid. If sanitizeName is\n * false (default), no validation occurs and the name is used as-is.\n *\n * @param {string}  name        - raw name from the JS object\n * @param {boolean} isAttribute - true when resolving an attribute name\n * @param {object}  options\n * @param {Matcher} matcher     - current matcher state (readonly from callback perspective)\n * @param {string}  xmlVersion  - '1.0' or '1.1', forwarded to xml-naming\n */\nfunction resolveTagName(name, isAttribute, options, matcher, xmlVersion) {\n  if (!options.sanitizeName) return name;\n  if (qName(name, { xmlVersion })) return name;\n  return options.sanitizeName(name, { isAttribute, matcher: matcher.readOnly() });\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    const xmlVersion = detectXmlVersionFromObj(jObj, this.options);\n    return this.j2x(jObj, 0, matcher, xmlVersion).val;\n  }\n};\n\nBuilder.prototype.j2x = function (jObj, level, matcher, xmlVersion) {\n  let attrStr = '';\n  let val = '';\n  if (this.options.maxNestedTags && matcher.getDepth() >= this.options.maxNestedTags) {\n    throw new Error(\"Maximum nested tags exceeded\");\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\n    // Resolve the key through sanitizeName before any use.\n    // Special keys (textNodeName, cdataPropName, commentPropName, attributeNamePrefix,\n    // attributesGroupName, \"?\" PI tags) are exempt — they are builder-internal conventions,\n    // not user-supplied XML names.\n    const isSpecialKey = key === this.options.textNodeName\n      || key === this.options.cdataPropName\n      || key === this.options.commentPropName\n      || (this.options.attributesGroupName && key === this.options.attributesGroupName)\n      || this.isAttribute(key)\n      || key[0] === '?';\n\n    const resolvedKey = isSpecialKey\n      ? key\n      : resolveTagName(key, false, this.options, matcher, xmlVersion);\n\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 (resolvedKey === this.options.cdataPropName || resolvedKey === this.options.commentPropName) {\n        val += '';\n      } else if (resolvedKey[0] === '?') {\n        val += this.indentate(level) + '<' + resolvedKey + '?' + this.tagEndChar;\n      } else {\n        val += this.indentate(level) + '<' + resolvedKey + '/' + this.tagEndChar;\n      }\n    } else if (jObj[key] instanceof Date) {\n      val += this.buildTextValNode(jObj[key], resolvedKey, '', 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        // Resolve the attribute name through sanitizeName\n        const resolvedAttr = resolveTagName(attr, true, this.options, matcher, xmlVersion);\n        attrStr += this.buildAttrPairStr(resolvedAttr, '' + 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(resolvedKey);\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) + '<' + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;\n            } else {\n              val += this.indentate(level) + '<' + resolvedKey + '>' + textValue + '</' + resolvedKey + this.tagEndChar;\n            }\n          } else {\n            val += this.buildTextValNode(jObj[key], resolvedKey, '', 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 (resolvedKey[0] === \"?\") val += this.indentate(level) + '<' + resolvedKey + '?' + this.tagEndChar;\n          else val += this.indentate(level) + '<' + resolvedKey + '/' + this.tagEndChar;\n        } else if (typeof item === 'object') {\n          if (this.options.oneListGroup) {\n            // Push tag to matcher before recursive call\n            matcher.push(resolvedKey);\n            const result = this.j2x(item, level + 1, matcher, xmlVersion);\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, resolvedKey, level, matcher, xmlVersion)\n          }\n        } else {\n          if (this.options.oneListGroup) {\n            let textValue = this.options.tagValueProcessor(resolvedKey, item);\n            textValue = this.replaceEntitiesValue(textValue);\n            listTagVal += textValue;\n          } else {\n            // Check if this is a stopNode before building\n            matcher.push(resolvedKey);\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) + '<' + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;\n              } else {\n                listTagVal += this.indentate(level) + '<' + resolvedKey + '>' + textValue + '</' + resolvedKey + this.tagEndChar;\n              }\n            } else {\n              listTagVal += this.buildTextValNode(item, resolvedKey, '', level, matcher);\n            }\n          }\n        }\n      }\n      if (this.options.oneListGroup) {\n        listTagVal = this.buildObjectNode(listTagVal, resolvedKey, 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          // Resolve attribute names inside attributesGroupName\n          const resolvedAttr = resolveTagName(Ks[j], true, this.options, matcher, xmlVersion);\n          attrStr += this.buildAttrPairStr(resolvedAttr, '' + jObj[key][Ks[j]], isCurrentStopNode);\n        }\n      } else {\n        val += this.processTextOrObjNode(jObj[key], resolvedKey, level, matcher, xmlVersion)\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 + '=\"' + escapeAttribute(val) + '\"';\n}\n\nfunction processTextOrObjNode(object, key, level, matcher, xmlVersion) {\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, xmlVersion);\n  // Pop tag from matcher after recursion\n  matcher.pop();\n\n  // PI/XML-declaration tags must never emit text content — route through\n  // buildTextValNode which correctly ignores the text node for \"?\" tags.\n  if (key[0] === '?') {\n    return this.buildTextValNode('', key, result.attrStr, level, matcher);\n  } else 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] = escapeAttribute(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] = escapeAttribute(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 if (key[0] === \"?\") {\n    // PI/XML-declaration tags never have body content — treat them like empty.\n    return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n  } else {\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    }\n  }\n}\n\nBuilder.prototype.buildTextValNode = function (val, key, attrStr, level, matcher) {\n  if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {\n    const safeVal = safeCdata(val);\n    return this.indentate(level) + `<![CDATA[${safeVal}]]>` + this.newLine;\n  } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {\n    const safeVal = safeComment(val);\n    return this.indentate(level) + `<!--${safeVal}-->` + 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","entityDecoder","ignoreDeclaration","ignorePiTags","transformTagName","transformAttributeName","updateTag","jPath","attrs","captureMetaData","maxNestedTags","strictReservedNames","onDangerousProperty","validatePropertyName","propertyName","optionName","normalized","toLowerCase","some","dangerous","Error","normalizeProcessEntities","enabled","maxEntitySize","maxExpansionDepth","maxTotalExpansions","Infinity","maxExpandedLength","maxEntityCount","allowedTags","tagFilter","appliesTo","Math","max","_value$maxEntitySize","_value$maxExpansionDe","_value$maxTotalExpans","_value$maxExpandedLen","_value$maxEntityCount","_value$allowedTags","_value$tagFilter","_value$appliesTo","METADATA_SYMBOL","buildOptions","built","_i","_propertyNameOptions","_propertyNameOptions$","unpairedTagsSet","Set","Array","node","startsWith","XmlNode","child","create","_proto","add","_this$child$push","addChild","_this$child$push2","_this$child$push3","keys","getMetaDataSymbol","nameStartChar10","nameStartChar11","nameChar11","buildRegexes","flags","ncNamePat","ncName","qName","nmToken","nmTokens","regexes10","regexes11","str","xmlVersion","getRegexes","test","DocTypeReader","suppressValidationErr","setXmlVersion","readDocType","entities","entityCount","hasBody","comment","hasSeq","entityName","_this$readEntityExp","readEntityExp","readElementExp","readNotationExp","skipWhitespace","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","binRegex","octRegex","numRegex","consider","binary","octal","decimalPoint","infinity","eNotationRegx","parse_int","numStr","base","parseInt","Number","window","MatcherView","constructor","matcher","_matcher","separator","getCurrentTag","path","tag","getCurrentNamespace","namespace","getAttrValue","values","hasAttr","current","getPosition","position","getCounter","counter","getIndex","getDepth","toString","includeNamespace","toArray","n","expression","matchesAny","exprSet","Matcher","siblingStacks","_pathStringCache","_view","attrValues","currentLevel","Map","siblings","siblingKey","set","updateCurrent","sep","reset","segments","hasDeepWildcard","_matchWithDeepWildcard","_matchSimple","_matchSegment","pathIdx","segIdx","segment","nextSeg","found","isCurrentNode","attrValue","String","positionValue","snapshot","restore","readOnly","Expression","pattern","_parse","_hasDeepWildcard","seg","_hasAttributeCondition","_hasPositionSelector","currentPart","_parseSegment","part","bracketContent","withoutBrackets","bracketMatch","content","slice","tagAndPosition","nsIndex","positionMatch","colonIndex","lastIndexOf","tagPart","posPart","eqIndex","nthMatch","hasAttributeCondition","hasPositionSelector","ExpressionSet","_byDepthAndTag","_wildcardByDepth","_deepWildcards","_patterns","_sealed","TypeError","has","depth","lastSeg","addAll","expressions","expr","size","seal","isSealed","findMatch","exactKey","exactBucket","wildcardBucket","CURRENCY","cent","pound","curren","yen","euro","dollar","fnof","inr","af","birr","peso","rub","won","yuan","cedil","XML","amp","apos","gt","lt","quot","COMMON_HTML","nbsp","copy","reg","trade","mdash","ndash","hellip","laquo","raquo","lsquo","rsquo","ldquo","rdquo","bull","para","sect","deg","frac12","frac14","frac34","SPECIAL_CHARS","ch","mergeEntityMaps","maps","out","raw","LIMIT_TIER_EXTERNAL","LIMIT_TIER_BASE","LIMIT_TIER_ALL","NCR_LEVEL","freeze","allow","leave","remove","throw","XML10_ALLOWED_C0","EntityDecoder","_limit","limit","_maxTotalExpansions","_maxExpandedLength","_postCheck","postCheck","r","_limitTiers","applyLimitsTo","_numericAllowed","numericAllowed","_baseMap","DEFAULT_XML_ENTITIES","namedEntities","_externalMap","_inputMap","_totalExpansions","_expandedLength","_removeSet","_leaveSet","ncrCfg","ncr","onLevel","nullLevel","onNCR","nullNCR","parseNCRConfig","_ncrXmlVersion","_ncrOnLevel","_ncrNullLevel","setExternalEntities","addExternalEntity","addInputEntities","version","decode","original","chunks","last","limitExpansions","limitLength","checkLimits","charCodeAt","token","replacement","tier","ncrResult","_resolveNCR","resolved","_resolveName","_tierCounts","delta","_classifyNCR","cp","_applyNCRAction","action","fromCodePoint","padStart","second","isNaN","minimum","effective","_extends","bind","e","arguments","apply","extractRawAttributes","prefixedAttrs","rawAttrs","extractNamespace","rawTagName","ns","OrderedObjParser","externalEntities","currentNode","tagsNodeStack","parseXml","parseTextData","resolveNameSpace","buildAttributesMap","isItStopNode","replaceEntitiesValue","readStopNodeData","saveTextToParentTag","ignoreAttributesFn","_step","_iterator","_createForOfIteratorHelperLoose","done","entityExpansionCount","currentExpandedLength","readonlyMatcher","isCurrentNodeStopNode","stopNodeExpressionsSet","stopNodesOpts","stopNodeExp","dontTrim","hasAttributes","isLeafNode","escapeEntities","jPathOrMatcher","newval","parseValue","prefix","charAt","attrsRegx","force","processedVals","hasRawAttrs","rawAttrsForMatcher","oldVal","jPathStr","hasAttrs","aName","sanitizeName","newVal","attrCollection","xmlObj","xmlNode","textData","docTypeReader","xmlLen","c1","closeIndex","findClosingIndex","lastTagName","tagData","readTagExp","attsMap","tagExp","ver","childNode","attrExpPresent","endIndex","_ref","_ref2","context","min","_transformTagName","lastTag","isSelfClosing","tagContent","_transformTagName2","entityConfig","parentNode","errMsg","closingIndex","findClosingChar","closingChar","attrBoundary","closeCode0","closeCode1","segmentStart","tagExpWithClosingIndex","separatorIndex","search","trimStart","openTagCount","xmllen","shouldParse","trimmedStr","skipLike","isFinite","sign","eChar","eAdjacentToLeadingZeros","resolveEnotation","numTrimmedByZeros","decimalAdjacentToLeadingZeros","num","parsedStr","isPositive","handleInfinity","toNumber","fn","newTagName","stripAttributePrefix","prettify","compress","arr","text","compressedObj","tagObj","property","propName","isLeaf","isLeafTag","assignAttributes","attrMap","atrrName","rawAttrName","propCount","XMLParser","parse","validationOption","orderedObjParser","orderedResult","addEntity","safeComment","safeCdata","escapeAttribute","resolveTagName","isAttribute","toXml","jArray","indentation","format","stopNodeExpressions","first","versionKey","detectXmlVersionFromArray","arrToStr","xmlStr","isPreviousElementTag","extractAttributeValues","isStopNode","checkStopNode","tagText","attr_to_str","newIdentation","indentBy","tagStart","tagValue","getRawContent","suppressUnpairedNode","suppressEmptyNode","endsWith","attr","item","attStr","attr_to_str_raw","nestedContent","attrVal","suppressBooleanAttributes","cleanAttrName","resolvedAttrName","textValue","entity","a","oneListGroup","Builder","attrPrefixLen","processTextOrObjNode","indentate","tagEndChar","newLine","object","level","extractAttributes","rawContent","buildRawContent","buildAttributesForStopNode","buildObjectNode","j2x","buildTextValNode","repeat","build","jObj","buildFromOrderedJs","arrayNodeName","decl","v","detectXmlVersionFromObj","isCurrentStopNode","resolvedKey","Date","resolvedAttr","buildAttrPairStr","closeTag","arrLen","listTagVal","listTagAttr","Ks","L","attrGroup","attrKey","nestedAttrs","cleanKey","tagEndExp","piClosingChar","safeVal","XMLValidator"],"sourceRoot":""}