npm - lambda-live-debugger - Versions diffs - 1.11.6 → 1.12.0-alpha.1 - Mend

lambda-live-debugger 1.11.6 → 1.12.0-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2035) hide show

package/node_modules/@aws-sdk/xml-builder/node_modules/fast-xml-parser/lib/fxparser.min.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"./lib/fxparser.min.js","mappings":"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","sources":["webpack://XMLParser/webpack/universalModuleDefinition","webpack://XMLParser/webpack/bootstrap","webpack://XMLParser/webpack/runtime/define property getters","webpack://XMLParser/webpack/runtime/hasOwnProperty shorthand","webpack://XMLParser/webpack/runtime/make namespace object","webpack://XMLParser/./src/xmlparser/OptionsBuilder.js","webpack://XMLParser/./src/util.js","webpack://XMLParser/./src/xmlparser/xmlNode.js","webpack://XMLParser/./src/xmlparser/DocTypeReader.js","webpack://XMLParser/./node_modules/strnum/strnum.js","webpack://XMLParser/./src/xmlparser/OrderedObjParser.js","webpack://XMLParser/./src/ignoreAttributes.js","webpack://XMLParser/./src/xmlparser/node2json.js","webpack://XMLParser/./src/validator.js","webpack://XMLParser/./src/xmlparser/XMLParser.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[\"XMLParser\"] = factory();\n\telse\n\t\troot[\"XMLParser\"] = 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};","export const defaultOptions = {\n preserveOrder: false,\n attributeNamePrefix: '@_',\n attributesGroupName: false,\n textNodeName: '#text',\n ignoreAttributes: true,\n removeNSPrefix: false, // remove NS from tag name or attribute name if true\n allowBooleanAttributes: false, //a tag can have attributes without any value\n //ignoreRootElement : false,\n parseTagValue: true,\n parseAttributeValue: false,\n trimValues: true, //Trim string values of tag and attributes\n cdataPropName: false,\n numberParseOptions: {\n hex: true,\n leadingZeros: true,\n eNotation: true\n },\n tagValueProcessor: function (tagName, val) {\n return val;\n },\n attributeValueProcessor: function (attrName, val) {\n return val;\n },\n stopNodes: [], //nested tags will not be parsed even for errors\n alwaysCreateTextNode: false,\n isArray: () => false,\n commentPropName: false,\n unpairedTags: [],\n processEntities: true,\n htmlEntities: false,\n ignoreDeclaration: false,\n ignorePiTags: false,\n transformTagName: false,\n transformAttributeName: false,\n updateTag: function (tagName, jPath, attrs) {\n return tagName\n },\n // skipEmptyListItem: false\n captureMetaData: false,\n};\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 allowedTags: null,\n tagFilter: null\n };\n }\n\n // Object config - merge with defaults\n if (typeof value === 'object' && value !== null) {\n return {\n enabled: value.enabled !== false, // default true if not specified\n maxEntitySize: value.maxEntitySize ?? 10000,\n maxExpansionDepth: value.maxExpansionDepth ?? 10,\n maxTotalExpansions: value.maxTotalExpansions ?? 1000,\n maxExpandedLength: value.maxExpandedLength ?? 100000,\n allowedTags: value.allowedTags ?? null,\n tagFilter: value.tagFilter ?? null\n };\n }\n\n // Default to enabled with limits\n return normalizeProcessEntities(true);\n}\n\nexport const buildOptions = function (options) {\n const built = Object.assign({}, defaultOptions, options);\n\n // Always normalize processEntities for backward compatibility and validation\n built.processEntities = normalizeProcessEntities(built.processEntities);\n //console.debug(built.processEntities)\n return built;\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\n/*\n Copy all the properties of a into b.\n * @param {} target\n @param {} a\n /\nexport function merge(target, a, arrayMode) {\n if (a) {\n const keys = Object.keys(a); // will return an array of own properties\n const len = keys.length; //don't make it inline\n for (let i = 0; i < len; i++) {\n if (arrayMode === 'strict') {\n target[keys[i]] = [ a[keys[i]] ];\n } else {\n target[keys[i]] = a[keys[i]];\n }\n }\n }\n}\n/* exports.merge =function (b,a){\n return Object.assign(b,a);\n} /\n\nexport function getValue(v) {\n if (exports.isExist(v)) {\n return v;\n } else {\n return '';\n }\n}\n\n// const fakeCall = function(a) {return a;};\n// const fakeCallNoReturn = function() {};","'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[\":@\"] = {}; //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\n const entities = {};\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 const escaped = entityName.replace(/[.\\-+:]/g, '\\\\.');\n entities[entityName] = {\n regx: RegExp(`&${escaped};`, \"g\"),\n val: val\n };\n }\n }\n else if (hasBody && hasSeq(xmlData, \"!ELEMENT\", i)) {\n i += 8;//Not supported\n const { index } = this.readElementExp(xmlData, i + 1);\n i = index;\n } else if (hasBody && hasSeq(xmlData, \"!ATTLIST\", i)) {\n i += 8;//Not supported\n // const {index} = this.readAttlistExp(xmlData,i+1);\n // i = index;\n } else if (hasBody && hasSeq(xmlData, \"!NOTATION\", i)) {\n i += 9;//Not supported\n const { index } = this.readNotationExp(xmlData, i + 1, this.suppressValidationErr);\n i = index;\n } else if (hasSeq(xmlData, \"!--\", i)) comment = true;\n else throw new Error(`Invalid DOCTYPE`);\n\n angleBracketsCount++;\n exp = \"\";\n } else if (xmlData[i] === '>') { //Read tag content\n if (comment) {\n if (xmlData[i - 1] === \"-\" && xmlData[i - 2] === \"-\") {\n comment = false;\n angleBracketsCount--;\n }\n } else {\n angleBracketsCount--;\n }\n if (angleBracketsCount === 0) {\n break;\n }\n } else if (xmlData[i] === '[') {\n hasBody = true;\n } else {\n exp += xmlData[i];\n }\n }\n if (angleBracketsCount !== 0) {\n throw new Error(`Unclosed DOCTYPE`);\n }\n } else {\n throw new Error(`Invalid Tag instead of DOCTYPE`);\n }\n return { entities, i };\n }\n readEntityExp(xmlData, i) {\n //External entities are not supported\n // <!ENTITY ext SYSTEM \"http://normal-website.com\" >\n\n //Parameter entities are not supported\n // <!ENTITY entityname \"&anotherElement;\">\n\n //Internal entities are supported\n // <!ENTITY entityname \"replacement text\">\n\n // Skip leading whitespace after <!ENTITY\n i = skipWhitespace(xmlData, i);\n\n // Read entity name\n let entityName = \"\";\n while (i < xmlData.length && !/\\s/.test(xmlData[i]) && xmlData[i] !== '\"' && xmlData[i] !== \"'\") {\n entityName += xmlData[i];\n i++;\n }\n validateEntityName(entityName);\n\n // Skip whitespace after entity name\n i = skipWhitespace(xmlData, i);\n\n // Check for unsupported constructs (external entities or parameter entities)\n if (!this.suppressValidationErr) {\n if (xmlData.substring(i, i + 6).toUpperCase() === \"SYSTEM\") {\n throw new Error(\"External entities are not supported\");\n } else if (xmlData[i] === \"%\") {\n throw new Error(\"Parameter entities are not supported\");\n }\n }\n\n // Read entity value (internal entity)\n let entityValue = \"\";\n [i, entityValue] = this.readIdentifierVal(xmlData, i, \"entity\");\n\n // Validate entity size\n if (this.options.enabled !== false &&\n this.options.maxEntitySize &&\n entityValue.length > this.options.maxEntitySize) {\n throw new Error(\n `Entity \"${entityName}\" size (${entityValue.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`\n );\n }\n\n i--;\n return [entityName, entityValue, i];\n }\n\n readNotationExp(xmlData, i) {\n // Skip leading whitespace after <!NOTATION\n i = skipWhitespace(xmlData, i);\n\n // Read notation name\n let notationName = \"\";\n while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n notationName += xmlData[i];\n i++;\n }\n !this.suppressValidationErr && validateEntityName(notationName);\n\n // Skip whitespace after notation name\n i = skipWhitespace(xmlData, i);\n\n // Check identifier type (SYSTEM or PUBLIC)\n const identifierType = xmlData.substring(i, i + 6).toUpperCase();\n if (!this.suppressValidationErr && identifierType !== \"SYSTEM\" && identifierType !== \"PUBLIC\") {\n throw new Error(`Expected SYSTEM or PUBLIC, found \"${identifierType}\"`);\n }\n i += identifierType.length;\n\n // Skip whitespace after identifier type\n i = skipWhitespace(xmlData, i);\n\n // Read public identifier (if PUBLIC)\n let publicIdentifier = null;\n let systemIdentifier = null;\n\n if (identifierType === \"PUBLIC\") {\n [i, publicIdentifier] = this.readIdentifierVal(xmlData, i, \"publicIdentifier\");\n\n // Skip whitespace after public identifier\n i = skipWhitespace(xmlData, i);\n\n // Optionally read system identifier\n if (xmlData[i] === '\"' \|\| xmlData[i] === \"'\") {\n [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, \"systemIdentifier\");\n }\n } else if (identifierType === \"SYSTEM\") {\n // Read system identifier (mandatory for SYSTEM)\n [i, systemIdentifier] = this.readIdentifierVal(xmlData, i, \"systemIdentifier\");\n\n if (!this.suppressValidationErr && !systemIdentifier) {\n throw new Error(\"Missing mandatory system identifier for SYSTEM notation\");\n }\n }\n\n return { notationName, publicIdentifier, systemIdentifier, index: --i };\n }\n\n readIdentifierVal(xmlData, i, type) {\n let identifierVal = \"\";\n const startChar = xmlData[i];\n if (startChar !== '\"' && startChar !== \"'\") {\n throw new Error(`Expected quoted string, found \"${startChar}\"`);\n }\n i++;\n\n while (i < xmlData.length && xmlData[i] !== startChar) {\n identifierVal += xmlData[i];\n i++;\n }\n\n if (xmlData[i] !== startChar) {\n throw new Error(`Unterminated ${type} value`);\n }\n i++;\n return [i, identifierVal];\n }\n\n readElementExp(xmlData, i) {\n // <!ELEMENT br EMPTY>\n // <!ELEMENT div ANY>\n // <!ELEMENT title (#PCDATA)>\n // <!ELEMENT book (title, author+)>\n // <!ELEMENT name (content-model)>\n\n // Skip leading whitespace after <!ELEMENT\n i = skipWhitespace(xmlData, i);\n\n // Read element name\n let elementName = \"\";\n while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n elementName += xmlData[i];\n i++;\n }\n\n // Validate element name\n if (!this.suppressValidationErr && !isName(elementName)) {\n throw new Error(`Invalid element name: \"${elementName}\"`);\n }\n\n // Skip whitespace after element name\n i = skipWhitespace(xmlData, i);\n let contentModel = \"\";\n // Expect '(' to start content model\n if (xmlData[i] === \"E\" && hasSeq(xmlData, \"MPTY\", i)) i += 4;\n else if (xmlData[i] === \"A\" && hasSeq(xmlData, \"NY\", i)) i += 2;\n else if (xmlData[i] === \"(\") {\n i++; // Move past '('\n\n // Read content model\n while (i < xmlData.length && xmlData[i] !== \")\") {\n contentModel += xmlData[i];\n i++;\n }\n if (xmlData[i] !== \")\") {\n throw new Error(\"Unterminated content model\");\n }\n\n } else if (!this.suppressValidationErr) {\n throw new Error(`Invalid Element Expression, found \"${xmlData[i]}\"`);\n }\n\n return {\n elementName,\n contentModel: contentModel.trim(),\n index: i\n };\n }\n\n readAttlistExp(xmlData, i) {\n // Skip leading whitespace after <!ATTLIST\n i = skipWhitespace(xmlData, i);\n\n // Read element name\n let elementName = \"\";\n while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n elementName += xmlData[i];\n i++;\n }\n\n // Validate element name\n validateEntityName(elementName)\n\n // Skip whitespace after element name\n i = skipWhitespace(xmlData, i);\n\n // Read attribute name\n let attributeName = \"\";\n while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n attributeName += xmlData[i];\n i++;\n }\n\n // Validate attribute name\n if (!validateEntityName(attributeName)) {\n throw new Error(`Invalid attribute name: \"${attributeName}\"`);\n }\n\n // Skip whitespace after attribute name\n i = skipWhitespace(xmlData, i);\n\n // Read attribute type\n let attributeType = \"\";\n if (xmlData.substring(i, i + 8).toUpperCase() === \"NOTATION\") {\n attributeType = \"NOTATION\";\n i += 8; // Move past \"NOTATION\"\n\n // Skip whitespace after \"NOTATION\"\n i = skipWhitespace(xmlData, i);\n\n // Expect '(' to start the list of notations\n if (xmlData[i] !== \"(\") {\n throw new Error(`Expected '(', found \"${xmlData[i]}\"`);\n }\n i++; // Move past '('\n\n // Read the list of allowed notations\n let allowedNotations = [];\n while (i < xmlData.length && xmlData[i] !== \")\") {\n let notation = \"\";\n while (i < xmlData.length && xmlData[i] !== \"\|\" && xmlData[i] !== \")\") {\n notation += xmlData[i];\n i++;\n }\n\n // Validate notation name\n notation = notation.trim();\n if (!validateEntityName(notation)) {\n throw new Error(`Invalid notation name: \"${notation}\"`);\n }\n\n allowedNotations.push(notation);\n\n // Skip '\|' separator or exit loop\n if (xmlData[i] === \"\|\") {\n i++; // Move past '\|'\n i = skipWhitespace(xmlData, i); // Skip optional whitespace after '\|'\n }\n }\n\n if (xmlData[i] !== \")\") {\n throw new Error(\"Unterminated list of notations\");\n }\n i++; // Move past ')'\n\n // Store the allowed notations as part of the attribute type\n attributeType += \" (\" + allowedNotations.join(\"\|\") + \")\";\n } else {\n // Handle simple types (e.g., CDATA, ID, IDREF, etc.)\n while (i < xmlData.length && !/\\s/.test(xmlData[i])) {\n attributeType += xmlData[i];\n i++;\n }\n\n // Validate simple attribute type\n const validTypes = [\"CDATA\", \"ID\", \"IDREF\", \"IDREFS\", \"ENTITY\", \"ENTITIES\", \"NMTOKEN\", \"NMTOKENS\"];\n if (!this.suppressValidationErr && !validTypes.includes(attributeType.toUpperCase())) {\n throw new Error(`Invalid attribute type: \"${attributeType}\"`);\n }\n }\n\n // Skip whitespace after attribute type\n i = skipWhitespace(xmlData, i);\n\n // Read default value\n let defaultValue = \"\";\n if (xmlData.substring(i, i + 8).toUpperCase() === \"#REQUIRED\") {\n defaultValue = \"#REQUIRED\";\n i += 8;\n } else if (xmlData.substring(i, i + 7).toUpperCase() === \"#IMPLIED\") {\n defaultValue = \"#IMPLIED\";\n i += 7;\n } else {\n [i, defaultValue] = this.readIdentifierVal(xmlData, i, \"ATTLIST\");\n }\n\n return {\n elementName,\n attributeName,\n attributeType,\n defaultValue,\n index: i\n }\n }\n}\n\n\n\nconst skipWhitespace = (data, index) => {\n while (index < data.length && /\\s/.test(data[index])) {\n index++;\n }\n return index;\n};\n\n\n\nfunction hasSeq(data, seq, i) {\n for (let j = 0; j < seq.length; j++) {\n if (seq[j] !== data[i + j + 1]) return false;\n }\n return true;\n}\n\nfunction validateEntityName(name) {\n if (isName(name))\n return name;\n else\n throw new Error(`Invalid entity name ${name}`);\n}","const hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;\nconst numRegex = /^([\\-\\+])?(0)([0-9](\\.[0-9])?)$/;\n// const octRegex = /^0x[a-z0-9]+/;\n// const binRegex = /0x[a-z0-9]+/;\n\n \nconst consider = {\n hex : true,\n // oct: false,\n leadingZeros: true,\n decimalPoint: \"\\.\",\n eNotation: true,\n //skipLike: /regex/\n};\n\nexport default function toNumber(str, options = {}){\n options = Object.assign({}, consider, options );\n if(!str \|\| typeof str !== \"string\" ) return str;\n \n let trimmedStr = str.trim();\n \n if(options.skipLike !== undefined && options.skipLike.test(trimmedStr)) return str;\n else if(str===\"0\") return 0;\n else if (options.hex && hexRegex.test(trimmedStr)) {\n return parse_int(trimmedStr, 16);\n // }else if (options.oct && octRegex.test(str)) {\n // return Number.parseInt(val, 8);\n }else if (trimmedStr.search(/.+[eE].+/)!== -1) { //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 \|\| num === -0) return num;\n if(parsedStr.search(/[eE]/) !== -1){ //given number is long and parsed to eNotation\n if(options.eNotation) return num;\n else return str;\n }else if(trimmedStr.indexOf(\".\") !== -1){ //floating number\n if(parsedStr === \"0\") return num; //0.0\n else if(parsedStr === numTrimmedByZeros) return num; //0.456. 0.79000\n else if( parsedStr === `${sign}${numTrimmedByZeros}`) return num;\n else return str;\n }\n \n let n = leadingZeros? numTrimmedByZeros : trimmedStr;\n if(leadingZeros){\n // -009 => -9\n return (n === parsedStr) \|\| (sign+n === parsedStr) ? num : str\n }else {\n // +9\n return (n === parsedStr) \|\| (n === sign+parsedStr) ? num : str\n }\n }\n }else{ //non-numeric string\n return str;\n }\n }\n}\n\nconst eNotationRegx = /^([-+])?(0)(\\d(\\.\\d)?[eE][-\\+]?\\d+)$/;\nfunction resolveEnotation(str,trimmedStr,options){\n if(!options.eNotation) return str;\n const notation = trimmedStr.match(eNotationRegx); \n if(notation){\n let sign = notation[1] \|\| \"\";\n const eChar = notation[3].indexOf(\"e\") === -1 ? \"E\" : \"e\";\n const leadingZeros = notation[2];\n const eAdjacentToLeadingZeros = sign ? // 0E.\n str[leadingZeros.length+1] === eChar \n : str[leadingZeros.length] === eChar;\n\n if(leadingZeros.length > 1 && eAdjacentToLeadingZeros) return str;\n else if(leadingZeros.length === 1 \n && (notation[3].startsWith(`.${eChar}`) \|\| notation[3][0] === eChar)){\n return Number(trimmedStr);\n }else if(options.leadingZeros && !eAdjacentToLeadingZeros){ //accept with leading zeros\n //remove leading 0s\n trimmedStr = (notation[1] \|\| \"\") + notation[3];\n return Number(trimmedStr);\n }else return str;\n }else{\n return str;\n }\n}\n\n/*\n \n * @param {string} numStr without leading zeros\n * @returns \n /\nfunction trimZeros(numStr){\n if(numStr && numStr.indexOf(\".\") !== -1){//float\n numStr = numStr.replace(/0+$/, \"\"); //remove ending zeros\n if(numStr === \".\") numStr = \"0\";\n else if(numStr[0] === \".\") numStr = \"0\"+numStr;\n else if(numStr[numStr.length-1] === \".\") numStr = numStr.substring(0,numStr.length-1);\n return numStr;\n }\n return numStr;\n}\n\nfunction parse_int(numStr, base){\n //polyfill\n if(parseInt) return parseInt(numStr, base);\n else if(Number.parseInt) return Number.parseInt(numStr, base);\n else if(window && window.parseInt) return window.parseInt(numStr, base);\n else throw new Error(\"parseInt, Number.parseInt, window.parseInt are not supported\")\n}","'use strict';\n///@ts-check\n\nimport { getAllMatches, isExist } from '../util.js';\nimport xmlNode from './xmlNode.js';\nimport DocTypeReader from './DocTypeReader.js';\nimport toNumber from \"strnum\";\nimport getIgnoreAttributesFn from \"../ignoreAttributes.js\";\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\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 if (this.options.stopNodes && this.options.stopNodes.length > 0) {\n this.stopNodesExact = new Set();\n this.stopNodesWildcard = new Set();\n for (let i = 0; i < this.options.stopNodes.length; i++) {\n const stopNodeExp = this.options.stopNodes[i];\n if (typeof stopNodeExp !== 'string') continue;\n if (stopNodeExp.startsWith(\".\")) {\n this.stopNodesWildcard.add(stopNodeExp.substring(2));\n } else {\n this.stopNodesExact.add(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} 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 const newval = this.options.tagValueProcessor(tagName, val, jPath, 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 for (let i = 0; i < len; i++) {\n const attrName = this.resolveNameSpace(matches[i][1]);\n if (this.ignoreAttributesFn(attrName, jPath)) {\n continue\n }\n let oldVal = matches[i][4];\n let aName = this.options.attributeNamePrefix + attrName;\n if (attrName.length) {\n if (this.options.transformAttributeName) {\n aName = this.options.transformAttributeName(aName);\n }\n if (aName === \"__proto__\") aName = \"#__proto__\";\n if (oldVal !== undefined) {\n if (this.options.trimValues) {\n oldVal = oldVal.trim();\n }\n oldVal = this.replaceEntitiesValue(oldVal, tagName, jPath);\n const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);\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 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 let jPath = \"\";\n\n // Reset entity expansion counters for this document\n this.entityExpansionCount = 0;\n this.currentExpandedLength = 0;\n\n const docTypeReader = new DocTypeReader(this.options.processEntities);\n for (let i = 0; i < xmlData.length; i++) {//for each char in XML data\n const ch = xmlData[i];\n if (ch === '<') {\n // const nextIndex = i+1;\n // const _2ndChar = xmlData[nextIndex];\n if (xmlData[i + 1] === '/') {//Closing Tag\n const closeIndex = findClosingIndex(xmlData, \">\", i, \"Closing Tag is not closed.\")\n let tagName = xmlData.substring(i + 2, closeIndex).trim();\n\n if (this.options.removeNSPrefix) {\n const colonIndex = tagName.indexOf(\":\");\n if (colonIndex !== -1) {\n tagName = tagName.substr(colonIndex + 1);\n }\n }\n\n if (this.options.transformTagName) {\n tagName = this.options.transformTagName(tagName);\n }\n\n if (currentNode) {\n textData = this.saveTextToParentTag(textData, currentNode, jPath);\n }\n\n //check if last tag of nested tag was unpaired tag\n const lastTagName = jPath.substring(jPath.lastIndexOf(\".\") + 1);\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 let propIndex = 0\n if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {\n propIndex = jPath.lastIndexOf('.', jPath.lastIndexOf('.') - 1)\n this.tagsNodeStack.pop();\n } else {\n propIndex = jPath.lastIndexOf(\".\");\n }\n jPath = jPath.substring(0, propIndex);\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, jPath);\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, jPath, tagData.tagName);\n }\n this.addChild(currentNode, childNode, jPath, 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, jPath);\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, jPath);\n\n let val = this.parseTextData(tagExp, currentNode.tagname, jPath, 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 let tagName = result.tagName;\n const rawTagName = result.rawTagName;\n let tagExp = result.tagExp;\n let attrExpPresent = result.attrExpPresent;\n let closeIndex = result.closeIndex;\n\n if (this.options.transformTagName) {\n //console.log(tagExp, tagName)\n const newTagName = this.options.transformTagName(tagName);\n if (tagExp === tagName) {\n tagExp = newTagName\n }\n tagName = newTagName;\n }\n\n //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, jPath, 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 jPath = jPath.substring(0, jPath.lastIndexOf(\".\"));\n }\n if (tagName !== xmlObj.tagname) {\n jPath += jPath ? \".\" + tagName : tagName;\n }\n const startIndex = i;\n if (this.isItStopNode(this.stopNodesExact, this.stopNodesWildcard, jPath, tagName)) {\n let tagContent = \"\";\n //self-closing tag\n if (tagExp.length > 0 && tagExp.lastIndexOf(\"/\") === tagExp.length - 1) {\n if (tagName[tagName.length - 1] === \"/\") { //remove trailing '/'\n tagName = tagName.substr(0, tagName.length - 1);\n jPath = jPath.substr(0, jPath.length - 1);\n tagExp = tagName;\n } else {\n tagExp = tagExp.substr(0, tagExp.length - 1);\n }\n i = result.closeIndex;\n }\n //unpaired tag\n else if (this.options.unpairedTags.indexOf(tagName) !== -1) {\n\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 (tagName !== tagExp && attrExpPresent) {\n childNode[\":@\"] = this.buildAttributesMap(tagExp, jPath, tagName);\n }\n if (tagContent) {\n tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);\n }\n\n jPath = jPath.substr(0, jPath.lastIndexOf(\".\"));\n childNode.add(this.options.textNodeName, tagContent);\n\n this.addChild(currentNode, childNode, jPath, startIndex);\n } else {\n //selfClosing tag\n if (tagExp.length > 0 && tagExp.lastIndexOf(\"/\") === tagExp.length - 1) {\n if (tagName[tagName.length - 1] === \"/\") { //remove trailing '/'\n tagName = tagName.substr(0, tagName.length - 1);\n jPath = jPath.substr(0, jPath.length - 1);\n tagExp = tagName;\n } else {\n tagExp = tagExp.substr(0, tagExp.length - 1);\n }\n\n if (this.options.transformTagName) {\n const newTagName = this.options.transformTagName(tagName);\n if (tagExp === tagName) {\n tagExp = newTagName\n }\n tagName = newTagName;\n }\n\n const childNode = new xmlNode(tagName);\n if (tagName !== tagExp && attrExpPresent) {\n childNode[\":@\"] = this.buildAttributesMap(tagExp, jPath, tagName);\n }\n this.addChild(currentNode, childNode, jPath, startIndex);\n jPath = jPath.substr(0, jPath.lastIndexOf(\".\"));\n }\n //opening tag\n else {\n const childNode = new xmlNode(tagName);\n this.tagsNodeStack.push(currentNode);\n\n if (tagName !== tagExp && attrExpPresent) {\n childNode[\":@\"] = this.buildAttributesMap(tagExp, jPath, tagName);\n }\n this.addChild(currentNode, childNode, jPath, 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, jPath, startIndex) {\n // unset startIndex if not requested\n if (!this.options.captureMetaData) startIndex = undefined;\n const result = this.options.updateTag(childNode.tagname, jPath, 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\nconst replaceEntitiesValue = function (val, tagName, jPath) {\n // Performance optimization: Early return if no entities to replace\n if (val.indexOf('&') === -1) {\n return val;\n }\n\n const entityConfig = this.options.processEntities;\n\n if (!entityConfig.enabled) {\n return val;\n }\n\n // Check tag-specific filtering\n if (entityConfig.allowedTags) {\n if (!entityConfig.allowedTags.includes(tagName)) {\n return val; // Skip entity replacement for current tag as not set\n }\n }\n\n if (entityConfig.tagFilter) {\n if (!entityConfig.tagFilter(tagName, jPath)) {\n return val; // Skip based on custom filter\n }\n }\n\n // Replace DOCTYPE entities\n for (let entityName in this.docTypeEntities) {\n const entity = this.docTypeEntities[entityName];\n const matches = val.match(entity.regx);\n\n if (matches) {\n // Track expansions\n this.entityExpansionCount += matches.length;\n\n // Check expansion limit\n if (entityConfig.maxTotalExpansions &&\n this.entityExpansionCount > entityConfig.maxTotalExpansions) {\n throw new Error(\n `Entity expansion limit exceeded: ${this.entityExpansionCount} > ${entityConfig.maxTotalExpansions}`\n );\n }\n\n // Store length before replacement\n const lengthBefore = val.length;\n val = val.replace(entity.regx, entity.val);\n\n // Check expanded length immediately after replacement\n if (entityConfig.maxExpandedLength) {\n this.currentExpandedLength += (val.length - lengthBefore);\n\n if (this.currentExpandedLength > entityConfig.maxExpandedLength) {\n throw new Error(\n `Total expanded content size exceeded: ${this.currentExpandedLength} > ${entityConfig.maxExpandedLength}`\n );\n }\n }\n }\n }\n if (val.indexOf('&') === -1) return val; // Early exit\n\n // Replace standard entities\n for (let entityName in this.lastEntities) {\n const entity = this.lastEntities[entityName];\n val = val.replace(entity.regex, entity.val);\n }\n if (val.indexOf('&') === -1) return val; // Early exit\n\n // Replace HTML entities if enabled\n if (this.options.htmlEntities) {\n for (let entityName in this.htmlEntities) {\n const entity = this.htmlEntities[entityName];\n val = val.replace(entity.regex, entity.val);\n }\n }\n\n // Replace ampersand entity last\n val = val.replace(this.ampEntity.regex, this.ampEntity.val);\n\n return val;\n}\n\n\nfunction saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {\n if (textData) { //store previously collected data as textNode\n if (isLeafNode === undefined) isLeafNode = currentNode.child.length === 0\n\n textData = this.parseTextData(textData,\n currentNode.tagname,\n jPath,\n false,\n currentNode[\":@\"] ? Object.keys(currentNode[\":@\"]).length !== 0 : false,\n isLeafNode);\n\n if (textData !== undefined && textData !== \"\")\n currentNode.add(this.options.textNodeName, textData);\n textData = \"\";\n }\n return textData;\n}\n\n//TODO: use jPath to simplify the logic\n/\n @param {Set} stopNodesExact\n * @param {Set} stopNodesWildcard\n * @param {string} jPath\n * @param {string} currentTagName\n /\nfunction isItStopNode(stopNodesExact, stopNodesWildcard, jPath, currentTagName) {\n if (stopNodesWildcard && stopNodesWildcard.has(currentTagName)) return true;\n if (stopNodesExact && stopNodesExact.has(jPath)) return true;\n return false;\n}\n\n/\n Returns the tag Expression and where it is ending handling single-double quotes situation\n * @param {string} xmlData \n * @param {number} i starting index\n * @returns \n /\nfunction tagExpWithClosingIndex(xmlData, i, closingChar = \">\") {\n let attrBoundary;\n let tagExp = \"\";\n for (let index = i; index < xmlData.length; index++) {\n let ch = xmlData[index];\n if (attrBoundary) {\n if (ch === attrBoundary) attrBoundary = \"\";//reset\n } else if (ch === '\"' \|\| ch === \"'\") {\n attrBoundary = ch;\n } else if (ch === closingChar[0]) {\n if (closingChar[1]) {\n if (xmlData[index + 1] === closingChar[1]) {\n return {\n data: tagExp,\n index: index\n }\n }\n } else {\n return {\n data: tagExp,\n index: index\n }\n }\n } else if (ch === '\\t') {\n ch = \" \"\n }\n tagExp += ch;\n }\n}\n\nfunction findClosingIndex(xmlData, str, i, errMsg) {\n const closingIndex = xmlData.indexOf(str, i);\n if (closingIndex === -1) {\n throw new Error(errMsg)\n } else {\n return closingIndex + str.length - 1;\n }\n}\n\nfunction readTagExp(xmlData, i, removeNSPrefix, closingChar = \">\") {\n const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar);\n if (!result) return;\n let tagExp = result.data;\n const closeIndex = result.index;\n const separatorIndex = tagExp.search(/\\s/);\n let tagName = tagExp;\n let attrExpPresent = true;\n if (separatorIndex !== -1) {//separate tag name and attributes expression\n tagName = tagExp.substring(0, separatorIndex);\n tagExp = tagExp.substring(separatorIndex + 1).trimStart();\n }\n\n const rawTagName = tagName;\n if (removeNSPrefix) {\n const colonIndex = tagName.indexOf(\":\");\n if (colonIndex !== -1) {\n tagName = tagName.substr(colonIndex + 1);\n attrExpPresent = tagName !== result.data.substr(colonIndex + 1);\n }\n }\n\n return {\n tagName: tagName,\n tagExp: tagExp,\n closeIndex: closeIndex,\n attrExpPresent: attrExpPresent,\n rawTagName: rawTagName,\n }\n}\n/\n find paired tag for a stop node\n * @param {string} xmlData \n * @param {string} tagName \n * @param {number} i \n /\nfunction readStopNodeData(xmlData, tagName, i) {\n const startIndex = i;\n // Starting at 1 since we already have an open tag\n let openTagCount = 1;\n\n for (; i < xmlData.length; i++) {\n if (xmlData[i] === \"<\") {\n if (xmlData[i + 1] === \"/\") {//close tag\n const closeIndex = findClosingIndex(xmlData, \">\", i, `${tagName} is not closed`);\n let closeTagName = xmlData.substring(i + 2, closeIndex).trim();\n if (closeTagName === tagName) {\n openTagCount--;\n if (openTagCount === 0) {\n return {\n tagContent: xmlData.substring(startIndex, i),\n i: closeIndex\n }\n }\n }\n i = closeIndex;\n } else if (xmlData[i + 1] === '?') {\n const closeIndex = findClosingIndex(xmlData, \"?>\", i + 1, \"StopNode is not closed.\")\n i = closeIndex;\n } else if (xmlData.substr(i + 1, 3) === '!--') {\n const closeIndex = findClosingIndex(xmlData, \"-->\", i + 3, \"StopNode is not closed.\")\n i = closeIndex;\n } else if (xmlData.substr(i + 1, 2) === '![') {\n const closeIndex = findClosingIndex(xmlData, \"]]>\", i, \"StopNode is not closed.\") - 2;\n i = closeIndex;\n } else {\n const tagData = readTagExp(xmlData, i, '>')\n\n if (tagData) {\n const openTagName = tagData && tagData.tagName;\n if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== \"/\") {\n openTagCount++;\n }\n i = tagData.closeIndex;\n }\n }\n }\n }//end for loop\n}\n\nfunction parseValue(val, shouldParse, options) {\n if (shouldParse && typeof val === 'string') {\n //console.log(options)\n const newval = val.trim();\n if (newval === 'true') return true;\n else if (newval === 'false') return false;\n else return toNumber(val, options);\n } else {\n if (isExist(val)) {\n return val;\n } else {\n return '';\n }\n }\n}\n\nfunction fromCodePoint(str, base, prefix) {\n const codePoint = Number.parseInt(str, base);\n\n if (codePoint >= 0 && codePoint <= 0x10FFFF) {\n return String.fromCodePoint(codePoint);\n } else {\n return prefix + str + \";\";\n }\n}","export default function getIgnoreAttributesFn(ignoreAttributes) {\n if (typeof ignoreAttributes === 'function') {\n return ignoreAttributes\n }\n if (Array.isArray(ignoreAttributes)) {\n return (attrName) => {\n for (const pattern of ignoreAttributes) {\n if (typeof pattern === 'string' && attrName === pattern) {\n return true\n }\n if (pattern instanceof RegExp && pattern.test(attrName)) {\n return true\n }\n }\n }\n }\n return () => false\n}","'use strict';\n\nimport XmlNode from './xmlNode.js';\n\nconst METADATA_SYMBOL = XmlNode.getMetaDataSymbol();\n\n/\n \n * @param {array} node \n * @param {any} options \n * @returns \n /\nexport default function prettify(node, options){\n return compress( node, options);\n}\n\n/\n \n * @param {array} arr \n * @param {object} options \n * @param {string} jPath \n * @returns object\n /\nfunction compress(arr, options, jPath){\n let text;\n const compressedObj = {};\n for (let i = 0; i < arr.length; i++) {\n const tagObj = arr[i];\n const property = propName(tagObj);\n let newJpath = \"\";\n if(jPath === undefined) newJpath = property;\n else newJpath = jPath + \".\" + property;\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, newJpath);\n const isLeaf = isLeafTag(val, options);\n if (tagObj[METADATA_SYMBOL] !== undefined) {\n val[METADATA_SYMBOL] = tagObj[METADATA_SYMBOL]; // copy over metadata\n }\n\n if(tagObj[\":@\"]){\n assignAttributes( val, tagObj[\":@\"], newJpath, 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(compressedObj[property] !== undefined && compressedObj.hasOwnProperty(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 if (options.isArray(property, newJpath, isLeaf )) {\n compressedObj[property] = [val];\n }else{\n compressedObj[property] = val;\n }\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 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, jpath, 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];\n if (options.isArray(atrrName, jpath + \".\" + atrrName, 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}\n","'use strict';\n\nimport {getAllMatches, isName} from './util.js';\n\nconst defaultOptions = {\n allowBooleanAttributes: false, //A tag can have attributes without any value\n unpairedTags: []\n};\n\n//const tagsPattern = new RegExp(\"<\\\\/?([\\\\w:\\\\-_\\.]+)\\\\s\\/?>\",\"g\");\nexport function validate(xmlData, options) {\n options = Object.assign({}, defaultOptions, options);\n\n //xmlData = xmlData.replace(/(\\r\\n\|\\n\|\\r)/gm,\"\");//make it single line\n //xmlData = xmlData.replace(/(^\\s<\\?xml.?\\?>)/g,\"\");//Remove XML starting tag\n //xmlData = xmlData.replace(/(<!DOCTYPE[\\s\\w\\\"\\.\\/\\-\\:]+(\\[.\\])\\s>)/g,\"\");//Remove DOCTYPE\n const tags = [];\n let tagFound = false;\n\n //indicates that the root tag has been closed (aka. depth 0 has been reached)\n let reachedRoot = false;\n\n if (xmlData[0] === '\\ufeff') {\n // check for byte order mark (BOM)\n xmlData = xmlData.substr(1);\n }\n \n for (let i = 0; i < xmlData.length; i++) {\n\n if (xmlData[i] === '<' && xmlData[i+1] === '?') {\n i+=2;\n i = readPI(xmlData,i);\n if (i.err) return i;\n }else if (xmlData[i] === '<') {\n //starting of tag\n //read until you reach to '>' avoiding any '>' in attribute value\n let tagStartPos = i;\n i++;\n \n if (xmlData[i] === '!') {\n i = readCommentAndCDATA(xmlData, i);\n continue;\n } else {\n let closingTag = false;\n if (xmlData[i] === '/') {\n //closing tag\n closingTag = true;\n i++;\n }\n //read tagname\n let tagName = '';\n for (; i < xmlData.length &&\n xmlData[i] !== '>' &&\n xmlData[i] !== ' ' &&\n xmlData[i] !== '\\t' &&\n xmlData[i] !== '\\n' &&\n xmlData[i] !== '\\r'; i++\n ) {\n tagName += xmlData[i];\n }\n tagName = tagName.trim();\n //console.log(tagName);\n\n if (tagName[tagName.length - 1] === '/') {\n //self closing tag without attributes\n tagName = tagName.substring(0, tagName.length - 1);\n //continue;\n i--;\n }\n if (!validateTagName(tagName)) {\n let msg;\n if (tagName.trim().length === 0) {\n msg = \"Invalid space after '<'.\";\n } else {\n msg = \"Tag '\"+tagName+\"' is an invalid name.\";\n }\n return getErrorObject('InvalidTag', msg, getLineNumberForPosition(xmlData, i));\n }\n\n const result = readAttributeStr(xmlData, i);\n if (result === false) {\n return getErrorObject('InvalidAttr', \"Attributes for '\"+tagName+\"' have open quote.\", getLineNumberForPosition(xmlData, i));\n }\n let attrStr = result.value;\n i = result.index;\n\n if (attrStr[attrStr.length - 1] === '/') {\n //self closing tag\n const attrStrStart = i - attrStr.length;\n attrStr = attrStr.substring(0, attrStr.length - 1);\n const isValid = validateAttributeString(attrStr, options);\n if (isValid === true) {\n tagFound = true;\n //continue; //text may presents after self closing tag\n } else {\n //the result from the nested function returns the position of the error within the attribute\n //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute\n //this gives us the absolute index in the entire xml, which we can use to find the line at last\n return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line));\n }\n } else if (closingTag) {\n if (!result.tagClosed) {\n return getErrorObject('InvalidTag', \"Closing tag '\"+tagName+\"' doesn't have proper closing.\", getLineNumberForPosition(xmlData, i));\n } else if (attrStr.trim().length > 0) {\n return getErrorObject('InvalidTag', \"Closing tag '\"+tagName+\"' can't have attributes or invalid starting.\", getLineNumberForPosition(xmlData, tagStartPos));\n } else if (tags.length === 0) {\n return getErrorObject('InvalidTag', \"Closing tag '\"+tagName+\"' has not been opened.\", getLineNumberForPosition(xmlData, tagStartPos));\n } else {\n const otg = tags.pop();\n if (tagName !== otg.tagName) {\n let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);\n return getErrorObject('InvalidTag',\n \"Expected closing tag '\"+otg.tagName+\"' (opened in line \"+openPos.line+\", col \"+openPos.col+\") instead of closing tag '\"+tagName+\"'.\",\n getLineNumberForPosition(xmlData, tagStartPos));\n }\n\n //when there are no more tags, we reached the root level.\n if (tags.length == 0) {\n reachedRoot = true;\n }\n }\n } else {\n const isValid = validateAttributeString(attrStr, options);\n if (isValid !== true) {\n //the result from the nested function returns the position of the error within the attribute\n //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute\n //this gives us the absolute index in the entire xml, which we can use to find the line at last\n return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));\n }\n\n //if the root level has been reached before ...\n if (reachedRoot === true) {\n return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));\n } else if(options.unpairedTags.indexOf(tagName) !== -1){\n //don't push into stack\n } else {\n tags.push({tagName, tagStartPos});\n }\n tagFound = true;\n }\n\n //skip tag text value\n //It may include comments and CDATA value\n for (i++; i < xmlData.length; i++) {\n if (xmlData[i] === '<') {\n if (xmlData[i + 1] === '!') {\n //comment or CADATA\n i++;\n i = readCommentAndCDATA(xmlData, i);\n continue;\n } else if (xmlData[i+1] === '?') {\n i = readPI(xmlData, ++i);\n if (i.err) return i;\n } else{\n break;\n }\n } else if (xmlData[i] === '&') {\n const afterAmp = validateAmpersand(xmlData, i);\n if (afterAmp == -1)\n return getErrorObject('InvalidChar', \"char '&' is not expected.\", getLineNumberForPosition(xmlData, i));\n i = afterAmp;\n }else{\n if (reachedRoot === true && !isWhiteSpace(xmlData[i])) {\n return getErrorObject('InvalidXml', \"Extra text at the end\", getLineNumberForPosition(xmlData, i));\n }\n }\n } //end of reading tag text value\n if (xmlData[i] === '<') {\n i--;\n }\n }\n } else {\n if ( isWhiteSpace(xmlData[i])) {\n continue;\n }\n return getErrorObject('InvalidChar', \"char '\"+xmlData[i]+\"' is not expected.\", getLineNumberForPosition(xmlData, i));\n }\n }\n\n if (!tagFound) {\n return getErrorObject('InvalidXml', 'Start tag expected.', 1);\n }else if (tags.length == 1) {\n return getErrorObject('InvalidTag', \"Unclosed tag '\"+tags[0].tagName+\"'.\", getLineNumberForPosition(xmlData, tags[0].tagStartPos));\n }else if (tags.length > 0) {\n return getErrorObject('InvalidXml', \"Invalid '\"+\n JSON.stringify(tags.map(t => t.tagName), null, 4).replace(/\\r?\\n/g, '')+\n \"' found.\", {line: 1, col: 1});\n }\n\n return true;\n};\n\nfunction isWhiteSpace(char){\n return char === ' ' \|\| char === '\\t' \|\| char === '\\n' \|\| char === '\\r';\n}\n/\n Read Processing insstructions and skip\n * @param {} xmlData\n @param {} i\n /\nfunction readPI(xmlData, i) {\n const start = i;\n for (; i < xmlData.length; i++) {\n if (xmlData[i] == '?' \|\| xmlData[i] == ' ') {\n //tagname\n const tagname = xmlData.substr(start, i - start);\n if (i > 5 && tagname === 'xml') {\n return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i));\n } else if (xmlData[i] == '?' && xmlData[i + 1] == '>') {\n //check if valid attribut string\n i++;\n break;\n } else {\n continue;\n }\n }\n }\n return i;\n}\n\nfunction readCommentAndCDATA(xmlData, i) {\n if (xmlData.length > i + 5 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') {\n //comment\n for (i += 3; i < xmlData.length; i++) {\n if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') {\n i += 2;\n break;\n }\n }\n } else if (\n xmlData.length > i + 8 &&\n xmlData[i + 1] === 'D' &&\n xmlData[i + 2] === 'O' &&\n xmlData[i + 3] === 'C' &&\n xmlData[i + 4] === 'T' &&\n xmlData[i + 5] === 'Y' &&\n xmlData[i + 6] === 'P' &&\n xmlData[i + 7] === 'E'\n ) {\n let angleBracketsCount = 1;\n for (i += 8; i < xmlData.length; i++) {\n if (xmlData[i] === '<') {\n angleBracketsCount++;\n } else if (xmlData[i] === '>') {\n angleBracketsCount--;\n if (angleBracketsCount === 0) {\n break;\n }\n }\n }\n } else if (\n xmlData.length > i + 9 &&\n xmlData[i + 1] === '[' &&\n xmlData[i + 2] === 'C' &&\n xmlData[i + 3] === 'D' &&\n xmlData[i + 4] === 'A' &&\n xmlData[i + 5] === 'T' &&\n xmlData[i + 6] === 'A' &&\n xmlData[i + 7] === '['\n ) {\n for (i += 8; i < xmlData.length; i++) {\n if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') {\n i += 2;\n break;\n }\n }\n }\n\n return i;\n}\n\nconst doubleQuote = '\"';\nconst singleQuote = \"'\";\n\n/*\n Keep reading xmlData until '<' is found outside the attribute value.\n * @param {string} xmlData\n * @param {number} i\n /\nfunction readAttributeStr(xmlData, i) {\n let attrStr = '';\n let startChar = '';\n let tagClosed = false;\n for (; i < xmlData.length; i++) {\n if (xmlData[i] === doubleQuote \|\| xmlData[i] === singleQuote) {\n if (startChar === '') {\n startChar = xmlData[i];\n } else if (startChar !== xmlData[i]) {\n //if vaue is enclosed with double quote then single quotes are allowed inside the value and vice versa\n } else {\n startChar = '';\n }\n } else if (xmlData[i] === '>') {\n if (startChar === '') {\n tagClosed = true;\n break;\n }\n }\n attrStr += xmlData[i];\n }\n if (startChar !== '') {\n return false;\n }\n\n return {\n value: attrStr,\n index: i,\n tagClosed: tagClosed\n };\n}\n\n/\n Select all the attributes whether valid or invalid.\n /\nconst validAttrStrRegxp = new RegExp('(\\\\s)([^\\\\s=]+)(\\\\s=)?(\\\\s([\\'\"])(([\\\\s\\\\S])?)\\\\5)?', 'g');\n\n//attr, =\"sd\", a=\"amit's\", a=\"sd\"b=\"saf\", ab cd=\"\"\n\nfunction validateAttributeString(attrStr, options) {\n //console.log(\"start:\"+attrStr+\":end\");\n\n //if(attrStr.trim().length === 0) return true; //empty string\n\n const matches = getAllMatches(attrStr, validAttrStrRegxp);\n const attrNames = {};\n\n for (let i = 0; i < matches.length; i++) {\n if (matches[i][1].length === 0) {\n //nospace before attribute name: a=\"sd\"b=\"saf\"\n return getErrorObject('InvalidAttr', \"Attribute '\"+matches[i][2]+\"' has no space in starting.\", getPositionFromMatch(matches[i]))\n } else if (matches[i][3] !== undefined && matches[i][4] === undefined) {\n return getErrorObject('InvalidAttr', \"Attribute '\"+matches[i][2]+\"' is without value.\", getPositionFromMatch(matches[i]));\n } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {\n //independent attribute: ab\n return getErrorObject('InvalidAttr', \"boolean attribute '\"+matches[i][2]+\"' is not allowed.\", getPositionFromMatch(matches[i]));\n }\n / else if(matches[i][6] === undefined){//attribute without value: ab=\n return { err: { code:\"InvalidAttr\",msg:\"attribute \" + matches[i][2] + \" has no value assigned.\"}};\n } /\n const attrName = matches[i][2];\n if (!validateAttrName(attrName)) {\n return getErrorObject('InvalidAttr', \"Attribute '\"+attrName+\"' is an invalid name.\", getPositionFromMatch(matches[i]));\n }\n if (!attrNames.hasOwnProperty(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 { 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);\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 ' '\")\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"],"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","defaultOptions","preserveOrder","attributeNamePrefix","attributesGroupName","textNodeName","ignoreAttributes","removeNSPrefix","allowBooleanAttributes","parseTagValue","parseAttributeValue","trimValues","cdataPropName","numberParseOptions","hex","leadingZeros","eNotation","tagValueProcessor","tagName","val","attributeValueProcessor","attrName","stopNodes","alwaysCreateTextNode","isArray","commentPropName","unpairedTags","processEntities","htmlEntities","ignoreDeclaration","ignorePiTags","transformTagName","transformAttributeName","updateTag","jPath","attrs","captureMetaData","normalizeProcessEntities","enabled","maxEntitySize","maxExpansionDepth","maxTotalExpansions","maxExpandedLength","allowedTags","tagFilter","_value$maxEntitySize","_value$maxExpansionDe","_value$maxTotalExpans","_value$maxExpandedLen","_value$allowedTags","_value$tagFilter","buildOptions","options","built","assign","nameStartChar","regexName","RegExp","getAllMatches","string","regex","matches","match","exec","allmatches","startIndex","lastIndex","length","len","index","push","METADATA_SYMBOL","isName","XmlNode","tagname","child","_proto","add","_this$child$push","addChild","node","_this$child$push2","_this$child$push3","keys","undefined","getMetaDataSymbol","DocTypeReader","suppressValidationErr","readDocType","xmlData","i","entities","Error","angleBracketsCount","hasBody","comment","hasSeq","entityName","_this$readEntityExp","readEntityExp","indexOf","escaped","replace","regx","readElementExp","readNotationExp","skipWhitespace","test","validateEntityName","substring","toUpperCase","entityValue","_this$readIdentifierV","readIdentifierVal","notationName","identifierType","publicIdentifier","systemIdentifier","_this$readIdentifierV2","_this$readIdentifierV3","_this$readIdentifierV4","type","identifierVal","startChar","elementName","contentModel","trim","readAttlistExp","attributeName","attributeType","allowedNotations","notation","join","includes","defaultValue","_this$readIdentifierV5","data","seq","j","name","hexRegex","numRegex","consider","decimalPoint","eNotationRegx","OrderedObjParser","currentNode","tagsNodeStack","docTypeEntities","lastEntities","ampEntity","_","str","fromCodePoint","addExternalEntities","parseXml","parseTextData","resolveNameSpace","buildAttributesMap","isItStopNode","replaceEntitiesValue","readStopNodeData","saveTextToParentTag","ignoreAttributesFn","Array","_step","_iterator","_createForOfIteratorHelperLoose","done","pattern","entityExpansionCount","currentExpandedLength","stopNodesExact","Set","stopNodesWildcard","stopNodeExp","startsWith","externalEntities","entKeys","ent","dontTrim","hasAttributes","isLeafNode","escapeEntities","newval","parseValue","tags","split","prefix","charAt","attrsRegx","attrStr","oldVal","aName","newVal","attrCollection","xmlObj","xmlNode","textData","docTypeReader","closeIndex","findClosingIndex","colonIndex","substr","lastTagName","lastIndexOf","propIndex","pop","tagData","readTagExp","childNode","tagExp","attrExpPresent","endIndex","_ref","result","_ref2","rawTagName","newTagName","lastTag","tagContent","entityConfig","entity","lengthBefore","currentTagName","has","errMsg","closingIndex","closingChar","attrBoundary","ch","tagExpWithClosingIndex","separatorIndex","search","trimStart","openTagCount","shouldParse","trimmedStr","skipLike","numStr","parseInt","Number","window","parse_int","sign","eChar","eAdjacentToLeadingZeros","resolveEnotation","numTrimmedByZeros","decimalAdjacentToLeadingZeros","num","parsedStr","String","n","toNumber","base","codePoint","prettify","compress","arr","text","compressedObj","newJpath","tagObj","property","propName","isLeaf","isLeafTag","assignAttributes","attrMap","jpath","atrrName","propCount","isWhiteSpace","char","readPI","start","getErrorObject","getLineNumberForPosition","readCommentAndCDATA","readAttributeStr","tagClosed","validAttrStrRegxp","validateAttributeString","attrNames","getPositionFromMatch","validateAttrName","validateAmpersand","re","validateNumberAmpersand","count","code","message","lineNumber","err","msg","line","col","lines","XMLParser","parse","validationOption","toString","tagFound","reachedRoot","tagStartPos","closingTag","attrStrStart","isValid","otg","openPos","afterAmp","JSON","stringify","map","t","validate","orderedObjParser","orderedResult","addEntity"],"sourceRoot":""}
1	+ {"version":3,"file":"./lib/fxparser.min.js","mappings":"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","sources":["webpack://XMLParser/webpack/universalModuleDefinition","webpack://XMLParser/webpack/bootstrap","webpack://XMLParser/webpack/runtime/define property getters","webpack://XMLParser/webpack/runtime/hasOwnProperty shorthand","webpack://XMLParser/webpack/runtime/make namespace object","webpack://XMLParser/./src/util.js","webpack://XMLParser/./src/xmlparser/OptionsBuilder.js","webpack://XMLParser/./src/xmlparser/xmlNode.js","webpack://XMLParser/./src/xmlparser/DocTypeReader.js","webpack://XMLParser/./node_modules/strnum/strnum.js","webpack://XMLParser/./node_modules/path-expression-matcher/src/Matcher.js","webpack://XMLParser/./node_modules/path-expression-matcher/src/Expression.js","webpack://XMLParser/./src/xmlparser/OrderedObjParser.js","webpack://XMLParser/./src/ignoreAttributes.js","webpack://XMLParser/./src/xmlparser/node2json.js","webpack://XMLParser/./src/validator.js","webpack://XMLParser/./src/xmlparser/XMLParser.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[\"XMLParser\"] = factory();\n\telse\n\t\troot[\"XMLParser\"] = 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\"];","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}","'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 { 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 ' '\")\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}"],"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","defaultOnDangerousProperty","name","includes","defaultOptions","preserveOrder","attributeNamePrefix","attributesGroupName","textNodeName","ignoreAttributes","removeNSPrefix","allowBooleanAttributes","parseTagValue","parseAttributeValue","trimValues","cdataPropName","numberParseOptions","hex","leadingZeros","eNotation","tagValueProcessor","tagName","val","attributeValueProcessor","attrName","stopNodes","alwaysCreateTextNode","isArray","commentPropName","unpairedTags","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","options","built","assign","_i","_propertyNameOptions","_propertyNameOptions$","Array","map","node","startsWith","substring","XmlNode","tagname","child","create","_proto","add","_this$child$push","addChild","_this$child$push2","_this$child$push3","keys","undefined","getMetaDataSymbol","DocTypeReader","suppressValidationErr","readDocType","xmlData","i","entities","entityCount","angleBracketsCount","hasBody","comment","hasSeq","entityName","_this$readEntityExp","readEntityExp","indexOf","escaped","replace","regx","readElementExp","readNotationExp","skipWhitespace","test","validateEntityName","toUpperCase","entityValue","_this$readIdentifierV","readIdentifierVal","notationName","identifierType","publicIdentifier","systemIdentifier","_this$readIdentifierV2","_this$readIdentifierV3","_this$readIdentifierV4","type","identifierVal","startChar","elementName","contentModel","trim","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","count","set","tag","pop","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","tags","split","prefix","charAt","attrsRegx","attrStr","rawAttrsForMatcher","oldVal","parsedVal","jPathStr","aName","sanitizeName","newVal","attrCollection","xmlObj","xmlNode","textData","docTypeReader","closeIndex","findClosingIndex","substr","lastTagName","tagData","readTagExp","childNode","tagExp","attrExpPresent","endIndex","_ref","result","_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","isWhiteSpace","char","readPI","start","getErrorObject","getLineNumberForPosition","readCommentAndCDATA","readAttributeStr","tagClosed","validAttrStrRegxp","validateAttributeString","attrNames","getPositionFromMatch","validateAttrName","validateAmpersand","re","validateNumberAmpersand","code","message","lineNumber","err","msg","line","col","validateTagName","lines","XMLParser","parse","validationOption","tagFound","reachedRoot","tagStartPos","closingTag","attrStrStart","isValid","otg","openPos","afterAmp","JSON","stringify","t","validate","orderedObjParser","orderedResult","addEntity"],"sourceRoot":""}