@nodable/flexible-xml-parser 1.4.0 → 1.6.0

package/src/InputSource/BufferSource.js

@@ -95,7 +95,14 @@ export default class BufferSource {
   // ─── Core read interface ──────────────────────────────────────────────────
 
   readCh() {
-    return String.fromCharCode(this.buffer[this.startIndex++]);
+    const code = this.buffer[this.startIndex++];
+    if (code === 10) { // '\n'
+      this.line++;
+      this.cols = 0;
+    } else {
+      this.cols++;
+    }
+    return String.fromCharCode(code);
   }
 
   readChAt(index) {
@@ -107,6 +114,34 @@ export default class BufferSource {
     return this.buffer.slice(from, from + n).toString();
   }
 
+  /**
+   * Scan buffer[this.startIndex, end) for byte code 10 ('\n') and advance
+   * line/cols to match, mirroring readCh()'s per-byte logic. Does NOT touch
+   * startIndex — callers set that themselves afterwards (their "end" is not
+   * always startIndex + n; readUptoCloseTag's consumed span includes the
+   * matched stop string).
+   *
+   * Shared by updateBufferBoundary() and the readUpto*() family so every path
+   * that advances the cursor in bulk keeps line/col accurate, not just the
+   * single-byte readCh() path.
+   *
+   * @param {number} end — exclusive end of the span being skipped
+   */
+  _advanceLineCol(end) {
+    let lastNewlineIdx = -1;
+    for (let i = this.startIndex; i < end; i++) {
+      if (this.buffer[i] === 10) {
+        this.line++;
+        lastNewlineIdx = i;
+      }
+    }
+    if (lastNewlineIdx >= 0) {
+      this.cols = end - lastNewlineIdx - 1;
+    } else {
+      this.cols += end - this.startIndex;
+    }
+  }
+
   readUpto(stopStr) {
     const inputLength = this.buffer.length;
     const stopLength = stopStr.length;
@@ -119,6 +154,7 @@ export default class BufferSource {
       }
       if (match) {
         const result = this.buffer.slice(this.startIndex, i).toString();
+        this._advanceLineCol(i + stopLength);
         this.startIndex = i + stopLength;
         return result;
       }
@@ -142,6 +178,7 @@ export default class BufferSource {
     for (let i = this.startIndex; i < len; i++) {
       if (buf[i] === stopCode) {
         const result = buf.slice(this.startIndex, i).toString();
+        this._advanceLineCol(i + 1);
         this.startIndex = i + 1;
         return result;
       }
@@ -177,6 +214,7 @@ export default class BufferSource {
       }
       if (state === 2) {
         const result = this.buffer.slice(this.startIndex, tagMatchStart).toString();
+        this._advanceLineCol(i + 1);
         this.startIndex = i + 1;
         return result;
       }
@@ -215,7 +253,9 @@ export default class BufferSource {
    * @param {number} [n=1]
    */
   updateBufferBoundary(n = 1) {
-    this.startIndex += n;
+    const end = this.startIndex + n;
+    this._advanceLineCol(end);
+    this.startIndex = end;
     if (this.autoFlush && this.startIndex >= this.flushThreshold && this._tokenStart < 0) {
       this.flush();
     }

package/src/InputSource/FeedableSource.js

@@ -69,9 +69,15 @@ export default class FeedableSource {
      * _marks[1] — inner mark: set by individual reader functions.
      *             Used only by flush() as the safe trim boundary.
      *
-     * -1 means "not set" for that level.
+     * `null` means "not set" for that level.
+     *
+     * Each entry is { startIndex, line, cols } (or null when unset) — line/cols
+     * are captured alongside startIndex so a rewind can undo readCh()'s
+     * line/col advancement too, not just the buffer offset. Without this,
+     * any token that fails mid-read (UNEXPECTED_END) and gets replayed on
+     * the next feed() double-counts every '\n' it consumed before failing.
      */
-    this._marks = [-1, -1];
+    this._marks = [null, null];
   }
 
   /**
@@ -132,7 +138,7 @@ export default class FeedableSource {
    * @param {0|1} [level=0]
    */
   markTokenStart(level = 0) {
-    this._marks[level] = this.startIndex;
+    this._marks[level] = { startIndex: this.startIndex, line: this.line, cols: this.cols };
   }
 
   /**
@@ -145,11 +151,13 @@ export default class FeedableSource {
    * Called by XMLParser.feed() when a reader throws UNEXPECTED_END.
    */
   rewindToMark() {
-    if (this._marks[0] >= 0) {
-      this.startIndex = this._marks[0];
+    if (this._marks[0] !== null) {
+      this.startIndex = this._marks[0].startIndex;
+      this.line = this._marks[0].line;
+      this.cols = this._marks[0].cols;
     }
-    this._marks[0] = -1;
-    this._marks[1] = -1;
+    this._marks[0] = null;
+    this._marks[1] = null;
   }
 
   /**
@@ -165,8 +173,8 @@ export default class FeedableSource {
    * stale mark only delays flushing — it does not cause correctness issues.
    */
   clearMark() {
-    this._marks[0] = -1;
-    this._marks[1] = -1;
+    this._marks[0] = null;
+    this._marks[1] = null;
   }
 
   /**
@@ -212,6 +220,33 @@ export default class FeedableSource {
    * @returns {string} content before the stop string (stop string is consumed)
    * @throws {ParseError} UNEXPECTED_END when stop string is not found
    */
+  /**
+   * Scan buffer[this.startIndex, end) for '\n' and advance line/cols to match,
+   * mirroring readCh()'s per-char logic. Does NOT touch startIndex — callers
+   * set that themselves afterwards (their "end" is not always startIndex + n;
+   * readUptoCloseTag's consumed span includes the matched stop string).
+   *
+   * Shared by updateBufferBoundary() and the readUpto*() family so every path
+   * that advances the cursor in bulk keeps line/col accurate, not just the
+   * single-character readCh() path.
+   *
+   * @param {number} end — exclusive end of the span being skipped
+   */
+  _advanceLineCol(end) {
+    let lastNewlineIdx = -1;
+    for (let i = this.startIndex; i < end; i++) {
+      if (this.buffer[i] === '\n') {
+        this.line++;
+        lastNewlineIdx = i;
+      }
+    }
+    if (lastNewlineIdx >= 0) {
+      this.cols = end - lastNewlineIdx - 1;
+    } else {
+      this.cols += end - this.startIndex;
+    }
+  }
+
   readUpto(stopStr) {
     const inputLength = this.buffer.length;
     const stopLength = stopStr.length;
@@ -223,6 +258,7 @@ export default class FeedableSource {
       }
       if (match) {
         const result = this.buffer.substring(this.startIndex, i);
+        this._advanceLineCol(i + stopLength);
         this.startIndex = i + stopLength;
         return result;
       }
@@ -245,6 +281,7 @@ export default class FeedableSource {
       throw new ParseError(`Unexpected end of source reading '${stopChar}'`, ErrorCode.UNEXPECTED_END);
     }
     const result = this.buffer.substring(this.startIndex, i);
+    this._advanceLineCol(i + 1);
     this.startIndex = i + 1;
     return result;
   }
@@ -281,6 +318,7 @@ export default class FeedableSource {
       }
       if (state === 2) {
         const result = this.buffer.substring(this.startIndex, tagMatchStart);
+        this._advanceLineCol(i + 1);
         this.startIndex = i + 1;
         return result;
       }
@@ -300,8 +338,10 @@ export default class FeedableSource {
    * @param {number} [n=1]
    */
   updateBufferBoundary(n = 1) {
-    this.startIndex += n;
-    const anyMarkActive = this._marks[0] >= 0 || this._marks[1] >= 0;
+    const end = this.startIndex + n;
+    this._advanceLineCol(end);
+    this.startIndex = end;
+    const anyMarkActive = this._marks[0] !== null || this._marks[1] !== null;
     if (this.autoFlush && this.startIndex >= this.flushThreshold && !anyMarkActive) {
       this.flush();
     }
@@ -322,16 +362,17 @@ export default class FeedableSource {
     // Determine the earliest position that must be kept.
     let origin = this.startIndex;
     for (const m of this._marks) {
-      if (m >= 0 && m < origin) origin = m;
+      if (m !== null && m.startIndex < origin) origin = m.startIndex;
     }
 
     if (origin > 0) {
       this.buffer = this.buffer.substring(origin);
 
-      // Adjust all mark positions by the amount trimmed.
+      // Adjust all mark buffer-offsets by the amount trimmed.
+      // line/cols are not buffer-relative — they stay untouched.
       const marksLen = this._marks.length;
       for (let i = 0; i < marksLen; i++) {
-        if (this._marks[i] >= 0) this._marks[i] -= origin;
+        if (this._marks[i] !== null) this._marks[i].startIndex -= origin;
       }
 
       this.startIndex -= origin;

package/src/InputSource/StringSource.js

@@ -108,7 +108,14 @@ export default class StringSource {
   // ─── Core read interface ──────────────────────────────────────────────────
 
   readCh() {
-    return this.buffer[this.startIndex++];
+    const ch = this.buffer[this.startIndex++];
+    if (ch === '\n') {
+      this.line++;
+      this.cols = 0;
+    } else {
+      this.cols++;
+    }
+    return ch;
   }
 
   readChAt(index) {
@@ -120,6 +127,33 @@ export default class StringSource {
     return this.buffer.substring(from, from + n);
   }
 
+  /**
+   * Scan buffer[this.startIndex, end) for '\n' and advance line/cols to match,
+   * mirroring readCh()'s per-char logic. Does NOT touch startIndex — callers
+   * set that themselves afterwards (their "end" is not always startIndex + n;
+   * readUptoCloseTag's consumed span includes the matched stop string).
+   *
+   * Shared by updateBufferBoundary() and the readUpto*() family so every path
+   * that advances the cursor in bulk keeps line/col accurate, not just the
+   * single-character readCh() path.
+   *
+   * @param {number} end — exclusive end of the span being skipped
+   */
+  _advanceLineCol(end) {
+    let lastNewlineIdx = -1;
+    for (let i = this.startIndex; i < end; i++) {
+      if (this.buffer[i] === '\n') {
+        this.line++;
+        lastNewlineIdx = i;
+      }
+    }
+    if (lastNewlineIdx >= 0) {
+      this.cols = end - lastNewlineIdx - 1;
+    } else {
+      this.cols += end - this.startIndex;
+    }
+  }
+
   readUpto(stopStr) {
     const inputLength = this.buffer.length;
     const stopLength = stopStr.length;
@@ -131,6 +165,7 @@ export default class StringSource {
       }
       if (match) {
         const result = this.buffer.substring(this.startIndex, i);
+        this._advanceLineCol(i + stopLength);
         this.startIndex = i + stopLength;
         return result;
       }
@@ -153,6 +188,7 @@ export default class StringSource {
       throw new ParseError(`Unexpected end of source reading '${stopChar}'`, ErrorCode.UNEXPECTED_END);
     }
     const result = this.buffer.substring(this.startIndex, i);
+    this._advanceLineCol(i + 1);
     this.startIndex = i + 1;
     return result;
   }
@@ -184,6 +220,7 @@ export default class StringSource {
       }
       if (state === 2) {
         const result = this.buffer.substring(this.startIndex, tagMatchStart);
+        this._advanceLineCol(i + 1);
         this.startIndex = i + 1;
         return result;
       }
@@ -211,7 +248,9 @@ export default class StringSource {
    * @param {number} [n=1]
    */
   updateBufferBoundary(n = 1) {
-    this.startIndex += n;
+    const end = this.startIndex + n;
+    this._advanceLineCol(end);
+    this.startIndex = end;
     const anyMarkActive = this._marks[0] >= 0 || this._marks[1] >= 0;
     if (this.autoFlush && this.startIndex >= this.flushThreshold && !anyMarkActive) {
       this.flush();

package/src/StopNodeProcessor.js

@@ -143,7 +143,12 @@ export class StopNodeProcessor {
    * chunk-boundary `UNEXPECTED_END` can be retried seamlessly.
    *
    * @param {object} source  Any source object with the standard read interface.
-   * @returns {string}  Raw content between the opening and closing tags.
+   * @returns {{content: string, end: {index: number, line: number, col: number}}}
+   *   `content` is the raw text between the opening and closing tags.
+   *   `end` is the position immediately after the matched closing tag's '>' —
+   *   mirrors `TagDetail.openEnd` / closeMeta.closeEnd for the opening-tag side,
+   *   letting a caller recover the exact span of `<tag>...</tag>` including
+   *   both delimiters, not just the inner content.
    */
   collect(source) {
     source.markTokenStart(1);
@@ -198,7 +203,7 @@ export class StopNodeProcessor {
             const c = source.readCh();
             if (c === '>') break;
           }
-          return this._finish();
+          return this._finish(source);
         }
       }
 
@@ -253,7 +258,7 @@ export class StopNodeProcessor {
 
         if (closeName === this._tagName) {
           this._depth--;
-          if (this._depth === 0) return this._finish();
+          if (this._depth === 0) return this._finish(source);
         }
         this._content += '</' + closeName + closeSuffix;
         continue;
@@ -322,7 +327,7 @@ export class StopNodeProcessor {
             const c = source.readCh();
             if (c === '>') break;
           }
-          return this._finish();
+          return this._finish(source);
         }
       }
 
@@ -389,7 +394,7 @@ export class StopNodeProcessor {
 
         if (closeName === this._tagName) {
           this._depth--;
-          if (this._depth === 0) return this._finish();
+          if (this._depth === 0) return this._finish(source);
         }
         this._content += '</' + closeName + closeSuffix;
         continue;
@@ -417,16 +422,20 @@ export class StopNodeProcessor {
   // ── Shared finish helper ───────────────────────────────────────────────────
 
   /**
-   * Reset runtime state and return the accumulated content.
-   * Called by every strategy when the closing tag is confirmed.
-   * @returns {string}
+   * Reset runtime state and return the accumulated content plus the end
+   * position (immediately after the matched closing tag's '>').
+   * Called by every strategy when the closing tag is confirmed — always
+   * right after that '>' has just been consumed from `source`.
+   * @param {object} source
+   * @returns {{content: string, end: {index: number, line: number, col: number}}}
    */
-  _finish() {
+  _finish(source) {
     const result = this._content;
+    const end = { index: source.startIndex, line: source.line, col: source.cols };
     this._active = false;
     this._content = '';
     this._depth = 1;
-    return result;
+    return { content: result, end };
   }
 
   // ── Private helpers ────────────────────────────────────────────────────────

package/src/Xml2JsParser.js

@@ -13,15 +13,20 @@ import { name as isName, qName as isQName } from 'xml-naming';
 class TagDetail {
   /**
    * @param {string} name  - Tag name
-   * @param {number} line  - 1-based line number where the opening tag began
-   * @param {number} col   - 1-based column where the opening tag began
-   * @param {number} index - Character offset from document start
+   * @param {number} line  - 1-based line number where the opening tag's '<' began
+   * @param {number} col   - 1-based column where the opening tag's '<' began
+   * @param {number} index - Character offset of '<' from document start
+   * @param {number} [openEnd] - Character offset immediately after the opening
+   *   tag's closing '>' (i.e. end of `<tag attr="x">`). Undefined until the
+   *   opening tag expression has been fully read; set in readOpeningTag().
+   *   For self-closing tags this is the offset after '/>'.
    */
-  constructor(name, line = 0, col = 0, index = 0) {
+  constructor(name, line = 0, col = 0, index = 0, openEnd = undefined) {
     this.name = name;
     this.line = line;
     this.col = col;
     this.index = index;
+    this.openEnd = openEnd;
   }
 }
 
@@ -61,7 +66,12 @@ export default class Xml2JsParser {
     this.tagsStack = [];
     this._stopNodeProcessor = null;
     this._exitIfTriggered = false;
-    this.xmlVersion = '1.0';
+    this.xmlDec = {
+      version: 1.0,
+      lang: null,
+      encoding: null,
+      standalone: "yes"
+    }
 
     if (!this.matcher) {
       this.matcher = new Matcher();
@@ -125,10 +135,20 @@ export default class Xml2JsParser {
       // which never overwrite this position.
       this.source.markTokenStart(0);
 
+      // Position of the next character, captured before it's read. When that
+      // character turns out to be '<', this is exactly the position of '<'
+      // itself — used below as the authoritative tag-start position for both
+      // TagDetail (open tags) and closeMeta (close tags), instead of deriving
+      // it after the fact from source.startIndex once the tag name/attrs have
+      // already been consumed (which points past the tag, not at its start).
+      const preReadPos = { line: this.source.line, col: this.source.cols, index: this.source.startIndex };
+
       const ch = this.source.readCh();
       if (ch === undefined || ch === '') break;
 
       if (ch === '<') {
+        const tagStart = preReadPos;
+
         const nextChar = this.source.readChAt(0);
         if (nextChar === '') throw new ParseError(
           "Unexpected end of source after '<'",
@@ -142,9 +162,9 @@ export default class Xml2JsParser {
           this.readSpecialTag(nextChar);
         } else if (nextChar === '/') {
           this.source.updateBufferBoundary();
-          this.readClosingTag();
+          this.readClosingTag(tagStart);
         } else {
-          this.readOpeningTag();
+          this.readOpeningTag(tagStart);
         }
       } else {
         // ch is already consumed. Peek ahead for more non-'<' chars and grab
@@ -223,8 +243,18 @@ export default class Xml2JsParser {
     this.finalizeXml();
   }
 
-  readClosingTag() {
+  readClosingTag(tagStart) {
     const tagName = this.processTagName(readClosingTagName(this.source));
+    // closeMeta: position of this closing tag's '</' (tagStart, passed in from
+    // parseXml's dispatch) plus the offset right after its '>' (closeEnd) —
+    // mirrors tagDetail.index / tagDetail.openEnd for the opening-tag side.
+    const closeMeta = {
+      name: tagName,
+      line: tagStart.line,
+      col: tagStart.col,
+      index: tagStart.index,
+      closeEnd: this.source.startIndex,
+    };
 
     if (this.isUnpaired(tagName) || this.isStopNode()) {
       throw new ParseError(`Unexpected closing tag '${tagName}'`, ErrorCode.UNEXPECTED_CLOSE_TAG, { line: this.source.line, col: this.source.cols, index: this.source.startIndex });
@@ -246,10 +276,10 @@ export default class Xml2JsParser {
     }
 
     if (!this.currentTagDetail.root) this.addTextNode();
-    this.popTag();
+    this.popTag(closeMeta);
   }
 
-  readOpeningTag() {
+  readOpeningTag(tagStart) {
     const options = this.options;
     this.addTextNode();
 
@@ -263,12 +293,15 @@ export default class Xml2JsParser {
       const { tagDetail, isSkip } = this._stopNodeProcessorMeta;
       this._stopNodeProcessor.resumeAfterOpenTag();
       readTagExp(this); // re-consume the opening tag from the rewound source
-      const content = this._stopNodeProcessor.collect(this.source);
+      // openEnd reflects the offset right after this opening tag's '>' — stable
+      // across retries since the opening tag is fully re-read every time.
+      tagDetail.openEnd = this.source.startIndex;
+      const { content, end: stopEnd } = this._stopNodeProcessor.collect(this.source);
       if (!isSkip) {
         this.outputBuilder.addElement(tagDetail, this.readonlyMatcher);
-        this.outputBuilder.onStopNode?.(tagDetail, content, this.readonlyMatcher);
+        this.outputBuilder.onStopNode?.(tagDetail, content, this.readonlyMatcher, stopEnd);
         this.outputBuilder.addValue(content, this.readonlyMatcher);
-        this.outputBuilder.closeElement(this.readonlyMatcher);
+        this.outputBuilder.closeElement(this.readonlyMatcher, { name: tagDetail.name, closeEnd: stopEnd.index });
       }
       this.matcher.pop();
       this._stopNodeProcessor = null;
@@ -280,9 +313,10 @@ export default class Xml2JsParser {
     const processedTagName = this.processTagName(tagExp.tagName);
     const tagDetail = new TagDetail(
       processedTagName,
-      this.source.line,
-      this.source.cols,
-      this.source.startIndex,
+      tagStart.line,
+      tagStart.col,
+      tagStart.index,
+      this.source.startIndex, // openEnd: offset right after this opening tag's '>'
     );
 
     // Extract namespace prefix and local name from raw tag name (e.g. "ns:tag" → "ns", "tag").
@@ -331,7 +365,7 @@ export default class Xml2JsParser {
     const skipTagConfig = stopNodeConfig ? null : this.isSkipTag();
 
     if (!options.skip.attributes && !skipTagConfig) {
-      flushAttributes(tagExp._attrsExp, this);
+      flushAttributes(tagExp._attrsExp, this, tagExp._attrsExpStart);
     }
 
     // Stop-node and skip-tag checks AFTER attributes are set so attribute conditions work.
@@ -341,12 +375,15 @@ export default class Xml2JsParser {
 
     if (this.isUnpaired(processedTagName)) {
       this.outputBuilder.addElement(tagDetail, this.readonlyMatcher);
-      this.outputBuilder.closeElement(this.readonlyMatcher);
+      // Unpaired tags (e.g. <br>, <img>) have no separate closing tag — the
+      // close position is the same as the open tag's end.
+      this.outputBuilder.closeElement(this.readonlyMatcher, this._closeMetaFor(tagDetail));
       this.matcher.pop();
     } else if (tagExp.selfClosing) {
       if (!skipTagConfig) {
         this.outputBuilder.addElement(tagDetail, this.readonlyMatcher);
-        this.outputBuilder.closeElement(this.readonlyMatcher);
+        // Self-closing tags (<tag/>) likewise have no distinct closing tag.
+        this.outputBuilder.closeElement(this.readonlyMatcher, this._closeMetaFor(tagDetail));
       }
       this.matcher.pop();
     } else if (stopNodeConfig) {
@@ -360,11 +397,16 @@ export default class Xml2JsParser {
       });
       this._stopNodeProcessorMeta = { tagDetail, isSkip: false };
       this._stopNodeProcessor.activate();
-      const content = this._stopNodeProcessor.collect(this.source);
+      const { content, end: stopEnd } = this._stopNodeProcessor.collect(this.source);
       this.outputBuilder.addElement(tagDetail, this.readonlyMatcher);
-      this.outputBuilder.onStopNode?.(tagDetail, content, this.readonlyMatcher);
+      this.outputBuilder.onStopNode?.(tagDetail, content, this.readonlyMatcher, stopEnd);
       this.outputBuilder.addValue(content, this.readonlyMatcher);
-      this.outputBuilder.closeElement(this.readonlyMatcher);
+      // closeMeta for a stop node carries only `closeEnd` (offset right after
+      // the matched </tagname> was consumed) — StopNodeProcessor scans the
+      // closing tag opaquely and doesn't track where '</tagname' itself starts,
+      // so unlike the normal close path we don't have a real index/line/col
+      // for the close tag's own start, only its end.
+      this.outputBuilder.closeElement(this.readonlyMatcher, { name: tagDetail.name, closeEnd: stopEnd.index });
       this.matcher.pop();
       this._stopNodeProcessor = null;
       this._stopNodeProcessorMeta = null;
@@ -435,13 +477,36 @@ export default class Xml2JsParser {
    * Pop the current tag from the parser stack and notify the output builder.
    * This is the single point of exit for closing a tag — both stacks are
    * updated together.
+   *
+   * @param {object} [closeMeta] - Position info for the closing tag:
+   *   { name, line, col, index, closeEnd }. Omitted when there is no real
+   *   closing tag to report a position for — e.g. AutoCloseHandler synthesizing
+   *   a close at EOF, or exitIf closing already-open ancestors. In that case a
+   *   minimal `{ name }` is passed to the builder instead of nothing, so
+   *   closeElement() never has to special-case "no second argument at all".
    */
-  popTag() {
-    this.outputBuilder.closeElement(this.readonlyMatcher);
+  popTag(closeMeta) {
+    this.outputBuilder.closeElement(this.readonlyMatcher, closeMeta ?? { name: this.currentTagDetail?.name });
     this.matcher.pop();
     this.currentTagDetail = this.tagsStack.pop();
   }
 
+  /**
+   * Build a closeMeta object for tags with no distinct closing token
+   * (unpaired tags like <br>, and self-closing tags like <tag/>) — the close
+   * position is just the opening tag's own end.
+   * @param {TagDetail} tagDetail
+   */
+  _closeMetaFor(tagDetail) {
+    return {
+      name: tagDetail.name,
+      line: tagDetail.line,
+      col: tagDetail.col,
+      index: tagDetail.index,
+      closeEnd: tagDetail.openEnd,
+    };
+  }
+
   readSpecialTag(startCh) {
     if (startCh === "!") {
       let nextChar = this.source.readCh();
@@ -481,7 +546,7 @@ export default class Xml2JsParser {
   processAttrName(attrName) {
     const options = this.options;
     attrName = resolveNsPrefix(attrName, options.skip.nsPrefix);
-    if (!isQName(attrName, this.xmlVersion)) { //TODO: make it optional
+    if (!isQName(attrName, this.xmlDec.version)) { //TODO: make it optional
       throw new ParseError(`Invalid attribute name: ${attrName}`, ErrorCode.INVALID_ATTRIBUTE_NAME);
     }
     attrName = sanitizeName(attrName, options.onDangerousProperty);