@cdklabs/cdk-ecs-codedeploy 0.0.440 → 0.0.442

package/node_modules/fast-xml-builder/lib/fxb.min.js.map

@@ -1 +1 @@
-{"version":3,"file":"./lib/fxb.min.js","mappings":"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","sources":["webpack://fxb/webpack/universalModuleDefinition","webpack://fxb/webpack/bootstrap","webpack://fxb/webpack/runtime/define property getters","webpack://fxb/webpack/runtime/hasOwnProperty shorthand","webpack://fxb/webpack/runtime/make namespace object","webpack://fxb/./node_modules/path-expression-matcher/src/Expression.js","webpack://fxb/./node_modules/path-expression-matcher/src/Matcher.js","webpack://fxb/./src/util.js","webpack://fxb/./src/orderedJs2Xml.js","webpack://fxb/./src/fxb.js","webpack://fxb/./src/ignoreAttributes.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[\"fxb\"] = factory();\n\telse\n\t\troot[\"fxb\"] = 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};","/**\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}","/**\n * Matcher - Tracks current path in XML/JSON tree and matches against Expressions\n * \n * The matcher maintains a stack of nodes representing the current path from root to\n * current tag. It only stores attribute values for the current (top) node to minimize\n * memory usage. Sibling tracking is used to auto-calculate position and counter.\n * \n * @example\n * const matcher = new Matcher();\n * matcher.push(\"root\", {});\n * matcher.push(\"users\", {});\n * matcher.push(\"user\", { id: \"123\", type: \"admin\" });\n * \n * const expr = new Expression(\"root.users.user\");\n * matcher.matches(expr); // true\n */\nexport default class Matcher {\n  /**\n   * Create a new Matcher\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Default path separator (default: '.')\n   */\n  constructor(options = {}) {\n    this.separator = options.separator || '.';\n    this.path = [];\n    this.siblingStacks = [];\n    // Each path node: { tag: string, values: object, position: number, counter: number }\n    // values only present for current (last) node\n    // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n  }\n\n  /**\n   * Push a new tag onto the path\n   * @param {string} tagName - Name of the tag\n   * @param {Object} attrValues - Attribute key-value pairs for current node (optional)\n   * @param {string} namespace - Namespace for the tag (optional)\n   */\n  push(tagName, attrValues = null, namespace = null) {\n    // Remove values from previous current node (now becoming ancestor)\n    if (this.path.length > 0) {\n      const prev = this.path[this.path.length - 1];\n      prev.values = undefined;\n    }\n\n    // Get or create sibling tracking for current level\n    const currentLevel = this.path.length;\n    if (!this.siblingStacks[currentLevel]) {\n      this.siblingStacks[currentLevel] = new Map();\n    }\n\n    const siblings = this.siblingStacks[currentLevel];\n\n    // Create a unique key for sibling tracking that includes namespace\n    const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;\n\n    // Calculate counter (how many times this tag appeared at this level)\n    const counter = siblings.get(siblingKey) || 0;\n\n    // Calculate position (total children at this level so far)\n    let position = 0;\n    for (const count of siblings.values()) {\n      position += count;\n    }\n\n    // Update sibling count for this tag\n    siblings.set(siblingKey, counter + 1);\n\n    // Create new node\n    const node = {\n      tag: tagName,\n      position: position,\n      counter: counter\n    };\n\n    // Store namespace if provided\n    if (namespace !== null && namespace !== undefined) {\n      node.namespace = namespace;\n    }\n\n    // Store values only for current node\n    if (attrValues !== null && attrValues !== undefined) {\n      node.values = attrValues;\n    }\n\n    this.path.push(node);\n  }\n\n  /**\n   * Pop the last tag from the path\n   * @returns {Object|undefined} The popped node\n   */\n  pop() {\n    if (this.path.length === 0) {\n      return undefined;\n    }\n\n    const node = this.path.pop();\n\n    // Clean up sibling tracking for levels deeper than current\n    // After pop, path.length is the new depth\n    // We need to clean up siblingStacks[path.length + 1] and beyond\n    if (this.siblingStacks.length > this.path.length + 1) {\n      this.siblingStacks.length = this.path.length + 1;\n    }\n\n    return node;\n  }\n\n  /**\n   * Update current node's attribute values\n   * Useful when attributes are parsed after push\n   * @param {Object} attrValues - Attribute values\n   */\n  updateCurrent(attrValues) {\n    if (this.path.length > 0) {\n      const current = this.path[this.path.length - 1];\n      if (attrValues !== null && attrValues !== undefined) {\n        current.values = attrValues;\n      }\n    }\n  }\n\n  /**\n   * Get current tag name\n   * @returns {string|undefined}\n   */\n  getCurrentTag() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;\n  }\n\n  /**\n   * Get current namespace\n   * @returns {string|undefined}\n   */\n  getCurrentNamespace() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;\n  }\n\n  /**\n   * Get current node's attribute value\n   * @param {string} attrName - Attribute name\n   * @returns {*} Attribute value or undefined\n   */\n  getAttrValue(attrName) {\n    if (this.path.length === 0) return undefined;\n    const current = this.path[this.path.length - 1];\n    return current.values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute\n   * @param {string} attrName - Attribute name\n   * @returns {boolean}\n   */\n  hasAttr(attrName) {\n    if (this.path.length === 0) return false;\n    const current = this.path[this.path.length - 1];\n    return current.values !== undefined && attrName in current.values;\n  }\n\n  /**\n   * Get current node's sibling position (child index in parent)\n   * @returns {number}\n   */\n  getPosition() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].position ?? 0;\n  }\n\n  /**\n   * Get current node's repeat counter (occurrence count of this tag name)\n   * @returns {number}\n   */\n  getCounter() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].counter ?? 0;\n  }\n\n  /**\n   * Get current node's sibling index (alias for getPosition for backward compatibility)\n   * @returns {number}\n   * @deprecated Use getPosition() or getCounter() instead\n   */\n  getIndex() {\n    return this.getPosition();\n  }\n\n  /**\n   * Get current path depth\n   * @returns {number}\n   */\n  getDepth() {\n    return this.path.length;\n  }\n\n  /**\n   * Get path as string\n   * @param {string} separator - Optional separator (uses default if not provided)\n   * @param {boolean} includeNamespace - Whether to include namespace in output (default: true)\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    const sep = separator || this.separator;\n    return this.path.map(n => {\n      if (includeNamespace && n.namespace) {\n        return `${n.namespace}:${n.tag}`;\n      }\n      return n.tag;\n    }).join(sep);\n  }\n\n  /**\n   * Get path as array of tag names\n   * @returns {string[]}\n   */\n  toArray() {\n    return this.path.map(n => n.tag);\n  }\n\n  /**\n   * Reset the path to empty\n   */\n  reset() {\n    this.path = [];\n    this.siblingStacks = [];\n  }\n\n  /**\n   * Match current path against an Expression\n   * @param {Expression} expression - The expression to match against\n   * @returns {boolean} True if current path matches the expression\n   */\n  matches(expression) {\n    const segments = expression.segments;\n\n    if (segments.length === 0) {\n      return false;\n    }\n\n    // Handle deep wildcard patterns\n    if (expression.hasDeepWildcard()) {\n      return this._matchWithDeepWildcard(segments);\n    }\n\n    // Simple path matching (no deep wildcards)\n    return this._matchSimple(segments);\n  }\n\n  /**\n   * Match simple path (no deep wildcards)\n   * @private\n   */\n  _matchSimple(segments) {\n    // Path must be same length as segments\n    if (this.path.length !== segments.length) {\n      return false;\n    }\n\n    // Match each segment bottom-to-top\n    for (let i = 0; i < segments.length; i++) {\n      const segment = segments[i];\n      const node = this.path[i];\n      const isCurrentNode = (i === this.path.length - 1);\n\n      if (!this._matchSegment(segment, node, isCurrentNode)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Match path with deep wildcards\n   * @private\n   */\n  _matchWithDeepWildcard(segments) {\n    let pathIdx = this.path.length - 1;  // Start from current node (bottom)\n    let segIdx = segments.length - 1;     // Start from last segment\n\n    while (segIdx >= 0 && pathIdx >= 0) {\n      const segment = segments[segIdx];\n\n      if (segment.type === 'deep-wildcard') {\n        // \"..\" matches zero or more levels\n        segIdx--;\n\n        if (segIdx < 0) {\n          // Pattern ends with \"..\", always matches\n          return true;\n        }\n\n        // Find where next segment matches in the path\n        const nextSeg = segments[segIdx];\n        let found = false;\n\n        for (let i = pathIdx; i >= 0; i--) {\n          const isCurrentNode = (i === this.path.length - 1);\n          if (this._matchSegment(nextSeg, this.path[i], isCurrentNode)) {\n            pathIdx = i - 1;\n            segIdx--;\n            found = true;\n            break;\n          }\n        }\n\n        if (!found) {\n          return false;\n        }\n      } else {\n        // Regular segment\n        const isCurrentNode = (pathIdx === this.path.length - 1);\n        if (!this._matchSegment(segment, this.path[pathIdx], isCurrentNode)) {\n          return false;\n        }\n        pathIdx--;\n        segIdx--;\n      }\n    }\n\n    // All segments must be consumed\n    return segIdx < 0;\n  }\n\n  /**\n   * Match a single segment against a node\n   * @private\n   * @param {Object} segment - Segment from Expression\n   * @param {Object} node - Node from path\n   * @param {boolean} isCurrentNode - Whether this is the current (last) node\n   * @returns {boolean}\n   */\n  _matchSegment(segment, node, isCurrentNode) {\n    // Match tag name (* is wildcard)\n    if (segment.tag !== '*' && segment.tag !== node.tag) {\n      return false;\n    }\n\n    // Match namespace if specified in segment\n    if (segment.namespace !== undefined) {\n      // Segment has namespace - node must match it\n      if (segment.namespace !== '*' && segment.namespace !== node.namespace) {\n        return false;\n      }\n    }\n    // If segment has no namespace, it matches nodes with or without namespace\n\n    // Match attribute name (check if node has this attribute)\n    // Can only check for current node since ancestors don't have values\n    if (segment.attrName !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check attributes for ancestor nodes (values not stored)\n        return false;\n      }\n\n      if (!node.values || !(segment.attrName in node.values)) {\n        return false;\n      }\n\n      // Match attribute value (only possible for current node)\n      if (segment.attrValue !== undefined) {\n        const actualValue = node.values[segment.attrName];\n        // Both should be strings\n        if (String(actualValue) !== String(segment.attrValue)) {\n          return false;\n        }\n      }\n    }\n\n    // Match position (only for current node)\n    if (segment.position !== undefined) {\n      if (!isCurrentNode) {\n        // Can't check position for ancestor nodes\n        return false;\n      }\n\n      const counter = node.counter ?? 0;\n\n      if (segment.position === 'first' && counter !== 0) {\n        return false;\n      } else if (segment.position === 'odd' && counter % 2 !== 1) {\n        return false;\n      } else if (segment.position === 'even' && counter % 2 !== 0) {\n        return false;\n      } else if (segment.position === 'nth') {\n        if (counter !== segment.positionValue) {\n          return false;\n        }\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Create a snapshot of current state\n   * @returns {Object} State snapshot\n   */\n  snapshot() {\n    return {\n      path: this.path.map(node => ({ ...node })),\n      siblingStacks: this.siblingStacks.map(map => new Map(map))\n    };\n  }\n\n  /**\n   * Restore state from snapshot\n   * @param {Object} snapshot - State snapshot\n   */\n  restore(snapshot) {\n    this.path = snapshot.path.map(node => ({ ...node }));\n    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));\n  }\n}","\n\nexport function safeComment(val) {\n  return String(val)\n    .replace(/--/g, '- -')   // -- is illegal anywhere in comment content\n    .replace(/--/g, '- -')   // handle the scenario when 2 consiucative dashes appears \n    .replace(/-$/, '- ');    // trailing - would form -- with the closing -->\n}\n\nexport function safeCdata(val) {\n  return String(val).replace(/\\]\\]>/g, ']]]]><![CDATA[>')\n}\n\nexport function escapeAttribute(val) {\n  return String(val).replace(/\"/g, '&quot;').replace(/'/g, '&apos;')\n}","import { Expression, Matcher } from 'path-expression-matcher';\nimport { safeComment, safeCdata, escapeAttribute } from \"./util.js\";\n\nconst EOL = \"\\n\";\n\n/**\n * \n * @param {array} jArray \n * @param {any} options \n * @returns \n */\nexport default function toXml(jArray, options) {\n    let indentation = \"\";\n    if (options.format && options.indentBy.length > 0) {\n        indentation = EOL;\n    }\n\n    // Pre-compile stopNode expressions for pattern matching\n    const stopNodeExpressions = [];\n    if (options.stopNodes && Array.isArray(options.stopNodes)) {\n        for (let i = 0; i < options.stopNodes.length; i++) {\n            const node = options.stopNodes[i];\n            if (typeof node === 'string') {\n                stopNodeExpressions.push(new Expression(node));\n            } else if (node instanceof Expression) {\n                stopNodeExpressions.push(node);\n            }\n        }\n    }\n\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n\n    return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions);\n}\n\nfunction arrToStr(arr, options, indentation, matcher, stopNodeExpressions) {\n    let xmlStr = \"\";\n    let isPreviousElementTag = false;\n\n    if (options.maxNestedTags && matcher.getDepth() > options.maxNestedTags) {\n        throw new Error(\"Maximum nested tags exceeded\");\n    }\n\n    if (!Array.isArray(arr)) {\n        // Non-array values (e.g. string tag values) should be treated as text content\n        if (arr !== undefined && arr !== null) {\n            let text = arr.toString();\n            text = replaceEntitiesValue(text, options);\n            return text;\n        }\n        return \"\";\n    }\n\n    for (let i = 0; i < arr.length; i++) {\n        const tagObj = arr[i];\n        const tagName = propName(tagObj);\n        if (tagName === undefined) continue;\n\n        // Extract attributes from \":@\" property\n        const attrValues = extractAttributeValues(tagObj[\":@\"], options);\n\n        // Push tag to matcher WITH attributes\n        matcher.push(tagName, attrValues);\n\n        // Check if this is a stop node using Expression matching\n        const isStopNode = checkStopNode(matcher, stopNodeExpressions);\n\n        if (tagName === options.textNodeName) {\n            let tagText = tagObj[tagName];\n            if (!isStopNode) {\n                tagText = options.tagValueProcessor(tagName, tagText);\n                tagText = replaceEntitiesValue(tagText, options);\n            }\n            if (isPreviousElementTag) {\n                xmlStr += indentation;\n            }\n            xmlStr += tagText;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.cdataPropName) {\n            if (isPreviousElementTag) {\n                xmlStr += indentation;\n            }\n            const val = tagObj[tagName][0][options.textNodeName];\n            const safeVal = safeCdata(val);\n            xmlStr += `<![CDATA[${safeVal}]]>`;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.commentPropName) {\n            const val = tagObj[tagName][0][options.textNodeName]\n            const safeVal = safeComment(val)\n            xmlStr += indentation + `<!--${safeVal}-->`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        } else if (tagName[0] === \"?\") {\n            const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode);\n            const tempInd = tagName === \"?xml\" ? \"\" : indentation;\n            let piTextNodeName = tagObj[tagName][0][options.textNodeName];\n            piTextNodeName = piTextNodeName.length !== 0 ? \" \" + piTextNodeName : \"\"; //remove extra spacing\n            xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr}?>`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        }\n\n        let newIdentation = indentation;\n        if (newIdentation !== \"\") {\n            newIdentation += options.indentBy;\n        }\n\n        // Pass isStopNode to attr_to_str so attributes are also not processed for stopNodes\n        const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode);\n        const tagStart = indentation + `<${tagName}${attStr}`;\n\n        // If this is a stopNode, get raw content without processing\n        let tagValue;\n        if (isStopNode) {\n            tagValue = getRawContent(tagObj[tagName], options);\n        } else {\n\n            tagValue = arrToStr(tagObj[tagName], options, newIdentation, matcher, stopNodeExpressions);\n        }\n\n        if (options.unpairedTags.indexOf(tagName) !== -1) {\n            if (options.suppressUnpairedNode) xmlStr += tagStart + \">\";\n            else xmlStr += tagStart + \"/>\";\n        } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {\n            xmlStr += tagStart + \"/>\";\n        } else if (tagValue && tagValue.endsWith(\">\")) {\n            xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;\n        } else {\n            xmlStr += tagStart + \">\";\n            if (tagValue && indentation !== \"\" && (tagValue.includes(\"/>\") || tagValue.includes(\"</\"))) {\n                xmlStr += indentation + options.indentBy + tagValue + indentation;\n            } else {\n                xmlStr += tagValue;\n            }\n            xmlStr += `</${tagName}>`;\n        }\n        isPreviousElementTag = true;\n\n        // Pop tag from matcher\n        matcher.pop();\n    }\n\n    return xmlStr;\n}\n\n/**\n * Extract attribute values from the \":@\" object and return as plain object\n * for passing to matcher.push()\n */\nfunction extractAttributeValues(attrMap, options) {\n    if (!attrMap || options.ignoreAttributes) return null;\n\n    const attrValues = {};\n    let hasAttrs = false;\n\n    for (let attr in attrMap) {\n        if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n        // Remove the attribute prefix to get clean attribute name\n        const cleanAttrName = attr.startsWith(options.attributeNamePrefix)\n            ? attr.substr(options.attributeNamePrefix.length)\n            : attr;\n        attrValues[cleanAttrName] = escapeAttribute(attrMap[attr]);\n        hasAttrs = true;\n    }\n\n    return hasAttrs ? attrValues : null;\n}\n\n/**\n * Extract raw content from a stopNode without any processing\n * This preserves the content exactly as-is, including special characters\n */\nfunction getRawContent(arr, options) {\n    if (!Array.isArray(arr)) {\n        // Non-array values return as-is\n        if (arr !== undefined && arr !== null) {\n            return arr.toString();\n        }\n        return \"\";\n    }\n\n    let content = \"\";\n    for (let i = 0; i < arr.length; i++) {\n        const item = arr[i];\n        const tagName = propName(item);\n\n        if (tagName === options.textNodeName) {\n            // Raw text content - NO processing, NO entity replacement\n            content += item[tagName];\n        } else if (tagName === options.cdataPropName) {\n            // CDATA content\n            content += item[tagName][0][options.textNodeName];\n        } else if (tagName === options.commentPropName) {\n            // Comment content\n            content += item[tagName][0][options.textNodeName];\n        } else if (tagName && tagName[0] === \"?\") {\n            // Processing instruction - skip for stopNodes\n            continue;\n        } else if (tagName) {\n            // Nested tags within stopNode\n            // Recursively get raw content and reconstruct the tag\n            // For stopNodes, we don't process attributes either\n            const attStr = attr_to_str_raw(item[\":@\"], options);\n            const nestedContent = getRawContent(item[tagName], options);\n\n            if (!nestedContent || nestedContent.length === 0) {\n                content += `<${tagName}${attStr}/>`;\n            } else {\n                content += `<${tagName}${attStr}>${nestedContent}</${tagName}>`;\n            }\n        }\n    }\n    return content;\n}\n\n/**\n * Build attribute string for stopNodes - NO entity replacement\n */\nfunction attr_to_str_raw(attrMap, options) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n            // For stopNodes, use raw value without processing\n            let attrVal = attrMap[attr];\n            if (attrVal === true && options.suppressBooleanAttributes) {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;\n            } else {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}=\"${escapeAttribute(attrVal)}\"`;\n            }\n        }\n    }\n    return attrStr;\n}\n\nfunction propName(obj) {\n    const keys = Object.keys(obj);\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n        if (key !== \":@\") return key;\n    }\n}\n\nfunction attr_to_str(attrMap, options, isStopNode) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n            let attrVal;\n\n            if (isStopNode) {\n                // For stopNodes, use raw value without any processing\n                attrVal = attrMap[attr];\n            } else {\n                // Normal processing: apply attributeValueProcessor and entity replacement\n                attrVal = options.attributeValueProcessor(attr, attrMap[attr]);\n                attrVal = replaceEntitiesValue(attrVal, options);\n            }\n\n            if (attrVal === true && options.suppressBooleanAttributes) {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;\n            } else {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}=\"${escapeAttribute(attrVal)}\"`;\n            }\n        }\n    }\n    return attrStr;\n}\n\nfunction checkStopNode(matcher, stopNodeExpressions) {\n    if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;\n\n    for (let i = 0; i < stopNodeExpressions.length; i++) {\n        if (matcher.matches(stopNodeExpressions[i])) {\n            return true;\n        }\n    }\n    return false;\n}\n\nfunction replaceEntitiesValue(textValue, options) {\n    if (textValue && textValue.length > 0 && options.processEntities) {\n        for (let i = 0; i < options.entities.length; i++) {\n            const entity = options.entities[i];\n            textValue = textValue.replace(entity.regex, entity.val);\n        }\n    }\n    return textValue;\n}\n\nfunction cdataVal(val) {\n\n}\n\nfunction commentVal(val) {\n\n}","'use strict';\n//parse Empty Node as self closing node\nimport buildFromOrderedJs from './orderedJs2Xml.js';\nimport getIgnoreAttributesFn from \"./ignoreAttributes.js\";\nimport { Expression, Matcher } from 'path-expression-matcher';\nimport { safeComment, safeCdata, escapeAttribute } from './util.js';\n\nconst defaultOptions = {\n  attributeNamePrefix: '@_',\n  attributesGroupName: false,\n  textNodeName: '#text',\n  ignoreAttributes: true,\n  cdataPropName: false,\n  format: false,\n  indentBy: '  ',\n  suppressEmptyNode: false,\n  suppressUnpairedNode: true,\n  suppressBooleanAttributes: true,\n  tagValueProcessor: function (key, a) {\n    return a;\n  },\n  attributeValueProcessor: function (attrName, a) {\n    return a;\n  },\n  preserveOrder: false,\n  commentPropName: false,\n  unpairedTags: [],\n  entities: [\n    { regex: new RegExp(\"&\", \"g\"), val: \"&amp;\" },//it must be on top\n    { regex: new RegExp(\">\", \"g\"), val: \"&gt;\" },\n    { regex: new RegExp(\"<\", \"g\"), val: \"&lt;\" },\n    { regex: new RegExp(\"\\'\", \"g\"), val: \"&apos;\" },\n    { regex: new RegExp(\"\\\"\", \"g\"), val: \"&quot;\" }\n  ],\n  processEntities: true,\n  stopNodes: [],\n  // transformTagName: false,\n  // transformAttributeName: false,\n  oneListGroup: false,\n  maxNestedTags: 100,\n  jPath: true  // When true, callbacks receive string jPath; when false, receive Matcher instance\n};\n\nexport default function Builder(options) {\n  this.options = Object.assign({}, defaultOptions, options);\n\n  // Convert old-style stopNodes for backward compatibility\n  // Old syntax: \"*.tag\" meant \"tag anywhere in tree\"\n  // New syntax: \"..tag\" means \"tag anywhere in tree\"\n  if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) {\n    this.options.stopNodes = this.options.stopNodes.map(node => {\n      if (typeof node === 'string' && node.startsWith('*.')) {\n        // Convert old wildcard syntax to deep wildcard\n        return '..' + node.substring(2);\n      }\n      return node;\n    });\n  }\n\n  // Pre-compile stopNode expressions for pattern matching\n  this.stopNodeExpressions = [];\n  if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) {\n    for (let i = 0; i < this.options.stopNodes.length; i++) {\n      const node = this.options.stopNodes[i];\n      if (typeof node === 'string') {\n        this.stopNodeExpressions.push(new Expression(node));\n      } else if (node instanceof Expression) {\n        this.stopNodeExpressions.push(node);\n      }\n    }\n  }\n\n  if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {\n    this.isAttribute = function (/*a*/) {\n      return false;\n    };\n  } else {\n    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)\n    this.attrPrefixLen = this.options.attributeNamePrefix.length;\n    this.isAttribute = isAttribute;\n  }\n\n  this.processTextOrObjNode = processTextOrObjNode\n\n  if (this.options.format) {\n    this.indentate = indentate;\n    this.tagEndChar = '>\\n';\n    this.newLine = '\\n';\n  } else {\n    this.indentate = function () {\n      return '';\n    };\n    this.tagEndChar = '>';\n    this.newLine = '';\n  }\n}\n\nBuilder.prototype.build = function (jObj) {\n  if (this.options.preserveOrder) {\n    return buildFromOrderedJs(jObj, this.options);\n  } else {\n    if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {\n      jObj = {\n        [this.options.arrayNodeName]: jObj\n      }\n    }\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n    return this.j2x(jObj, 0, matcher).val;\n  }\n};\n\nBuilder.prototype.j2x = function (jObj, level, matcher) {\n  let attrStr = '';\n  let val = '';\n  if (this.options.maxNestedTags && matcher.getDepth() >= this.options.maxNestedTags) {\n    throw new Error(\"Maximum nested tags exceeded\");\n  }\n  // Get jPath based on option: string for backward compatibility, or Matcher for new features\n  const jPath = this.options.jPath ? matcher.toString() : matcher;\n\n  // Check if current node is a stopNode (will be used for attribute encoding)\n  const isCurrentStopNode = this.checkStopNode(matcher);\n\n  for (let key in jObj) {\n    if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;\n    if (typeof jObj[key] === 'undefined') {\n      // supress undefined node only if it is not an attribute\n      if (this.isAttribute(key)) {\n        val += '';\n      }\n    } else if (jObj[key] === null) {\n      // null attribute should be ignored by the attribute list, but should not cause the tag closing\n      if (this.isAttribute(key)) {\n        val += '';\n      } else if (key === this.options.cdataPropName || key === this.options.commentPropName) {\n        val += '';\n      } else if (key[0] === '?') {\n        val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;\n      } else {\n        val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n      }\n      // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n    } else if (jObj[key] instanceof Date) {\n      val += this.buildTextValNode(jObj[key], key, '', level, matcher);\n    } else if (typeof jObj[key] !== 'object') {\n      //premitive type\n      const attr = this.isAttribute(key);\n      if (attr && !this.ignoreAttributesFn(attr, jPath)) {\n        attrStr += this.buildAttrPairStr(attr, '' + jObj[key], isCurrentStopNode);\n      } else if (!attr) {\n        //tag value\n        if (key === this.options.textNodeName) {\n          let newval = this.options.tagValueProcessor(key, '' + jObj[key]);\n          val += this.replaceEntitiesValue(newval);\n        } else {\n          // Check if this is a stopNode before building\n          matcher.push(key);\n          const isStopNode = this.checkStopNode(matcher);\n          matcher.pop();\n\n          if (isStopNode) {\n            // Build as raw content without encoding\n            const textValue = '' + jObj[key];\n            if (textValue === '') {\n              val += this.indentate(level) + '<' + key + this.closeTag(key) + this.tagEndChar;\n            } else {\n              val += this.indentate(level) + '<' + key + '>' + textValue + '</' + key + this.tagEndChar;\n            }\n          } else {\n            val += this.buildTextValNode(jObj[key], key, '', level, matcher);\n          }\n        }\n      }\n    } else if (Array.isArray(jObj[key])) {\n      //repeated nodes\n      const arrLen = jObj[key].length;\n      let listTagVal = \"\";\n      let listTagAttr = \"\";\n      for (let j = 0; j < arrLen; j++) {\n        const item = jObj[key][j];\n        if (typeof item === 'undefined') {\n          // supress undefined node\n        } else if (item === null) {\n          if (key[0] === \"?\") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar;\n          else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n          // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;\n        } else if (typeof item === 'object') {\n          if (this.options.oneListGroup) {\n            // Push tag to matcher before recursive call\n            matcher.push(key);\n            const result = this.j2x(item, level + 1, matcher);\n            // Pop tag from matcher after recursive call\n            matcher.pop();\n\n            listTagVal += result.val;\n            if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {\n              listTagAttr += result.attrStr\n            }\n          } else {\n            listTagVal += this.processTextOrObjNode(item, key, level, matcher)\n          }\n        } else {\n          if (this.options.oneListGroup) {\n            let textValue = this.options.tagValueProcessor(key, item);\n            textValue = this.replaceEntitiesValue(textValue);\n            listTagVal += textValue;\n          } else {\n            // Check if this is a stopNode before building\n            matcher.push(key);\n            const isStopNode = this.checkStopNode(matcher);\n            matcher.pop();\n\n            if (isStopNode) {\n              // Build as raw content without encoding\n              const textValue = '' + item;\n              if (textValue === '') {\n                listTagVal += this.indentate(level) + '<' + key + this.closeTag(key) + this.tagEndChar;\n              } else {\n                listTagVal += this.indentate(level) + '<' + key + '>' + textValue + '</' + key + this.tagEndChar;\n              }\n            } else {\n              listTagVal += this.buildTextValNode(item, key, '', level, matcher);\n            }\n          }\n        }\n      }\n      if (this.options.oneListGroup) {\n        listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);\n      }\n      val += listTagVal;\n    } else {\n      //nested node\n      if (this.options.attributesGroupName && key === this.options.attributesGroupName) {\n        const Ks = Object.keys(jObj[key]);\n        const L = Ks.length;\n        for (let j = 0; j < L; j++) {\n          attrStr += this.buildAttrPairStr(Ks[j], '' + jObj[key][Ks[j]], isCurrentStopNode);\n        }\n      } else {\n        val += this.processTextOrObjNode(jObj[key], key, level, matcher)\n      }\n    }\n  }\n  return { attrStr: attrStr, val: val };\n};\n\nBuilder.prototype.buildAttrPairStr = function (attrName, val, isStopNode) {\n  if (!isStopNode) {\n    val = this.options.attributeValueProcessor(attrName, '' + val);\n    val = this.replaceEntitiesValue(val);\n  }\n  if (this.options.suppressBooleanAttributes && val === \"true\") {\n    return ' ' + attrName;\n  } else return ' ' + attrName + '=\"' + escapeAttribute(val) + '\"';\n}\n\nfunction processTextOrObjNode(object, key, level, matcher) {\n  // Extract attributes to pass to matcher\n  const attrValues = this.extractAttributes(object);\n\n  // Push tag to matcher before recursion WITH attributes\n  matcher.push(key, attrValues);\n\n  // Check if this entire node is a stopNode\n  const isStopNode = this.checkStopNode(matcher);\n\n  if (isStopNode) {\n    // For stopNodes, build raw content without entity encoding\n    const rawContent = this.buildRawContent(object);\n    const attrStr = this.buildAttributesForStopNode(object);\n    matcher.pop();\n    return this.buildObjectNode(rawContent, key, attrStr, level);\n  }\n\n  const result = this.j2x(object, level + 1, matcher);\n  // Pop tag from matcher after recursion\n  matcher.pop();\n\n  if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {\n    return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level, matcher);\n  } else {\n    return this.buildObjectNode(result.val, key, result.attrStr, level);\n  }\n}\n\n// Helper method to extract attributes from an object\nBuilder.prototype.extractAttributes = function (obj) {\n  if (!obj || typeof obj !== 'object') return null;\n\n  const attrValues = {};\n  let hasAttrs = false;\n\n  // Check for attributesGroupName (when attributes are grouped)\n  if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {\n    const attrGroup = obj[this.options.attributesGroupName];\n    for (let attrKey in attrGroup) {\n      if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;\n      // Remove attribute prefix if present\n      const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix)\n        ? attrKey.substring(this.options.attributeNamePrefix.length)\n        : attrKey;\n      attrValues[cleanKey] = escapeAttribute(attrGroup[attrKey]);\n      hasAttrs = true;\n    }\n  } else {\n    // Look for individual attributes (prefixed with attributeNamePrefix)\n    for (let key in obj) {\n      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n      const attr = this.isAttribute(key);\n      if (attr) {\n        attrValues[attr] = escapeAttribute(obj[key]);\n        hasAttrs = true;\n      }\n    }\n  }\n\n  return hasAttrs ? attrValues : null;\n};\n\n// Build raw content for stopNode without entity encoding\nBuilder.prototype.buildRawContent = function (obj) {\n  if (typeof obj === 'string') {\n    return obj; // Already a string, return as-is\n  }\n\n  if (typeof obj !== 'object' || obj === null) {\n    return String(obj);\n  }\n\n  // Check if this is a stopNode data from parser: { \"#text\": \"raw xml\", \"@_attr\": \"val\" }\n  if (obj[this.options.textNodeName] !== undefined) {\n    return obj[this.options.textNodeName]; // Return raw text without encoding\n  }\n\n  // Build raw XML from nested structure\n  let content = '';\n\n  for (let key in obj) {\n    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n\n    // Skip attributes\n    if (this.isAttribute(key)) continue;\n    if (this.options.attributesGroupName && key === this.options.attributesGroupName) continue;\n\n    const value = obj[key];\n\n    if (key === this.options.textNodeName) {\n      content += value; // Raw text\n    } else if (Array.isArray(value)) {\n      // Array of same tag\n      for (let item of value) {\n        if (typeof item === 'string' || typeof item === 'number') {\n          content += `<${key}>${item}</${key}>`;\n        } else if (typeof item === 'object' && item !== null) {\n          const nestedContent = this.buildRawContent(item);\n          const nestedAttrs = this.buildAttributesForStopNode(item);\n          if (nestedContent === '') {\n            content += `<${key}${nestedAttrs}/>`;\n          } else {\n            content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;\n          }\n        }\n      }\n    } else if (typeof value === 'object' && value !== null) {\n      // Nested object\n      const nestedContent = this.buildRawContent(value);\n      const nestedAttrs = this.buildAttributesForStopNode(value);\n      if (nestedContent === '') {\n        content += `<${key}${nestedAttrs}/>`;\n      } else {\n        content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;\n      }\n    } else {\n      // Primitive value\n      content += `<${key}>${value}</${key}>`;\n    }\n  }\n\n  return content;\n};\n\n// Build attribute string for stopNode (no entity encoding)\nBuilder.prototype.buildAttributesForStopNode = function (obj) {\n  if (!obj || typeof obj !== 'object') return '';\n\n  let attrStr = '';\n\n  // Check for attributesGroupName (when attributes are grouped)\n  if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {\n    const attrGroup = obj[this.options.attributesGroupName];\n    for (let attrKey in attrGroup) {\n      if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;\n      const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix)\n        ? attrKey.substring(this.options.attributeNamePrefix.length)\n        : attrKey;\n      const val = attrGroup[attrKey];\n      if (val === true && this.options.suppressBooleanAttributes) {\n        attrStr += ' ' + cleanKey;\n      } else {\n        attrStr += ' ' + cleanKey + '=\"' + val + '\"'; // No encoding for stopNode\n      }\n    }\n  } else {\n    // Look for individual attributes\n    for (let key in obj) {\n      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n      const attr = this.isAttribute(key);\n      if (attr) {\n        const val = obj[key];\n        if (val === true && this.options.suppressBooleanAttributes) {\n          attrStr += ' ' + attr;\n        } else {\n          attrStr += ' ' + attr + '=\"' + val + '\"'; // No encoding for stopNode\n        }\n      }\n    }\n  }\n\n  return attrStr;\n};\n\nBuilder.prototype.buildObjectNode = function (val, key, attrStr, level) {\n  if (val === \"\") {\n    if (key[0] === \"?\") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n    else {\n      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;\n    }\n  } else {\n\n    let tagEndExp = '</' + key + this.tagEndChar;\n    let piClosingChar = \"\";\n\n    if (key[0] === \"?\") {\n      piClosingChar = \"?\";\n      tagEndExp = \"\";\n    }\n\n    // attrStr is an empty string in case the attribute came as undefined or null\n    if ((attrStr || attrStr === '') && val.indexOf('<') === -1) {\n      return (this.indentate(level) + '<' + key + attrStr + piClosingChar + '>' + val + tagEndExp);\n    } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {\n      return this.indentate(level) + `<!--${val}-->` + this.newLine;\n    } else {\n      return (\n        this.indentate(level) + '<' + key + attrStr + piClosingChar + this.tagEndChar +\n        val +\n        this.indentate(level) + tagEndExp);\n    }\n  }\n}\n\nBuilder.prototype.closeTag = function (key) {\n  let closeTag = \"\";\n  if (this.options.unpairedTags.indexOf(key) !== -1) { //unpaired\n    if (!this.options.suppressUnpairedNode) closeTag = \"/\"\n  } else if (this.options.suppressEmptyNode) { //empty\n    closeTag = \"/\";\n  } else {\n    closeTag = `></${key}`\n  }\n  return closeTag;\n}\n\nBuilder.prototype.checkStopNode = function (matcher) {\n  if (!this.stopNodeExpressions || this.stopNodeExpressions.length === 0) return false;\n\n  for (let i = 0; i < this.stopNodeExpressions.length; i++) {\n    if (matcher.matches(this.stopNodeExpressions[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction buildEmptyObjNode(val, key, attrStr, level) {\n  if (val !== '') {\n    return this.buildObjectNode(val, key, attrStr, level);\n  } else {\n    if (key[0] === \"?\") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n    else {\n      return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;\n      // return this.buildTagStr(level,key, attrStr);\n    }\n  }\n}\n\nBuilder.prototype.buildTextValNode = function (val, key, attrStr, level, matcher) {\n  if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {\n    const safeVal = safeCdata(val);\n    return this.indentate(level) + `<![CDATA[${safeVal}]]>` + this.newLine;\n  } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {\n    const safeVal = safeComment(val);\n    return this.indentate(level) + `<!--${safeVal}-->` + this.newLine;\n  } else if (key[0] === \"?\") {//PI tag\n    return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n  } else {\n    // Normal processing: apply tagValueProcessor and entity replacement\n    let textValue = this.options.tagValueProcessor(key, val);\n    textValue = this.replaceEntitiesValue(textValue);\n\n    if (textValue === '') {\n      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;\n    } else {\n      return this.indentate(level) + '<' + key + attrStr + '>' +\n        textValue +\n        '</' + key + this.tagEndChar;\n    }\n  }\n}\n\nBuilder.prototype.replaceEntitiesValue = function (textValue) {\n  if (textValue && textValue.length > 0 && this.options.processEntities) {\n    for (let i = 0; i < this.options.entities.length; i++) {\n      const entity = this.options.entities[i];\n      textValue = textValue.replace(entity.regex, entity.val);\n    }\n  }\n  return textValue;\n}\n\nfunction indentate(level) {\n  return this.options.indentBy.repeat(level);\n}\n\nfunction isAttribute(name /*, options*/) {\n  if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {\n    return name.substr(this.attrPrefixLen);\n  } else {\n    return false;\n  }\n}","export default function getIgnoreAttributesFn(ignoreAttributes) {\n    if (typeof ignoreAttributes === 'function') {\n        return ignoreAttributes\n    }\n    if (Array.isArray(ignoreAttributes)) {\n        return (attrName) => {\n            for (const pattern of ignoreAttributes) {\n                if (typeof pattern === 'string' && attrName === pattern) {\n                    return true\n                }\n                if (pattern instanceof RegExp && pattern.test(attrName)) {\n                    return true\n                }\n            }\n        }\n    }\n    return () => false\n}"],"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","Expression","constructor","pattern","options","separator","segments","_parse","_hasDeepWildcard","some","seg","type","_hasAttributeCondition","undefined","attrName","_hasPositionSelector","position","i","currentPart","length","trim","push","_parseSegment","part","segment","bracketContent","withoutBrackets","bracketMatch","match","content","slice","namespace","tag","tagAndPosition","includes","nsIndex","indexOf","substring","Error","positionMatch","colonIndex","lastIndexOf","tagPart","posPart","test","eqIndex","attrValue","nthMatch","positionValue","parseInt","hasDeepWildcard","hasAttributeCondition","hasPositionSelector","toString","Matcher","path","siblingStacks","tagName","attrValues","values","currentLevel","Map","siblings","siblingKey","counter","count","set","node","pop","updateCurrent","current","getCurrentTag","getCurrentNamespace","getAttrValue","hasAttr","getPosition","getCounter","getIndex","getDepth","includeNamespace","sep","map","n","join","toArray","reset","matches","expression","_matchWithDeepWildcard","_matchSimple","isCurrentNode","_matchSegment","pathIdx","segIdx","nextSeg","found","actualValue","String","snapshot","restore","safeComment","val","replace","safeCdata","escapeAttribute","toXml","jArray","indentation","format","indentBy","stopNodeExpressions","stopNodes","Array","isArray","arrToStr","arr","matcher","xmlStr","isPreviousElementTag","maxNestedTags","text","replaceEntitiesValue","tagObj","propName","extractAttributeValues","isStopNode","checkStopNode","textNodeName","cdataPropName","commentPropName","newIdentation","tagStart","attr_to_str","tagValue","getRawContent","unpairedTags","suppressUnpairedNode","suppressEmptyNode","endsWith","attStr","tempInd","piTextNodeName","tagText","tagValueProcessor","attrMap","ignoreAttributes","hasAttrs","attr","startsWith","attributeNamePrefix","substr","item","attr_to_str_raw","nestedContent","attrStr","attrVal","suppressBooleanAttributes","keys","attributeValueProcessor","textValue","processEntities","entities","entity","regex","_createForOfIteratorHelperLoose","r","e","t","iterator","next","bind","a","_arrayLikeToArray","name","from","_unsupportedIterableToArray","done","TypeError","defaultOptions","attributesGroupName","preserveOrder","RegExp","oneListGroup","jPath","Builder","assign","isAttribute","ignoreAttributesFn","_step","_iterator","attrPrefixLen","processTextOrObjNode","indentate","tagEndChar","newLine","object","level","extractAttributes","rawContent","buildRawContent","buildAttributesForStopNode","buildObjectNode","result","j2x","buildTextValNode","repeat","build","jObj","buildFromOrderedJs","_jObj","arrayNodeName","isCurrentStopNode","Date","buildAttrPairStr","newval","closeTag","arrLen","listTagVal","listTagAttr","j","Ks","L","attrGroup","attrKey","nestedAttrs","cleanKey","tagEndExp","piClosingChar","safeVal"],"sourceRoot":""}
+{"version":3,"file":"./lib/fxb.min.js","mappings":"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","sources":["webpack://fxb/webpack/universalModuleDefinition","webpack://fxb/webpack/bootstrap","webpack://fxb/webpack/runtime/define property getters","webpack://fxb/webpack/runtime/hasOwnProperty shorthand","webpack://fxb/webpack/runtime/make namespace object","webpack://fxb/./node_modules/path-expression-matcher/src/Expression.js","webpack://fxb/./node_modules/path-expression-matcher/src/Matcher.js","webpack://fxb/./src/util.js","webpack://fxb/./node_modules/xml-naming/src/index.js","webpack://fxb/./src/orderedJs2Xml.js","webpack://fxb/./src/fxb.js","webpack://fxb/./src/ignoreAttributes.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[\"fxb\"] = factory();\n\telse\n\t\troot[\"fxb\"] = 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};","/**\n * Expression - Parses and stores a tag pattern expression\n * \n * Patterns are parsed once and stored in an optimized structure for fast matching.\n * \n * @example\n * const expr = new Expression(\"root.users.user\");\n * const expr2 = new Expression(\"..user[id]:first\");\n * const expr3 = new Expression(\"root/users/user\", { separator: '/' });\n */\nexport default class Expression {\n  /**\n   * Create a new Expression\n   * @param {string} pattern - Pattern string (e.g., \"root.users.user\", \"..user[id]\")\n   * @param {Object} options - Configuration options\n   * @param {string} options.separator - Path separator (default: '.')\n   */\n  constructor(pattern, options = {}, data) {\n    this.pattern = pattern;\n    this.separator = options.separator || '.';\n    this.segments = this._parse(pattern);\n    this.data = data;\n    // Cache expensive checks for performance (O(1) instead of O(n))\n    this._hasDeepWildcard = this.segments.some(seg => seg.type === 'deep-wildcard');\n    this._hasAttributeCondition = this.segments.some(seg => seg.attrName !== undefined);\n    this._hasPositionSelector = this.segments.some(seg => seg.position !== undefined);\n  }\n\n  /**\n   * Parse pattern string into segments\n   * @private\n   * @param {string} pattern - Pattern to parse\n   * @returns {Array} Array of segment objects\n   */\n  _parse(pattern) {\n    const segments = [];\n\n    // Split by separator but handle \"..\" specially\n    let i = 0;\n    let currentPart = '';\n\n    while (i < pattern.length) {\n      if (pattern[i] === this.separator) {\n        // Check if next char is also separator (deep wildcard)\n        if (i + 1 < pattern.length && pattern[i + 1] === this.separator) {\n          // Flush current part if any\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n            currentPart = '';\n          }\n          // Add deep wildcard\n          segments.push({ type: 'deep-wildcard' });\n          i += 2; // Skip both separators\n        } else {\n          // Regular separator\n          if (currentPart.trim()) {\n            segments.push(this._parseSegment(currentPart.trim()));\n          }\n          currentPart = '';\n          i++;\n        }\n      } else {\n        currentPart += pattern[i];\n        i++;\n      }\n    }\n\n    // Flush remaining part\n    if (currentPart.trim()) {\n      segments.push(this._parseSegment(currentPart.trim()));\n    }\n\n    return segments;\n  }\n\n  /**\n   * Parse a single segment\n   * @private\n   * @param {string} part - Segment string (e.g., \"user\", \"ns::user\", \"user[id]\", \"ns::user:first\")\n   * @returns {Object} Segment object\n   */\n  _parseSegment(part) {\n    const segment = { type: 'tag' };\n\n    // NEW NAMESPACE SYNTAX (v2.0):\n    // ============================\n    // Namespace uses DOUBLE colon (::)\n    // Position uses SINGLE colon (:)\n    // \n    // Examples:\n    //   \"user\"              → tag\n    //   \"user:first\"        → tag + position\n    //   \"user[id]\"          → tag + attribute\n    //   \"user[id]:first\"    → tag + attribute + position\n    //   \"ns::user\"          → namespace + tag\n    //   \"ns::user:first\"    → namespace + tag + position\n    //   \"ns::user[id]\"      → namespace + tag + attribute\n    //   \"ns::user[id]:first\" → namespace + tag + attribute + position\n    //   \"ns::first\"         → namespace + tag named \"first\" (NO ambiguity!)\n    //\n    // This eliminates all ambiguity:\n    //   :: = namespace separator\n    //   :  = position selector\n    //   [] = attributes\n\n    // Step 1: Extract brackets [attr] or [attr=value]\n    let bracketContent = null;\n    let withoutBrackets = part;\n\n    const bracketMatch = part.match(/^([^\\[]+)(\\[[^\\]]*\\])(.*)$/);\n    if (bracketMatch) {\n      withoutBrackets = bracketMatch[1] + bracketMatch[3];\n      if (bracketMatch[2]) {\n        const content = bracketMatch[2].slice(1, -1);\n        if (content) {\n          bracketContent = content;\n        }\n      }\n    }\n\n    // Step 2: Check for namespace (double colon ::)\n    let namespace = undefined;\n    let tagAndPosition = withoutBrackets;\n\n    if (withoutBrackets.includes('::')) {\n      const nsIndex = withoutBrackets.indexOf('::');\n      namespace = withoutBrackets.substring(0, nsIndex).trim();\n      tagAndPosition = withoutBrackets.substring(nsIndex + 2).trim(); // Skip ::\n\n      if (!namespace) {\n        throw new Error(`Invalid namespace in pattern: ${part}`);\n      }\n    }\n\n    // Step 3: Parse tag and position (single colon :)\n    let tag = undefined;\n    let positionMatch = null;\n\n    if (tagAndPosition.includes(':')) {\n      const colonIndex = tagAndPosition.lastIndexOf(':'); // Use last colon for position\n      const tagPart = tagAndPosition.substring(0, colonIndex).trim();\n      const posPart = tagAndPosition.substring(colonIndex + 1).trim();\n\n      // Verify position is a valid keyword\n      const isPositionKeyword = ['first', 'last', 'odd', 'even'].includes(posPart) ||\n        /^nth\\(\\d+\\)$/.test(posPart);\n\n      if (isPositionKeyword) {\n        tag = tagPart;\n        positionMatch = posPart;\n      } else {\n        // Not a valid position keyword, treat whole thing as tag\n        tag = tagAndPosition;\n      }\n    } else {\n      tag = tagAndPosition;\n    }\n\n    if (!tag) {\n      throw new Error(`Invalid segment pattern: ${part}`);\n    }\n\n    segment.tag = tag;\n    if (namespace) {\n      segment.namespace = namespace;\n    }\n\n    // Step 4: Parse attributes\n    if (bracketContent) {\n      if (bracketContent.includes('=')) {\n        const eqIndex = bracketContent.indexOf('=');\n        segment.attrName = bracketContent.substring(0, eqIndex).trim();\n        segment.attrValue = bracketContent.substring(eqIndex + 1).trim();\n      } else {\n        segment.attrName = bracketContent.trim();\n      }\n    }\n\n    // Step 5: Parse position selector\n    if (positionMatch) {\n      const nthMatch = positionMatch.match(/^nth\\((\\d+)\\)$/);\n      if (nthMatch) {\n        segment.position = 'nth';\n        segment.positionValue = parseInt(nthMatch[1], 10);\n      } else {\n        segment.position = positionMatch;\n      }\n    }\n\n    return segment;\n  }\n\n  /**\n   * Get the number of segments\n   * @returns {number}\n   */\n  get length() {\n    return this.segments.length;\n  }\n\n  /**\n   * Check if expression contains deep wildcard\n   * @returns {boolean}\n   */\n  hasDeepWildcard() {\n    return this._hasDeepWildcard;\n  }\n\n  /**\n   * Check if expression has attribute conditions\n   * @returns {boolean}\n   */\n  hasAttributeCondition() {\n    return this._hasAttributeCondition;\n  }\n\n  /**\n   * Check if expression has position selectors\n   * @returns {boolean}\n   */\n  hasPositionSelector() {\n    return this._hasPositionSelector;\n  }\n\n  /**\n   * Get string representation\n   * @returns {string}\n   */\n  toString() {\n    return this.pattern;\n  }\n}","import ExpressionSet from \"./ExpressionSet.js\";\n\n/**\n * MatcherView - A lightweight read-only view over a Matcher's internal state.\n *\n * Created once by Matcher and reused across all callbacks. Holds a direct\n * reference to the parent Matcher so it always reflects current parser state\n * with zero copying or freezing overhead.\n *\n * Users receive this via {@link Matcher#readOnly} or directly from parser\n * callbacks. It exposes all query and matching methods but has no mutation\n * methods — misuse is caught at the TypeScript level rather than at runtime.\n *\n * @example\n * const matcher = new Matcher();\n * const view = matcher.readOnly();\n *\n * matcher.push(\"root\", {});\n * view.getCurrentTag(); // \"root\"\n * view.getDepth();      // 1\n */\nexport class MatcherView {\n  /**\n   * @param {Matcher} matcher - The parent Matcher instance to read from.\n   */\n  constructor(matcher) {\n    this._matcher = matcher;\n  }\n\n  /**\n   * Get the path separator used by the parent matcher.\n   * @returns {string}\n   */\n  get separator() {\n    return this._matcher.separator;\n  }\n\n  /**\n   * Get current tag name.\n   * @returns {string|undefined}\n   */\n  getCurrentTag() {\n    const path = this._matcher.path;\n    return path.length > 0 ? path[path.length - 1].tag : undefined;\n  }\n\n  /**\n   * Get current namespace.\n   * @returns {string|undefined}\n   */\n  getCurrentNamespace() {\n    const path = this._matcher.path;\n    return path.length > 0 ? path[path.length - 1].namespace : undefined;\n  }\n\n  /**\n   * Get current node's attribute value.\n   * @param {string} attrName\n   * @returns {*}\n   */\n  getAttrValue(attrName) {\n    const path = this._matcher.path;\n    if (path.length === 0) return undefined;\n    return path[path.length - 1].values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute.\n   * @param {string} attrName\n   * @returns {boolean}\n   */\n  hasAttr(attrName) {\n    const path = this._matcher.path;\n    if (path.length === 0) return false;\n    const current = path[path.length - 1];\n    return current.values !== undefined && attrName in current.values;\n  }\n\n  /**\n   * Get current node's sibling position (child index in parent).\n   * @returns {number}\n   */\n  getPosition() {\n    const path = this._matcher.path;\n    if (path.length === 0) return -1;\n    return path[path.length - 1].position ?? 0;\n  }\n\n  /**\n   * Get current node's repeat counter (occurrence count of this tag name).\n   * @returns {number}\n   */\n  getCounter() {\n    const path = this._matcher.path;\n    if (path.length === 0) return -1;\n    return path[path.length - 1].counter ?? 0;\n  }\n\n  /**\n   * Get current node's sibling index (alias for getPosition).\n   * @returns {number}\n   * @deprecated Use getPosition() or getCounter() instead\n   */\n  getIndex() {\n    return this.getPosition();\n  }\n\n  /**\n   * Get current path depth.\n   * @returns {number}\n   */\n  getDepth() {\n    return this._matcher.path.length;\n  }\n\n  /**\n   * Get path as string.\n   * @param {string} [separator] - Optional separator (uses default if not provided)\n   * @param {boolean} [includeNamespace=true]\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    return this._matcher.toString(separator, includeNamespace);\n  }\n\n  /**\n   * Get path as array of tag names.\n   * @returns {string[]}\n   */\n  toArray() {\n    return this._matcher.path.map(n => n.tag);\n  }\n\n  /**\n   * Match current path against an Expression.\n   * @param {Expression} expression\n   * @returns {boolean}\n   */\n  matches(expression) {\n    return this._matcher.matches(expression);\n  }\n\n  /**\n   * Match any expression in the given set against the current path.\n   * @param {ExpressionSet} exprSet\n   * @returns {boolean}\n   */\n  matchesAny(exprSet) {\n    return exprSet.matchesAny(this._matcher);\n  }\n}\n\n/**\n * Matcher - Tracks current path in XML/JSON tree and matches against Expressions.\n *\n * The matcher maintains a stack of nodes representing the current path from root to\n * current tag. It only stores attribute values for the current (top) node to minimize\n * memory usage. Sibling tracking is used to auto-calculate position and counter.\n *\n * Use {@link Matcher#readOnly} to obtain a {@link MatcherView} safe to pass to\n * user callbacks — it always reflects current state with no Proxy overhead.\n *\n * @example\n * const matcher = new Matcher();\n * matcher.push(\"root\", {});\n * matcher.push(\"users\", {});\n * matcher.push(\"user\", { id: \"123\", type: \"admin\" });\n *\n * const expr = new Expression(\"root.users.user\");\n * matcher.matches(expr); // true\n */\nexport default class Matcher {\n  /**\n   * Create a new Matcher.\n   * @param {Object} [options={}]\n   * @param {string} [options.separator='.'] - Default path separator\n   */\n  constructor(options = {}) {\n    this.separator = options.separator || '.';\n    this.path = [];\n    this.siblingStacks = [];\n    // Each path node: { tag, values, position, counter, namespace? }\n    // values only present for current (last) node\n    // Each siblingStacks entry: Map<tagName, count> tracking occurrences at each level\n    this._pathStringCache = null;\n    this._view = new MatcherView(this);\n  }\n\n  /**\n   * Push a new tag onto the path.\n   * @param {string} tagName\n   * @param {Object|null} [attrValues=null]\n   * @param {string|null} [namespace=null]\n   */\n  push(tagName, attrValues = null, namespace = null) {\n    this._pathStringCache = null;\n\n    // Remove values from previous current node (now becoming ancestor)\n    if (this.path.length > 0) {\n      this.path[this.path.length - 1].values = undefined;\n    }\n\n    // Get or create sibling tracking for current level\n    const currentLevel = this.path.length;\n    if (!this.siblingStacks[currentLevel]) {\n      this.siblingStacks[currentLevel] = new Map();\n    }\n\n    const siblings = this.siblingStacks[currentLevel];\n\n    // Create a unique key for sibling tracking that includes namespace\n    const siblingKey = namespace ? `${namespace}:${tagName}` : tagName;\n\n    // Calculate counter (how many times this tag appeared at this level)\n    const counter = siblings.get(siblingKey) || 0;\n\n    // Calculate position (total children at this level so far)\n    let position = 0;\n    for (const count of siblings.values()) {\n      position += count;\n    }\n\n    // Update sibling count for this tag\n    siblings.set(siblingKey, counter + 1);\n\n    // Create new node\n    const node = {\n      tag: tagName,\n      position: position,\n      counter: counter\n    };\n\n    if (namespace !== null && namespace !== undefined) {\n      node.namespace = namespace;\n    }\n\n    if (attrValues !== null && attrValues !== undefined) {\n      node.values = attrValues;\n    }\n\n    this.path.push(node);\n  }\n\n  /**\n   * Pop the last tag from the path.\n   * @returns {Object|undefined} The popped node\n   */\n  pop() {\n    if (this.path.length === 0) return undefined;\n    this._pathStringCache = null;\n\n    const node = this.path.pop();\n\n    if (this.siblingStacks.length > this.path.length + 1) {\n      this.siblingStacks.length = this.path.length + 1;\n    }\n\n    return node;\n  }\n\n  /**\n   * Update current node's attribute values.\n   * Useful when attributes are parsed after push.\n   * @param {Object} attrValues\n   */\n  updateCurrent(attrValues) {\n    if (this.path.length > 0) {\n      const current = this.path[this.path.length - 1];\n      if (attrValues !== null && attrValues !== undefined) {\n        current.values = attrValues;\n      }\n    }\n  }\n\n  /**\n   * Get current tag name.\n   * @returns {string|undefined}\n   */\n  getCurrentTag() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].tag : undefined;\n  }\n\n  /**\n   * Get current namespace.\n   * @returns {string|undefined}\n   */\n  getCurrentNamespace() {\n    return this.path.length > 0 ? this.path[this.path.length - 1].namespace : undefined;\n  }\n\n  /**\n   * Get current node's attribute value.\n   * @param {string} attrName\n   * @returns {*}\n   */\n  getAttrValue(attrName) {\n    if (this.path.length === 0) return undefined;\n    return this.path[this.path.length - 1].values?.[attrName];\n  }\n\n  /**\n   * Check if current node has an attribute.\n   * @param {string} attrName\n   * @returns {boolean}\n   */\n  hasAttr(attrName) {\n    if (this.path.length === 0) return false;\n    const current = this.path[this.path.length - 1];\n    return current.values !== undefined && attrName in current.values;\n  }\n\n  /**\n   * Get current node's sibling position (child index in parent).\n   * @returns {number}\n   */\n  getPosition() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].position ?? 0;\n  }\n\n  /**\n   * Get current node's repeat counter (occurrence count of this tag name).\n   * @returns {number}\n   */\n  getCounter() {\n    if (this.path.length === 0) return -1;\n    return this.path[this.path.length - 1].counter ?? 0;\n  }\n\n  /**\n   * Get current node's sibling index (alias for getPosition).\n   * @returns {number}\n   * @deprecated Use getPosition() or getCounter() instead\n   */\n  getIndex() {\n    return this.getPosition();\n  }\n\n  /**\n   * Get current path depth.\n   * @returns {number}\n   */\n  getDepth() {\n    return this.path.length;\n  }\n\n  /**\n   * Get path as string.\n   * @param {string} [separator] - Optional separator (uses default if not provided)\n   * @param {boolean} [includeNamespace=true]\n   * @returns {string}\n   */\n  toString(separator, includeNamespace = true) {\n    const sep = separator || this.separator;\n    const isDefault = (sep === this.separator && includeNamespace === true);\n\n    if (isDefault) {\n      if (this._pathStringCache !== null) {\n        return this._pathStringCache;\n      }\n      const result = this.path.map(n =>\n        (n.namespace) ? `${n.namespace}:${n.tag}` : n.tag\n      ).join(sep);\n      this._pathStringCache = result;\n      return result;\n    }\n\n    return this.path.map(n =>\n      (includeNamespace && n.namespace) ? `${n.namespace}:${n.tag}` : n.tag\n    ).join(sep);\n  }\n\n  /**\n   * Get path as array of tag names.\n   * @returns {string[]}\n   */\n  toArray() {\n    return this.path.map(n => n.tag);\n  }\n\n  /**\n   * Reset the path to empty.\n   */\n  reset() {\n    this._pathStringCache = null;\n    this.path = [];\n    this.siblingStacks = [];\n  }\n\n  /**\n   * Match current path against an Expression.\n   * @param {Expression} expression\n   * @returns {boolean}\n   */\n  matches(expression) {\n    const segments = expression.segments;\n\n    if (segments.length === 0) {\n      return false;\n    }\n\n    if (expression.hasDeepWildcard()) {\n      return this._matchWithDeepWildcard(segments);\n    }\n\n    return this._matchSimple(segments);\n  }\n\n  /**\n   * @private\n   */\n  _matchSimple(segments) {\n    if (this.path.length !== segments.length) {\n      return false;\n    }\n\n    for (let i = 0; i < segments.length; i++) {\n      if (!this._matchSegment(segments[i], this.path[i], i === this.path.length - 1)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * @private\n   */\n  _matchWithDeepWildcard(segments) {\n    let pathIdx = this.path.length - 1;\n    let segIdx = segments.length - 1;\n\n    while (segIdx >= 0 && pathIdx >= 0) {\n      const segment = segments[segIdx];\n\n      if (segment.type === 'deep-wildcard') {\n        segIdx--;\n\n        if (segIdx < 0) {\n          return true;\n        }\n\n        const nextSeg = segments[segIdx];\n        let found = false;\n\n        for (let i = pathIdx; i >= 0; i--) {\n          if (this._matchSegment(nextSeg, this.path[i], i === this.path.length - 1)) {\n            pathIdx = i - 1;\n            segIdx--;\n            found = true;\n            break;\n          }\n        }\n\n        if (!found) {\n          return false;\n        }\n      } else {\n        if (!this._matchSegment(segment, this.path[pathIdx], pathIdx === this.path.length - 1)) {\n          return false;\n        }\n        pathIdx--;\n        segIdx--;\n      }\n    }\n\n    return segIdx < 0;\n  }\n\n  /**\n   * @private\n   */\n  _matchSegment(segment, node, isCurrentNode) {\n    if (segment.tag !== '*' && segment.tag !== node.tag) {\n      return false;\n    }\n\n    if (segment.namespace !== undefined) {\n      if (segment.namespace !== '*' && segment.namespace !== node.namespace) {\n        return false;\n      }\n    }\n\n    if (segment.attrName !== undefined) {\n      if (!isCurrentNode) {\n        return false;\n      }\n\n      if (!node.values || !(segment.attrName in node.values)) {\n        return false;\n      }\n\n      if (segment.attrValue !== undefined) {\n        if (String(node.values[segment.attrName]) !== String(segment.attrValue)) {\n          return false;\n        }\n      }\n    }\n\n    if (segment.position !== undefined) {\n      if (!isCurrentNode) {\n        return false;\n      }\n\n      const counter = node.counter ?? 0;\n\n      if (segment.position === 'first' && counter !== 0) {\n        return false;\n      } else if (segment.position === 'odd' && counter % 2 !== 1) {\n        return false;\n      } else if (segment.position === 'even' && counter % 2 !== 0) {\n        return false;\n      } else if (segment.position === 'nth' && counter !== segment.positionValue) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Match any expression in the given set against the current path.\n   * @param {ExpressionSet} exprSet\n   * @returns {boolean}\n   */\n  matchesAny(exprSet) {\n    return exprSet.matchesAny(this);\n  }\n\n  /**\n   * Create a snapshot of current state.\n   * @returns {Object}\n   */\n  snapshot() {\n    return {\n      path: this.path.map(node => ({ ...node })),\n      siblingStacks: this.siblingStacks.map(map => new Map(map))\n    };\n  }\n\n  /**\n   * Restore state from snapshot.\n   * @param {Object} snapshot\n   */\n  restore(snapshot) {\n    this._pathStringCache = null;\n    this.path = snapshot.path.map(node => ({ ...node }));\n    this.siblingStacks = snapshot.siblingStacks.map(map => new Map(map));\n  }\n\n  /**\n   * Return the read-only {@link MatcherView} for this matcher.\n   *\n   * The same instance is returned on every call — no allocation occurs.\n   * It always reflects the current parser state and is safe to pass to\n   * user callbacks without risk of accidental mutation.\n   *\n   * @returns {MatcherView}\n   *\n   * @example\n   * const view = matcher.readOnly();\n   * // pass view to callbacks — it stays in sync automatically\n   * view.matches(expr);       // ✓\n   * view.getCurrentTag();     // ✓\n   * // view.push(...)         // ✗ method does not exist — caught by TypeScript\n   */\n  readOnly() {\n    return this._view;\n  }\n}","\n\nexport function safeComment(val) {\n  return String(val)\n    .replace(/--/g, '- -')   // -- is illegal anywhere in comment content\n    .replace(/--/g, '- -')   // handle the scenario when 2 consiucative dashes appears \n    .replace(/-$/, '- ');    // trailing - would form -- with the closing -->\n}\n\nexport function safeCdata(val) {\n  return String(val).replace(/\\]\\]>/g, ']]]]><![CDATA[>')\n}\n\nexport function escapeAttribute(val) {\n  return String(val).replace(/\"/g, '&quot;').replace(/'/g, '&apos;')\n}","/**\n * xml-naming\n * Validates XML Name productions as defined in the XML 1.0 and 1.1 specifications.\n * Covers: Name, NCName, QName, NMToken, NMTokens\n *\n * XML 1.0 spec: https://www.w3.org/TR/xml/#NT-Name\n * XML 1.1 spec: https://www.w3.org/TR/xml11/#NT-NameStartChar\n * XML NS spec:  https://www.w3.org/TR/xml-names/#NT-NCName\n */\n\n// ---------------------------------------------------------------------------\n// Character class strings — XML 1.0\n//\n// NameStartChar ::= \":\" | [A-Z] | \"_\" | [a-z]\n//   | [#xC0-#xD6]   | [#xD8-#xF6]   | [#xF8-#x2FF]\n//   | [#x370-#x37D] | [#x37F-#x1FFF]    <- split to exclude #x0487\n//   | [#x200C-#x200D]\n//   | [#x2070-#x218F] | [#x2C00-#x2FEF]\n//   | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD]\n//\n// NameChar ::= NameStartChar | \"-\" | \".\" | [0-9]\n//   | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]\n//\n// Note: \\u0487 (Combining Cyrillic Millions Sign) was added in Unicode 4.0,\n// after XML 1.0 was defined against Unicode 2.0. It falls inside the range\n// \\u037F-\\u1FFF but must be excluded. We split that range into\n// \\u037F-\\u0486 and \\u0488-\\u1FFF to exclude it explicitly.\n// ---------------------------------------------------------------------------\n\nconst nameStartChar10 =\n  ':A-Za-z_' +\n  '\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF' +\n  '\\u0370-\\u037D' +\n  '\\u037F-\\u0486\\u0488-\\u1FFF' +  // split to exclude \\u0487\n  '\\u200C-\\u200D' +\n  '\\u2070-\\u218F' +\n  '\\u2C00-\\u2FEF' +\n  '\\u3001-\\uD7FF' +\n  '\\uF900-\\uFDCF' +\n  '\\uFDF0-\\uFFFD';\n\nconst nameChar10 =\n  nameStartChar10 +\n  '\\\\-\\\\.\\\\d' +\n  '\\u00B7' +\n  '\\u0300-\\u036F' +\n  '\\u203F-\\u2040';\n\n// ---------------------------------------------------------------------------\n// Character class strings — XML 1.1\n//\n// Differences from XML 1.0:\n//\n// NameStartChar:\n//   1.0 has split ranges: \\u00C0-\\u00D6, \\u00D8-\\u00F6, \\u00F8-\\u02FF\n//   1.1 merges them into: \\u00C0-\\u02FF\n//   (\\u00D7 x and \\u00F7 / are division symbols, excluded in both versions)\n//\n//   1.0 tops out at \\uFFFD (BMP only)\n//   1.1 adds \\u{10000}-\\u{EFFFF} (supplementary planes)\n//   These require the /u flag on the RegExp — see buildRegexes below.\n//\n// NameChar:\n//   1.1 adds \\u0487 (Combining Cyrillic Millions Sign, added in Unicode 4.0)\n// ---------------------------------------------------------------------------\n\nconst nameStartChar11 =\n  ':A-Za-z_' +\n  '\\u00C0-\\u02FF' +                    // merged — 1.0 had three split ranges here\n  '\\u0370-\\u037D' +\n  '\\u037F-\\u0486\\u0488-\\u1FFF' +       // split to exclude \\u0487 (combining mark, never a NameStartChar)\n  '\\u200C-\\u200D' +\n  '\\u2070-\\u218F' +\n  '\\u2C00-\\u2FEF' +\n  '\\u3001-\\uD7FF' +\n  '\\uF900-\\uFDCF' +\n  '\\uFDF0-\\uFFFD' +\n  '\\u{10000}-\\u{EFFFF}';     // supplementary planes — REQUIRES /u flag on RegExp\n\nconst nameChar11 =\n  nameStartChar11 +\n  '\\\\-\\\\.\\\\d' +\n  '\\u00B7' +\n  '\\u0300-\\u036F' +\n  '\\u0487' +                 // Combining Cyrillic Millions Sign — valid in 1.1, not 1.0\n  '\\u203F-\\u2040';\n\n// ---------------------------------------------------------------------------\n// Regex builders\n//\n// XML 1.0 regexes: no flags — BMP only, standard JS regex behaviour.\n// XML 1.1 regexes: /u flag — required for \\u{10000}-\\u{EFFFF} to match actual\n//   supplementary code points rather than lone surrogates (which are illegal XML).\n// ---------------------------------------------------------------------------\n\nconst buildRegexes = (startChar, char, flags = '') => {\n  const ncStart = startChar.replace(':', '');\n  const ncChar = char.replace(':', '');\n  const ncNamePat = `[${ncStart}][${ncChar}]*`;\n\n  return {\n    name: new RegExp(`^[${startChar}][${char}]*$`, flags),\n    ncName: new RegExp(`^${ncNamePat}$`, flags),\n    qName: new RegExp(`^${ncNamePat}(?::${ncNamePat})?$`, flags),\n    nmToken: new RegExp(`^[${char}]+$`, flags),\n    nmTokens: new RegExp(`^[${char}]+(?:\\\\s+[${char}]+)*$`, flags),\n  };\n};\n\nconst regexes10 = buildRegexes(nameStartChar10, nameChar10);       // no /u — BMP only\nconst regexes11 = buildRegexes(nameStartChar11, nameChar11, 'u');  // /u — enables \\u{10000}-\\u{EFFFF}\n\nconst getRegexes = (xmlVersion = '1.0') =>\n  xmlVersion === '1.1' ? regexes11 : regexes10;\n\n// ---------------------------------------------------------------------------\n// Boolean validators\n// ---------------------------------------------------------------------------\n\n/**\n * Returns true if the string is a valid XML Name.\n * Colons are allowed anywhere (Name production).\n * Used for: DOCTYPE entity names, notation names, DTD element declarations.\n */\nexport const name = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).name.test(str);\n\n/**\n * Returns true if the string is a valid NCName (Non-Colonized Name).\n * Colons are not permitted.\n * Used for: namespace prefixes, local names, SVG id attributes.\n */\nexport const ncName = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).ncName.test(str);\n\n/**\n * Returns true if the string is a valid QName (Qualified Name).\n * Allows exactly one colon as a prefix separator: prefix:localName.\n * Used for: element and attribute names in namespace-aware XML/SVG.\n */\nexport const qName = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).qName.test(str);\n\n/**\n * Returns true if the string is a valid NMToken.\n * Like Name but no restriction on the first character.\n * Used for: DTD NMTOKEN attribute values.\n */\nexport const nmToken = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).nmToken.test(str);\n\n/**\n * Returns true if the string is a valid NMTokens value.\n * A whitespace-separated list of NMToken values.\n * Used for: DTD NMTOKENS attribute values.\n */\nexport const nmTokens = (str, { xmlVersion = '1.0' } = {}) =>\n  getRegexes(xmlVersion).nmTokens.test(str);\n\n// ---------------------------------------------------------------------------\n// Diagnostic validator\n// ---------------------------------------------------------------------------\n\nconst PRODUCTIONS = ['name', 'ncName', 'qName', 'nmToken', 'nmTokens'];\n\n/**\n * Validates a string against a named production and returns a detailed result.\n *\n * @param {string} str\n * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production\n * @param {{ xmlVersion?: '1.0'|'1.1' }} [opts]\n * @returns {{ valid: boolean, production: string, input: string, reason?: string, position?: number }}\n */\nexport const validate = (str, production, { xmlVersion = '1.0' } = {}) => {\n  if (!PRODUCTIONS.includes(production)) {\n    throw new TypeError(\n      `Unknown production \"${production}\". Must be one of: ${PRODUCTIONS.join(', ')}`\n    );\n  }\n\n  const validators = { name, ncName, qName, nmToken, nmTokens };\n  const isValid = validators[production](str, { xmlVersion });\n\n  if (isValid) return { valid: true, production, input: str };\n\n  let reason = 'Does not match the production rules';\n  let position;\n\n  if (str.length === 0) {\n    reason = 'Input is empty';\n  } else if (production === 'ncName' && str.includes(':')) {\n    position = str.indexOf(':');\n    reason = 'Colon is not allowed in NCName';\n  } else if (production === 'qName' && str.startsWith(':')) {\n    reason = 'QName cannot start with a colon';\n    position = 0;\n  } else if (production === 'qName' && str.endsWith(':')) {\n    reason = 'QName cannot end with a colon';\n    position = str.length - 1;\n  } else if (production === 'qName' && (str.match(/:/g) || []).length > 1) {\n    reason = 'QName can have at most one colon';\n    position = str.lastIndexOf(':');\n  } else if (\n    ['name', 'ncName', 'qName'].includes(production) &&\n    !/^[:A-Za-z_\\u00C0-\\uFFFD]/.test(str[0])\n  ) {\n    reason = `First character \"${str[0]}\" is not a valid NameStartChar`;\n    position = 0;\n  } else {\n    for (let i = 0; i < str.length; i++) {\n      if (!/[\\w\\-\\\\.:\\u00B7\\u00C0-\\uFFFD]/.test(str[i])) {\n        reason = `Character \"${str[i]}\" at position ${i} is not a valid NameChar`;\n        position = i;\n        break;\n      }\n    }\n  }\n\n  return { valid: false, production, input: str, reason, position };\n};\n\n// ---------------------------------------------------------------------------\n// Batch validator\n// ---------------------------------------------------------------------------\n\n/**\n * Validates an array of strings against a named production.\n *\n * @param {string[]} strings\n * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production\n * @param {{ xmlVersion?: '1.0'|'1.1' }} [opts]\n * @returns {Array<{ valid: boolean, production: string, input: string, reason?: string, position?: number }>}\n */\nexport const validateAll = (strings, production, opts = {}) =>\n  strings.map(str => validate(str, production, opts));\n\n// ---------------------------------------------------------------------------\n// Sanitizer\n// ---------------------------------------------------------------------------\n\n/**\n * Transforms an invalid string into the nearest valid XML name for the given production.\n *\n * @param {string} str\n * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production\n * @param {{ replacement?: string }} [opts]\n * @returns {string}\n */\nexport const sanitize = (str, production = 'name', { replacement = '_' } = {}) => {\n  if (!str) return replacement;\n\n  let result = str;\n\n  // Strip colons for NCName\n  if (production === 'ncName') {\n    result = result.replace(/:/g, '');\n  }\n\n  // Replace illegal characters\n  result = result.replace(/[^\\w\\-\\.:\\u00B7\\u00C0-\\uFFFD]/g, replacement);\n\n  // Fix invalid start character for Name / NCName / QName\n  if (production !== 'nmToken' && production !== 'nmTokens') {\n    if (/^[\\-\\.\\d]/.test(result)) {\n      result = replacement + result;\n    }\n  }\n\n  return result || replacement;\n};","import { Expression, Matcher } from 'path-expression-matcher';\nimport { safeComment, safeCdata, escapeAttribute } from \"./util.js\";\nimport { qName } from 'xml-naming';\n\nconst EOL = \"\\n\";\n\n/**\n * Detect XML version from the first element of the ordered array input.\n * The first element must be a ?xml processing instruction with a version attribute.\n * Returns '1.0' if not found.\n *\n * @param {array}  jArray\n * @param {object} options\n */\nfunction detectXmlVersionFromArray(jArray, options) {\n    if (!Array.isArray(jArray) || jArray.length === 0) return '1.0';\n    const first = jArray[0];\n    const firstKey = propName(first);\n    if (firstKey === '?xml') {\n        const attrs = first[':@'];\n        if (attrs) {\n            const versionKey = options.attributeNamePrefix + 'version';\n            if (attrs[versionKey]) return attrs[versionKey];\n        }\n    }\n    return '1.0';\n}\n\n/**\n * Resolve a tag or attribute name through sanitizeName if configured.\n * Validation via xml-naming's qName is performed first; the sanitizeName\n * callback is invoked only when the name is invalid. If sanitizeName is\n * false (default), no validation occurs and the name is used as-is.\n *\n * @param {string}  name        - raw name from the JS object\n * @param {boolean} isAttribute - true when resolving an attribute name\n * @param {object}  options\n * @param {Matcher} matcher     - current matcher state (readonly from callback perspective)\n * @param {string}  xmlVersion  - '1.0' or '1.1', forwarded to xml-naming\n */\nfunction resolveTagName(name, isAttribute, options, matcher, xmlVersion) {\n    if (!options.sanitizeName) return name;\n    if (qName(name, { xmlVersion })) return name;\n    return options.sanitizeName(name, { isAttribute, matcher: matcher.readOnly() });\n}\n\n/**\n * @param {array} jArray\n * @param {any} options\n * @returns\n */\nexport default function toXml(jArray, options) {\n    let indentation = \"\";\n    if (options.format) {\n        indentation = EOL;\n    }\n\n    // Pre-compile stopNode expressions for pattern matching\n    const stopNodeExpressions = [];\n    if (options.stopNodes && Array.isArray(options.stopNodes)) {\n        for (let i = 0; i < options.stopNodes.length; i++) {\n            const node = options.stopNodes[i];\n            if (typeof node === 'string') {\n                stopNodeExpressions.push(new Expression(node));\n            } else if (node instanceof Expression) {\n                stopNodeExpressions.push(node);\n            }\n        }\n    }\n\n    // Detect XML version for use in name validation\n    const xmlVersion = detectXmlVersionFromArray(jArray, options);\n\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n\n    return arrToStr(jArray, options, indentation, matcher, stopNodeExpressions, xmlVersion);\n}\n\nfunction arrToStr(arr, options, indentation, matcher, stopNodeExpressions, xmlVersion) {\n    let xmlStr = \"\";\n    let isPreviousElementTag = false;\n\n    if (options.maxNestedTags && matcher.getDepth() > options.maxNestedTags) {\n        throw new Error(\"Maximum nested tags exceeded\");\n    }\n\n    if (!Array.isArray(arr)) {\n        // Non-array values (e.g. string tag values) should be treated as text content\n        if (arr !== undefined && arr !== null) {\n            let text = arr.toString();\n            text = replaceEntitiesValue(text, options);\n            return text;\n        }\n        return \"\";\n    }\n\n    for (let i = 0; i < arr.length; i++) {\n        const tagObj = arr[i];\n        const rawTagName = propName(tagObj);\n        if (rawTagName === undefined) continue;\n\n        // Special names are exempt from sanitizeName: internal conventions and PI tags\n        // are not user-supplied XML element names.\n        const isSpecialName = rawTagName === options.textNodeName\n            || rawTagName === options.cdataPropName\n            || rawTagName === options.commentPropName\n            || rawTagName[0] === '?';\n\n        // Resolve tag name (may transform it; may throw for invalid names)\n        const tagName = isSpecialName\n            ? rawTagName\n            : resolveTagName(rawTagName, false, options, matcher, xmlVersion);\n\n        // Extract attributes from \":@\" property\n        const attrValues = extractAttributeValues(tagObj[\":@\"], options);\n\n        // Push resolved tag to matcher WITH attributes\n        matcher.push(tagName, attrValues);\n\n        // Check if this is a stop node using Expression matching\n        const isStopNode = checkStopNode(matcher, stopNodeExpressions);\n\n        if (tagName === options.textNodeName) {\n            let tagText = tagObj[rawTagName];\n            if (!isStopNode) {\n                tagText = options.tagValueProcessor(tagName, tagText);\n                tagText = replaceEntitiesValue(tagText, options);\n            }\n            if (isPreviousElementTag) {\n                xmlStr += indentation;\n            }\n            xmlStr += tagText;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.cdataPropName) {\n            if (isPreviousElementTag) {\n                xmlStr += indentation;\n            }\n            const val = tagObj[rawTagName][0][options.textNodeName];\n            const safeVal = safeCdata(val);\n            xmlStr += `<![CDATA[${safeVal}]]>`;\n            isPreviousElementTag = false;\n            matcher.pop();\n            continue;\n        } else if (tagName === options.commentPropName) {\n            const val = tagObj[rawTagName][0][options.textNodeName];\n            const safeVal = safeComment(val);\n            xmlStr += indentation + `<!--${safeVal}-->`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        } else if (tagName[0] === \"?\") {\n            const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode, matcher, xmlVersion);\n            const tempInd = tagName === \"?xml\" ? \"\" : indentation;\n            // Text node content on PI/XML declaration tags is intentionally ignored.\n            // Only attributes are valid on these tags per the XML spec.\n            xmlStr += tempInd + `<${tagName}${attStr}?>`;\n            isPreviousElementTag = true;\n            matcher.pop();\n            continue;\n        }\n\n        let newIdentation = indentation;\n        if (newIdentation !== \"\") {\n            newIdentation += options.indentBy;\n        }\n\n        // Pass isStopNode to attr_to_str so attributes are also not processed for stopNodes\n        const attStr = attr_to_str(tagObj[\":@\"], options, isStopNode, matcher, xmlVersion);\n        const tagStart = indentation + `<${tagName}${attStr}`;\n\n        // If this is a stopNode, get raw content without processing\n        let tagValue;\n        if (isStopNode) {\n            tagValue = getRawContent(tagObj[rawTagName], options);\n        } else {\n            tagValue = arrToStr(tagObj[rawTagName], options, newIdentation, matcher, stopNodeExpressions, xmlVersion);\n        }\n\n        if (options.unpairedTags.indexOf(tagName) !== -1) {\n            if (options.suppressUnpairedNode) xmlStr += tagStart + \">\";\n            else xmlStr += tagStart + \"/>\";\n        } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {\n            xmlStr += tagStart + \"/>\";\n        } else if (tagValue && tagValue.endsWith(\">\")) {\n            xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;\n        } else {\n            xmlStr += tagStart + \">\";\n            if (tagValue && indentation !== \"\" && (tagValue.includes(\"/>\") || tagValue.includes(\"</\"))) {\n                xmlStr += indentation + options.indentBy + tagValue + indentation;\n            } else {\n                xmlStr += tagValue;\n            }\n            xmlStr += `</${tagName}>`;\n        }\n        isPreviousElementTag = true;\n\n        // Pop tag from matcher\n        matcher.pop();\n    }\n\n    return xmlStr;\n}\n\n/**\n * Extract attribute values from the \":@\" object and return as plain object\n * for passing to matcher.push()\n */\nfunction extractAttributeValues(attrMap, options) {\n    if (!attrMap || options.ignoreAttributes) return null;\n\n    const attrValues = {};\n    let hasAttrs = false;\n\n    for (let attr in attrMap) {\n        if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n        // Remove the attribute prefix to get clean attribute name\n        const cleanAttrName = attr.startsWith(options.attributeNamePrefix)\n            ? attr.substr(options.attributeNamePrefix.length)\n            : attr;\n        attrValues[cleanAttrName] = escapeAttribute(attrMap[attr]);\n        hasAttrs = true;\n    }\n\n    return hasAttrs ? attrValues : null;\n}\n\n/**\n * Extract raw content from a stopNode without any processing\n * This preserves the content exactly as-is, including special characters\n */\nfunction getRawContent(arr, options) {\n    if (!Array.isArray(arr)) {\n        // Non-array values return as-is\n        if (arr !== undefined && arr !== null) {\n            return arr.toString();\n        }\n        return \"\";\n    }\n\n    let content = \"\";\n    for (let i = 0; i < arr.length; i++) {\n        const item = arr[i];\n        const tagName = propName(item);\n\n        if (tagName === options.textNodeName) {\n            // Raw text content - NO processing, NO entity replacement\n            content += item[tagName];\n        } else if (tagName === options.cdataPropName) {\n            // CDATA content\n            content += item[tagName][0][options.textNodeName];\n        } else if (tagName === options.commentPropName) {\n            // Comment content\n            content += item[tagName][0][options.textNodeName];\n        } else if (tagName && tagName[0] === \"?\") {\n            // Processing instruction - skip for stopNodes\n            continue;\n        } else if (tagName) {\n            // Nested tags within stopNode — no sanitizeName, content is raw\n            const attStr = attr_to_str_raw(item[\":@\"], options);\n            const nestedContent = getRawContent(item[tagName], options);\n\n            if (!nestedContent || nestedContent.length === 0) {\n                content += `<${tagName}${attStr}/>`;\n            } else {\n                content += `<${tagName}${attStr}>${nestedContent}</${tagName}>`;\n            }\n        }\n    }\n    return content;\n}\n\n/**\n * Build attribute string for stopNodes - NO entity replacement\n */\nfunction attr_to_str_raw(attrMap, options) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n            // For stopNodes, use raw value without processing\n            let attrVal = attrMap[attr];\n            if (attrVal === true && options.suppressBooleanAttributes) {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;\n            } else {\n                attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}=\"${escapeAttribute(attrVal)}\"`;\n            }\n        }\n    }\n    return attrStr;\n}\n\nfunction propName(obj) {\n    const keys = Object.keys(obj);\n    for (let i = 0; i < keys.length; i++) {\n        const key = keys[i];\n        if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n        if (key !== \":@\") return key;\n    }\n}\n\n/**\n * Build attribute string, resolving attribute names through sanitizeName when configured.\n * Accepts matcher so the callback has path context.\n */\nfunction attr_to_str(attrMap, options, isStopNode, matcher, xmlVersion) {\n    let attrStr = \"\";\n    if (attrMap && !options.ignoreAttributes) {\n        for (let attr in attrMap) {\n            if (!Object.prototype.hasOwnProperty.call(attrMap, attr)) continue;\n\n            // Strip prefix to get the clean XML attribute name, then optionally sanitize it\n            const cleanAttrName = attr.substr(options.attributeNamePrefix.length);\n            const resolvedAttrName = isStopNode\n                ? cleanAttrName  // stopNodes are raw — skip sanitizeName for attr names too\n                : resolveTagName(cleanAttrName, true, options, matcher, xmlVersion);\n\n            let attrVal;\n            if (isStopNode) {\n                // For stopNodes, use raw value without any processing\n                attrVal = attrMap[attr];\n            } else {\n                // Normal processing: apply attributeValueProcessor and entity replacement\n                attrVal = options.attributeValueProcessor(attr, attrMap[attr]);\n                attrVal = replaceEntitiesValue(attrVal, options);\n            }\n\n            if (attrVal === true && options.suppressBooleanAttributes) {\n                attrStr += ` ${resolvedAttrName}`;\n            } else {\n                attrStr += ` ${resolvedAttrName}=\"${escapeAttribute(attrVal)}\"`;\n            }\n        }\n    }\n    return attrStr;\n}\n\nfunction checkStopNode(matcher, stopNodeExpressions) {\n    if (!stopNodeExpressions || stopNodeExpressions.length === 0) return false;\n\n    for (let i = 0; i < stopNodeExpressions.length; i++) {\n        if (matcher.matches(stopNodeExpressions[i])) {\n            return true;\n        }\n    }\n    return false;\n}\n\nfunction replaceEntitiesValue(textValue, options) {\n    if (textValue && textValue.length > 0 && options.processEntities) {\n        for (let i = 0; i < options.entities.length; i++) {\n            const entity = options.entities[i];\n            textValue = textValue.replace(entity.regex, entity.val);\n        }\n    }\n    return textValue;\n}","'use strict';\n//parse Empty Node as self closing node\nimport buildFromOrderedJs from './orderedJs2Xml.js';\nimport getIgnoreAttributesFn from \"./ignoreAttributes.js\";\nimport { Expression, Matcher } from 'path-expression-matcher';\nimport { safeComment, safeCdata, escapeAttribute } from './util.js';\nimport { qName } from 'xml-naming';\n\nconst defaultOptions = {\n  attributeNamePrefix: '@_',\n  attributesGroupName: false,\n  textNodeName: '#text',\n  ignoreAttributes: true,\n  cdataPropName: false,\n  format: false,\n  indentBy: '  ',\n  suppressEmptyNode: false,\n  suppressUnpairedNode: true,\n  suppressBooleanAttributes: true,\n  tagValueProcessor: function (key, a) {\n    return a;\n  },\n  attributeValueProcessor: function (attrName, a) {\n    return a;\n  },\n  preserveOrder: false,\n  commentPropName: false,\n  unpairedTags: [],\n  entities: [\n    { regex: new RegExp(\"&\", \"g\"), val: \"&amp;\" },//it must be on top\n    { regex: new RegExp(\">\", \"g\"), val: \"&gt;\" },\n    { regex: new RegExp(\"<\", \"g\"), val: \"&lt;\" },\n    { regex: new RegExp(\"\\'\", \"g\"), val: \"&apos;\" },\n    { regex: new RegExp(\"\\\"\", \"g\"), val: \"&quot;\" }\n  ],\n  processEntities: true,\n  stopNodes: [],\n  // transformTagName: false,\n  // transformAttributeName: false,\n  oneListGroup: false,\n  maxNestedTags: 100,\n  jPath: true,  // When true, callbacks receive string jPath; when false, receive Matcher instance\n  sanitizeName: false  // false = allow all names as-is (default, backward-compatible).\n  // Set to a function (name, { isAttribute, matcher }) => string to\n  // validate/sanitize tag and attribute names. Throw inside the function\n  // to reject an invalid name.\n};\n\nexport default function Builder(options) {\n  this.options = Object.assign({}, defaultOptions, options);\n\n  // Convert old-style stopNodes for backward compatibility\n  // Old syntax: \"*.tag\" meant \"tag anywhere in tree\"\n  // New syntax: \"..tag\" means \"tag anywhere in tree\"\n  if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) {\n    this.options.stopNodes = this.options.stopNodes.map(node => {\n      if (typeof node === 'string' && node.startsWith('*.')) {\n        // Convert old wildcard syntax to deep wildcard\n        return '..' + node.substring(2);\n      }\n      return node;\n    });\n  }\n\n  // Pre-compile stopNode expressions for pattern matching\n  this.stopNodeExpressions = [];\n  if (this.options.stopNodes && Array.isArray(this.options.stopNodes)) {\n    for (let i = 0; i < this.options.stopNodes.length; i++) {\n      const node = this.options.stopNodes[i];\n      if (typeof node === 'string') {\n        this.stopNodeExpressions.push(new Expression(node));\n      } else if (node instanceof Expression) {\n        this.stopNodeExpressions.push(node);\n      }\n    }\n  }\n\n  if (this.options.ignoreAttributes === true || this.options.attributesGroupName) {\n    this.isAttribute = function (/*a*/) {\n      return false;\n    };\n  } else {\n    this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)\n    this.attrPrefixLen = this.options.attributeNamePrefix.length;\n    this.isAttribute = isAttribute;\n  }\n\n  this.processTextOrObjNode = processTextOrObjNode\n\n  if (this.options.format) {\n    this.indentate = indentate;\n    this.tagEndChar = '>\\n';\n    this.newLine = '\\n';\n  } else {\n    this.indentate = function () {\n      return '';\n    };\n    this.tagEndChar = '>';\n    this.newLine = '';\n  }\n}\n\n/**\n * Detect XML version from the ?xml declaration at the root of a plain-object input.\n * Checks both attributesGroupName and flat attribute forms.\n * Returns '1.0' if no declaration is found.\n */\nfunction detectXmlVersionFromObj(jObj, options) {\n  const decl = jObj['?xml'];\n  if (decl && typeof decl === 'object') {\n    // attributesGroupName path e.g. { '$$': { '@_version': '1.1' } }\n    if (options.attributesGroupName && decl[options.attributesGroupName]) {\n      const v = decl[options.attributesGroupName][options.attributeNamePrefix + 'version'];\n      if (v) return v;\n    }\n    // flat attribute path e.g. { '@_version': '1.1' }\n    const v = decl[options.attributeNamePrefix + 'version'];\n    if (v) return v;\n  }\n  return '1.0';\n}\n\n/**\n * Resolve a tag or attribute name through sanitizeName if configured.\n * Validation via xml-naming's qName is performed first; the sanitizeName\n * callback is invoked only when the name is invalid. If sanitizeName is\n * false (default), no validation occurs and the name is used as-is.\n *\n * @param {string}  name        - raw name from the JS object\n * @param {boolean} isAttribute - true when resolving an attribute name\n * @param {object}  options\n * @param {Matcher} matcher     - current matcher state (readonly from callback perspective)\n * @param {string}  xmlVersion  - '1.0' or '1.1', forwarded to xml-naming\n */\nfunction resolveTagName(name, isAttribute, options, matcher, xmlVersion) {\n  if (!options.sanitizeName) return name;\n  if (qName(name, { xmlVersion })) return name;\n  return options.sanitizeName(name, { isAttribute, matcher: matcher.readOnly() });\n}\n\nBuilder.prototype.build = function (jObj) {\n  if (this.options.preserveOrder) {\n    return buildFromOrderedJs(jObj, this.options);\n  } else {\n    if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {\n      jObj = {\n        [this.options.arrayNodeName]: jObj\n      }\n    }\n    // Initialize matcher for path tracking\n    const matcher = new Matcher();\n    const xmlVersion = detectXmlVersionFromObj(jObj, this.options);\n    return this.j2x(jObj, 0, matcher, xmlVersion).val;\n  }\n};\n\nBuilder.prototype.j2x = function (jObj, level, matcher, xmlVersion) {\n  let attrStr = '';\n  let val = '';\n  if (this.options.maxNestedTags && matcher.getDepth() >= this.options.maxNestedTags) {\n    throw new Error(\"Maximum nested tags exceeded\");\n  }\n  // Get jPath based on option: string for backward compatibility, or Matcher for new features\n  const jPath = this.options.jPath ? matcher.toString() : matcher;\n\n  // Check if current node is a stopNode (will be used for attribute encoding)\n  const isCurrentStopNode = this.checkStopNode(matcher);\n\n  for (let key in jObj) {\n    if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;\n\n    // Resolve the key through sanitizeName before any use.\n    // Special keys (textNodeName, cdataPropName, commentPropName, attributeNamePrefix,\n    // attributesGroupName, \"?\" PI tags) are exempt — they are builder-internal conventions,\n    // not user-supplied XML names.\n    const isSpecialKey = key === this.options.textNodeName\n      || key === this.options.cdataPropName\n      || key === this.options.commentPropName\n      || (this.options.attributesGroupName && key === this.options.attributesGroupName)\n      || this.isAttribute(key)\n      || key[0] === '?';\n\n    const resolvedKey = isSpecialKey\n      ? key\n      : resolveTagName(key, false, this.options, matcher, xmlVersion);\n\n    if (typeof jObj[key] === 'undefined') {\n      // supress undefined node only if it is not an attribute\n      if (this.isAttribute(key)) {\n        val += '';\n      }\n    } else if (jObj[key] === null) {\n      // null attribute should be ignored by the attribute list, but should not cause the tag closing\n      if (this.isAttribute(key)) {\n        val += '';\n      } else if (resolvedKey === this.options.cdataPropName || resolvedKey === this.options.commentPropName) {\n        val += '';\n      } else if (resolvedKey[0] === '?') {\n        val += this.indentate(level) + '<' + resolvedKey + '?' + this.tagEndChar;\n      } else {\n        val += this.indentate(level) + '<' + resolvedKey + '/' + this.tagEndChar;\n      }\n    } else if (jObj[key] instanceof Date) {\n      val += this.buildTextValNode(jObj[key], resolvedKey, '', level, matcher);\n    } else if (typeof jObj[key] !== 'object') {\n      //premitive type\n      const attr = this.isAttribute(key);\n      if (attr && !this.ignoreAttributesFn(attr, jPath)) {\n        // Resolve the attribute name through sanitizeName\n        const resolvedAttr = resolveTagName(attr, true, this.options, matcher, xmlVersion);\n        attrStr += this.buildAttrPairStr(resolvedAttr, '' + jObj[key], isCurrentStopNode);\n      } else if (!attr) {\n        //tag value\n        if (key === this.options.textNodeName) {\n          let newval = this.options.tagValueProcessor(key, '' + jObj[key]);\n          val += this.replaceEntitiesValue(newval);\n        } else {\n          // Check if this is a stopNode before building\n          matcher.push(resolvedKey);\n          const isStopNode = this.checkStopNode(matcher);\n          matcher.pop();\n\n          if (isStopNode) {\n            // Build as raw content without encoding\n            const textValue = '' + jObj[key];\n            if (textValue === '') {\n              val += this.indentate(level) + '<' + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;\n            } else {\n              val += this.indentate(level) + '<' + resolvedKey + '>' + textValue + '</' + resolvedKey + this.tagEndChar;\n            }\n          } else {\n            val += this.buildTextValNode(jObj[key], resolvedKey, '', level, matcher);\n          }\n        }\n      }\n    } else if (Array.isArray(jObj[key])) {\n      //repeated nodes\n      const arrLen = jObj[key].length;\n      let listTagVal = \"\";\n      let listTagAttr = \"\";\n      for (let j = 0; j < arrLen; j++) {\n        const item = jObj[key][j];\n        if (typeof item === 'undefined') {\n          // supress undefined node\n        } else if (item === null) {\n          if (resolvedKey[0] === \"?\") val += this.indentate(level) + '<' + resolvedKey + '?' + this.tagEndChar;\n          else val += this.indentate(level) + '<' + resolvedKey + '/' + this.tagEndChar;\n        } else if (typeof item === 'object') {\n          if (this.options.oneListGroup) {\n            // Push tag to matcher before recursive call\n            matcher.push(resolvedKey);\n            const result = this.j2x(item, level + 1, matcher, xmlVersion);\n            // Pop tag from matcher after recursive call\n            matcher.pop();\n\n            listTagVal += result.val;\n            if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {\n              listTagAttr += result.attrStr\n            }\n          } else {\n            listTagVal += this.processTextOrObjNode(item, resolvedKey, level, matcher, xmlVersion)\n          }\n        } else {\n          if (this.options.oneListGroup) {\n            let textValue = this.options.tagValueProcessor(resolvedKey, item);\n            textValue = this.replaceEntitiesValue(textValue);\n            listTagVal += textValue;\n          } else {\n            // Check if this is a stopNode before building\n            matcher.push(resolvedKey);\n            const isStopNode = this.checkStopNode(matcher);\n            matcher.pop();\n\n            if (isStopNode) {\n              // Build as raw content without encoding\n              const textValue = '' + item;\n              if (textValue === '') {\n                listTagVal += this.indentate(level) + '<' + resolvedKey + this.closeTag(resolvedKey) + this.tagEndChar;\n              } else {\n                listTagVal += this.indentate(level) + '<' + resolvedKey + '>' + textValue + '</' + resolvedKey + this.tagEndChar;\n              }\n            } else {\n              listTagVal += this.buildTextValNode(item, resolvedKey, '', level, matcher);\n            }\n          }\n        }\n      }\n      if (this.options.oneListGroup) {\n        listTagVal = this.buildObjectNode(listTagVal, resolvedKey, listTagAttr, level);\n      }\n      val += listTagVal;\n    } else {\n      //nested node\n      if (this.options.attributesGroupName && key === this.options.attributesGroupName) {\n        const Ks = Object.keys(jObj[key]);\n        const L = Ks.length;\n        for (let j = 0; j < L; j++) {\n          // Resolve attribute names inside attributesGroupName\n          const resolvedAttr = resolveTagName(Ks[j], true, this.options, matcher, xmlVersion);\n          attrStr += this.buildAttrPairStr(resolvedAttr, '' + jObj[key][Ks[j]], isCurrentStopNode);\n        }\n      } else {\n        val += this.processTextOrObjNode(jObj[key], resolvedKey, level, matcher, xmlVersion)\n      }\n    }\n  }\n  return { attrStr: attrStr, val: val };\n};\n\nBuilder.prototype.buildAttrPairStr = function (attrName, val, isStopNode) {\n  if (!isStopNode) {\n    val = this.options.attributeValueProcessor(attrName, '' + val);\n    val = this.replaceEntitiesValue(val);\n  }\n  if (this.options.suppressBooleanAttributes && val === \"true\") {\n    return ' ' + attrName;\n  } else return ' ' + attrName + '=\"' + escapeAttribute(val) + '\"';\n}\n\nfunction processTextOrObjNode(object, key, level, matcher, xmlVersion) {\n  // Extract attributes to pass to matcher\n  const attrValues = this.extractAttributes(object);\n\n  // Push tag to matcher before recursion WITH attributes\n  matcher.push(key, attrValues);\n\n  // Check if this entire node is a stopNode\n  const isStopNode = this.checkStopNode(matcher);\n\n  if (isStopNode) {\n    // For stopNodes, build raw content without entity encoding\n    const rawContent = this.buildRawContent(object);\n    const attrStr = this.buildAttributesForStopNode(object);\n    matcher.pop();\n    return this.buildObjectNode(rawContent, key, attrStr, level);\n  }\n\n  const result = this.j2x(object, level + 1, matcher, xmlVersion);\n  // Pop tag from matcher after recursion\n  matcher.pop();\n\n  // PI/XML-declaration tags must never emit text content — route through\n  // buildTextValNode which correctly ignores the text node for \"?\" tags.\n  if (key[0] === '?') {\n    return this.buildTextValNode('', key, result.attrStr, level, matcher);\n  } else if (object[this.options.textNodeName] !== undefined && Object.keys(object).length === 1) {\n    return this.buildTextValNode(object[this.options.textNodeName], key, result.attrStr, level, matcher);\n  } else {\n    return this.buildObjectNode(result.val, key, result.attrStr, level);\n  }\n}\n\n// Helper method to extract attributes from an object\nBuilder.prototype.extractAttributes = function (obj) {\n  if (!obj || typeof obj !== 'object') return null;\n\n  const attrValues = {};\n  let hasAttrs = false;\n\n  // Check for attributesGroupName (when attributes are grouped)\n  if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {\n    const attrGroup = obj[this.options.attributesGroupName];\n    for (let attrKey in attrGroup) {\n      if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;\n      // Remove attribute prefix if present\n      const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix)\n        ? attrKey.substring(this.options.attributeNamePrefix.length)\n        : attrKey;\n      attrValues[cleanKey] = escapeAttribute(attrGroup[attrKey]);\n      hasAttrs = true;\n    }\n  } else {\n    // Look for individual attributes (prefixed with attributeNamePrefix)\n    for (let key in obj) {\n      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n      const attr = this.isAttribute(key);\n      if (attr) {\n        attrValues[attr] = escapeAttribute(obj[key]);\n        hasAttrs = true;\n      }\n    }\n  }\n\n  return hasAttrs ? attrValues : null;\n};\n\n// Build raw content for stopNode without entity encoding\nBuilder.prototype.buildRawContent = function (obj) {\n  if (typeof obj === 'string') {\n    return obj; // Already a string, return as-is\n  }\n\n  if (typeof obj !== 'object' || obj === null) {\n    return String(obj);\n  }\n\n  // Check if this is a stopNode data from parser: { \"#text\": \"raw xml\", \"@_attr\": \"val\" }\n  if (obj[this.options.textNodeName] !== undefined) {\n    return obj[this.options.textNodeName]; // Return raw text without encoding\n  }\n\n  // Build raw XML from nested structure\n  let content = '';\n\n  for (let key in obj) {\n    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n\n    // Skip attributes\n    if (this.isAttribute(key)) continue;\n    if (this.options.attributesGroupName && key === this.options.attributesGroupName) continue;\n\n    const value = obj[key];\n\n    if (key === this.options.textNodeName) {\n      content += value; // Raw text\n    } else if (Array.isArray(value)) {\n      // Array of same tag\n      for (let item of value) {\n        if (typeof item === 'string' || typeof item === 'number') {\n          content += `<${key}>${item}</${key}>`;\n        } else if (typeof item === 'object' && item !== null) {\n          const nestedContent = this.buildRawContent(item);\n          const nestedAttrs = this.buildAttributesForStopNode(item);\n          if (nestedContent === '') {\n            content += `<${key}${nestedAttrs}/>`;\n          } else {\n            content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;\n          }\n        }\n      }\n    } else if (typeof value === 'object' && value !== null) {\n      // Nested object\n      const nestedContent = this.buildRawContent(value);\n      const nestedAttrs = this.buildAttributesForStopNode(value);\n      if (nestedContent === '') {\n        content += `<${key}${nestedAttrs}/>`;\n      } else {\n        content += `<${key}${nestedAttrs}>${nestedContent}</${key}>`;\n      }\n    } else {\n      // Primitive value\n      content += `<${key}>${value}</${key}>`;\n    }\n  }\n\n  return content;\n};\n\n// Build attribute string for stopNode (no entity encoding)\nBuilder.prototype.buildAttributesForStopNode = function (obj) {\n  if (!obj || typeof obj !== 'object') return '';\n\n  let attrStr = '';\n\n  // Check for attributesGroupName (when attributes are grouped)\n  if (this.options.attributesGroupName && obj[this.options.attributesGroupName]) {\n    const attrGroup = obj[this.options.attributesGroupName];\n    for (let attrKey in attrGroup) {\n      if (!Object.prototype.hasOwnProperty.call(attrGroup, attrKey)) continue;\n      const cleanKey = attrKey.startsWith(this.options.attributeNamePrefix)\n        ? attrKey.substring(this.options.attributeNamePrefix.length)\n        : attrKey;\n      const val = attrGroup[attrKey];\n      if (val === true && this.options.suppressBooleanAttributes) {\n        attrStr += ' ' + cleanKey;\n      } else {\n        attrStr += ' ' + cleanKey + '=\"' + val + '\"'; // No encoding for stopNode\n      }\n    }\n  } else {\n    // Look for individual attributes\n    for (let key in obj) {\n      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;\n      const attr = this.isAttribute(key);\n      if (attr) {\n        const val = obj[key];\n        if (val === true && this.options.suppressBooleanAttributes) {\n          attrStr += ' ' + attr;\n        } else {\n          attrStr += ' ' + attr + '=\"' + val + '\"'; // No encoding for stopNode\n        }\n      }\n    }\n  }\n\n  return attrStr;\n};\n\nBuilder.prototype.buildObjectNode = function (val, key, attrStr, level) {\n  if (val === \"\") {\n    if (key[0] === \"?\") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n    else {\n      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;\n    }\n  } else if (key[0] === \"?\") {\n    // PI/XML-declaration tags never have body content — treat them like empty.\n    return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n  } else {\n    let tagEndExp = '</' + key + this.tagEndChar;\n    let piClosingChar = \"\";\n\n    if (key[0] === \"?\") {\n      piClosingChar = \"?\";\n      tagEndExp = \"\";\n    }\n\n    // attrStr is an empty string in case the attribute came as undefined or null\n    if ((attrStr || attrStr === '') && val.indexOf('<') === -1) {\n      return (this.indentate(level) + '<' + key + attrStr + piClosingChar + '>' + val + tagEndExp);\n    } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {\n      return this.indentate(level) + `<!--${val}-->` + this.newLine;\n    } else {\n      return (\n        this.indentate(level) + '<' + key + attrStr + piClosingChar + this.tagEndChar +\n        val +\n        this.indentate(level) + tagEndExp);\n    }\n  }\n}\n\nBuilder.prototype.closeTag = function (key) {\n  let closeTag = \"\";\n  if (this.options.unpairedTags.indexOf(key) !== -1) { //unpaired\n    if (!this.options.suppressUnpairedNode) closeTag = \"/\"\n  } else if (this.options.suppressEmptyNode) { //empty\n    closeTag = \"/\";\n  } else {\n    closeTag = `></${key}`\n  }\n  return closeTag;\n}\n\nBuilder.prototype.checkStopNode = function (matcher) {\n  if (!this.stopNodeExpressions || this.stopNodeExpressions.length === 0) return false;\n\n  for (let i = 0; i < this.stopNodeExpressions.length; i++) {\n    if (matcher.matches(this.stopNodeExpressions[i])) {\n      return true;\n    }\n  }\n  return false;\n}\n\nfunction buildEmptyObjNode(val, key, attrStr, level) {\n  if (val !== '') {\n    return this.buildObjectNode(val, key, attrStr, level);\n  } else {\n    if (key[0] === \"?\") return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n    else {\n      return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;\n    }\n  }\n}\n\nBuilder.prototype.buildTextValNode = function (val, key, attrStr, level, matcher) {\n  if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {\n    const safeVal = safeCdata(val);\n    return this.indentate(level) + `<![CDATA[${safeVal}]]>` + this.newLine;\n  } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {\n    const safeVal = safeComment(val);\n    return this.indentate(level) + `<!--${safeVal}-->` + this.newLine;\n  } else if (key[0] === \"?\") {//PI tag\n    return this.indentate(level) + '<' + key + attrStr + '?' + this.tagEndChar;\n  } else {\n    // Normal processing: apply tagValueProcessor and entity replacement\n    let textValue = this.options.tagValueProcessor(key, val);\n    textValue = this.replaceEntitiesValue(textValue);\n\n    if (textValue === '') {\n      return this.indentate(level) + '<' + key + attrStr + this.closeTag(key) + this.tagEndChar;\n    } else {\n      return this.indentate(level) + '<' + key + attrStr + '>' +\n        textValue +\n        '</' + key + this.tagEndChar;\n    }\n  }\n}\n\nBuilder.prototype.replaceEntitiesValue = function (textValue) {\n  if (textValue && textValue.length > 0 && this.options.processEntities) {\n    for (let i = 0; i < this.options.entities.length; i++) {\n      const entity = this.options.entities[i];\n      textValue = textValue.replace(entity.regex, entity.val);\n    }\n  }\n  return textValue;\n}\n\nfunction indentate(level) {\n  return this.options.indentBy.repeat(level);\n}\n\nfunction isAttribute(name /*, options*/) {\n  if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) {\n    return name.substr(this.attrPrefixLen);\n  } else {\n    return false;\n  }\n}","export default function getIgnoreAttributesFn(ignoreAttributes) {\n    if (typeof ignoreAttributes === 'function') {\n        return ignoreAttributes\n    }\n    if (Array.isArray(ignoreAttributes)) {\n        return (attrName) => {\n            for (const pattern of ignoreAttributes) {\n                if (typeof pattern === 'string' && attrName === pattern) {\n                    return true\n                }\n                if (pattern instanceof RegExp && pattern.test(attrName)) {\n                    return true\n                }\n            }\n        }\n    }\n    return () => false\n}"],"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","Expression","constructor","pattern","options","data","separator","segments","_parse","_hasDeepWildcard","some","seg","type","_hasAttributeCondition","undefined","attrName","_hasPositionSelector","position","i","currentPart","length","trim","push","_parseSegment","part","segment","bracketContent","withoutBrackets","bracketMatch","match","content","slice","namespace","tag","tagAndPosition","includes","nsIndex","indexOf","substring","Error","positionMatch","colonIndex","lastIndexOf","tagPart","posPart","test","eqIndex","attrValue","nthMatch","positionValue","parseInt","hasDeepWildcard","hasAttributeCondition","hasPositionSelector","toString","MatcherView","matcher","_matcher","getCurrentTag","path","getCurrentNamespace","getAttrValue","values","hasAttr","current","getPosition","getCounter","counter","getIndex","getDepth","includeNamespace","toArray","map","n","matches","expression","matchesAny","exprSet","Matcher","siblingStacks","_pathStringCache","_view","tagName","attrValues","currentLevel","Map","siblings","siblingKey","count","set","node","pop","updateCurrent","sep","result","join","reset","_matchWithDeepWildcard","_matchSimple","_matchSegment","pathIdx","segIdx","nextSeg","found","isCurrentNode","String","snapshot","restore","readOnly","safeComment","val","replace","safeCdata","escapeAttribute","nameStartChar10","nameStartChar11","nameChar11","buildRegexes","startChar","char","flags","ncNamePat","name","RegExp","ncName","qName","nmToken","nmTokens","regexes10","regexes11","str","xmlVersion","getRegexes","resolveTagName","isAttribute","sanitizeName","toXml","jArray","indentation","format","stopNodeExpressions","stopNodes","Array","isArray","first","propName","attrs","versionKey","attributeNamePrefix","detectXmlVersionFromArray","arrToStr","arr","xmlStr","isPreviousElementTag","maxNestedTags","text","replaceEntitiesValue","tagObj","rawTagName","textNodeName","cdataPropName","commentPropName","extractAttributeValues","isStopNode","checkStopNode","newIdentation","indentBy","tagStart","attr_to_str","tagValue","getRawContent","unpairedTags","suppressUnpairedNode","suppressEmptyNode","endsWith","tagText","tagValueProcessor","attrMap","ignoreAttributes","hasAttrs","attr","startsWith","substr","item","attStr","attr_to_str_raw","nestedContent","attrStr","attrVal","suppressBooleanAttributes","keys","cleanAttrName","resolvedAttrName","attributeValueProcessor","textValue","processEntities","entities","entity","regex","_createForOfIteratorHelperLoose","r","e","t","iterator","next","bind","a","_arrayLikeToArray","from","_unsupportedIterableToArray","done","TypeError","defaultOptions","attributesGroupName","preserveOrder","oneListGroup","jPath","Builder","assign","ignoreAttributesFn","_step","_iterator","attrPrefixLen","processTextOrObjNode","indentate","tagEndChar","newLine","object","level","extractAttributes","rawContent","buildRawContent","buildAttributesForStopNode","buildObjectNode","j2x","buildTextValNode","repeat","build","jObj","buildFromOrderedJs","_jObj","arrayNodeName","decl","v","detectXmlVersionFromObj","isCurrentStopNode","resolvedKey","Date","resolvedAttr","buildAttrPairStr","newval","closeTag","arrLen","listTagVal","listTagAttr","j","Ks","L","attrGroup","attrKey","nestedAttrs","cleanKey","tagEndExp","piClosingChar","safeVal"],"sourceRoot":""}

package/node_modules/fast-xml-builder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-xml-builder",
-  "version": "1.1.7",
+  "version": "1.2.0",
   "description": "Build XML from JSON without C/C++ based libraries",
   "main": "./lib/fxb.cjs",
   "type": "module",
@@ -75,6 +75,7 @@
     }
   ],
   "dependencies": {
-    "path-expression-matcher": "^1.1.3"
+    "path-expression-matcher": "^1.5.0",
+    "xml-naming": "^0.1.0"
   }
 }

package/node_modules/fast-xml-builder/src/fxb.d.ts

@@ -1,8 +1,50 @@
-// import { Expression } from 'path-expression-matcher';
+// import { Expression, Matcher } from 'path-expression-matcher';
 
-type Matcher = unknown;
+//type Matcher = unknown;
 type Expression = unknown;
 
+/**
+ * A lightweight, live read-only view of a Matcher instance.
+ *
+ * Returned by `Matcher.readOnly()`. The same instance is reused across every
+ * callback invocation — no allocation overhead per call. Reads directly from
+ * the parent Matcher's internal state so it always reflects the current parser
+ * position with no copying or freezing.
+ */
+export class MatcherView {
+  readonly separator: string;
+
+  /** Check if current path matches an Expression. */
+  matches(expression: Expression): boolean;
+
+  /** Get current tag name, or `undefined` if path is empty. */
+  getCurrentTag(): string | undefined;
+
+  /** Get current namespace, or `undefined` if not present. */
+  getCurrentNamespace(): string | undefined;
+
+  /** Get attribute value of the current node. */
+  getAttrValue(attrName: string): any;
+
+  /** Check if the current node has a given attribute. */
+  hasAttr(attrName: string): boolean;
+
+  /** Sibling position of the current node (child index in parent). */
+  getPosition(): number;
+
+  /** Occurrence counter of the current tag name at this level. */
+  getCounter(): number;
+
+  /** Number of nodes in the current path. */
+  getDepth(): number;
+
+  /** Current path as a string (e.g. `"root.users.user"`). */
+  toString(separator?: string, includeNamespace?: boolean): string;
+
+  /** Current path as an array of tag names. */
+  toArray(): string[];
+}
+
 export type XmlBuilderOptions = {
   /**
    * Give a prefix to the attribute name in the resulting JS object
@@ -164,6 +206,53 @@ export type XmlBuilderOptions = {
    * Defaults to `100`
    */
   maxNestedTags?: number;
+
+  /**
+   * Validate or sanitize tag and attribute names before they are written to XML output.
+   *
+   * The context object provides:
+   * - `isAttribute` — `true` when the name being resolved is an attribute name,
+   *   `false` when it is a tag name.
+   * - `matcher` — the current path matcher (readonly). Can be used to inspect the
+   *   current element path, e.g. via `.toString()` or `.getDepth()`.
+   *
+   * Return the (possibly transformed) name to use in the output.
+   * Throw an error inside the function to reject an invalid name entirely.
+   *
+   * When set to `false` (default) all names are written as-is, preserving
+   * backward-compatible behaviour.
+   *
+   * @example
+   * // Auto-fix invalid names using xml-naming
+   * import { sanitize } from 'xml-naming';
+   * { sanitizeName: (name) => sanitize(name, 'qName') }
+   *
+   * @example
+   * // Reject invalid names
+   * import { qName } from 'xml-naming';
+   * { sanitizeName: (name) => { if (!qName(name)) throw new Error(`Invalid XML name: "${name}"`); return name; } }
+   *
+   * Defaults to `false`
+   */
+  sanitizeName?: false | ((name: string, context: SanitizeNameContext) => string);
+};
+
+/**
+ * Context object passed as the second argument to {@link XmlBuilderOptions.sanitizeName}.
+ */
+export type SanitizeNameContext = {
+  /**
+   * `true` when the name being resolved is an XML attribute name;
+   * `false` when it is an XML element (tag) name.
+   */
+  isAttribute: boolean;
+
+  /**
+   * The current path matcher at the point where the name is being resolved.
+   * Readonly from the callback's perspective — do not call mutating methods.
+   * Use `.toString()` to get the current jPath string, `.getDepth()` for nesting depth.
+   */
+  matcher: MatcherView;
 };
 
 export interface XMLBuilder {
@@ -177,4 +266,5 @@ export interface XMLBuilderConstructor {
 
 declare const Builder: XMLBuilderConstructor;
 
-export default Builder;
+export { Builder };
+export default Builder;