@nodable/flexible-xml-parser 1.6.0 → 1.7.0

package/src/AttributeProcessor.js

@@ -30,9 +30,13 @@ import { isSpaceCode } from "./util.js"
 /**
  * Parse an attribute expression string into an array of match tuples.
  *
- * Each element has the same shape the old getAllMatches() returned so that
- * callers are unchanged:
- *   [fullMatch, name, '=value' | undefined, quote | undefined, value | undefined]
+ * Each element is `{ name, value, startIndex }` — `value` is `undefined` for
+ * a boolean attribute (no `=`). Earlier versions of this function also built
+ * a full-match string and an `'=value'` string per attribute (matching an
+ * old regex-based getAllMatches() return shape) — neither was ever read by
+ * collectRawAttributes()/flushAttributes() (only `name`, `value`, and
+ * `.startIndex` are), so building them was pure wasted string concatenation
+ * on every attribute, on every tag. Dropped.
  *
  * The implementation is a single O(n) pass over char codes with no regex and
  * no recursion, making it safe for arbitrarily long attribute strings.
@@ -44,7 +48,7 @@ import { isSpaceCode } from "./util.js"
  *   IN_VALUE   — inside a quoted value, accumulating until the closing quote
  *
  * @param {string} attrStr
- * @returns {Array}  array of match tuples (see shape above)
+ * @returns {Array<{name: string, value: string|undefined, startIndex: number}>}
  */
 function parseAttributes(attrStr) {
   const results = [];
@@ -66,9 +70,7 @@ function parseAttributes(attrStr) {
 
     if (i >= len || attrStr.charCodeAt(i) !== 61) {
       // Boolean attribute — no '='
-      const m = [name, name, undefined, undefined, undefined];
-      m.startIndex = nameStart;
-      results.push(m);
+      results.push({ name, value: undefined, startIndex: nameStart });
       continue;
     }
 
@@ -81,7 +83,6 @@ function parseAttributes(attrStr) {
     const quote = attrStr.charCodeAt(i);
     if (quote === 34 || quote === 39) { // " or '
       i++; // skip opening quote
-      const valueStart = i;
       let value = '';
       let segStart = i;
       while (i < len && attrStr.charCodeAt(i) !== quote) {
@@ -94,10 +95,7 @@ function parseAttributes(attrStr) {
       }
       value += attrStr.substring(segStart, i);
       i++; // skip closing quote
-      const quoteChar = String.fromCharCode(quote);
-      const m = [name + '=' + quoteChar + value + quoteChar, name, '=' + quoteChar + value + quoteChar, quoteChar, value];
-      m.startIndex = nameStart;
-      results.push(m);
+      results.push({ name, value, startIndex: nameStart });
     }
   }
 
@@ -105,7 +103,20 @@ function parseAttributes(attrStr) {
 }
 
 /**
- * Pass 1: extract raw (unparsed) attribute values into rawAttributes.
+ * Pass 1: extract raw (unparsed) attribute values into rawAttributes, AND
+ * build tagExp._parsedAttrs — the processed-name/value list pass 2 will
+ * consume directly.
+ *
+ * Previously, pass 2 (flushAttributes) re-ran parseAttributes() from scratch
+ * on the same attrStr, and re-ran parser.processAttrName() (ns-prefix
+ * resolution + name validation + sanitizeName + reserved-name check) on
+ * every attribute a second time — full re-tokenization plus full re-validation
+ * of work already done here. processAttrName() is a pure function of
+ * (rawName, options) — nothing between pass 1 and pass 2 (matcher.push,
+ * stop/skip resolution) can change its result — so it's safe to compute once
+ * and cache. The matcher still gets the *raw* (pre-resolveNsPrefix/sanitize)
+ * name as its rawAttributes key, unchanged, since PEM's attribute-condition
+ * matching (`div[class=code]`) matches against attribute names as written.
  *
  * @param {string} attrStr      - raw attribute expression substring
  * @param {object} parser       - Xml2JsParser instance (for processAttrName)
@@ -116,56 +127,60 @@ export function collectRawAttributes(attrStr, parser, tagExp) {
 
   const matches = parseAttributes(attrStr);
   const len = matches.length;
+  tagExp._rawAttrMatchCount = len; // total parsed attrs, incl. dropped (xmlns:) ones — for maxAttributesPerTag parity with old behavior
+  const parsedAttrs = [];
   let count = 0;
   for (let i = 0; i < len; i++) {
-    const attrName = parser.processAttrName(matches[i][1]);
+    const m = matches[i];
+    const attrName = parser.processAttrName(m.name);
     if (attrName === false) continue;
     count++;
-    const rawVal = matches[i][4];
-    tagExp.rawAttributes[matches[i][1]] = rawVal !== undefined ? rawVal : true;
+    const rawVal = m.value;
+    const attrVal = rawVal !== undefined ? rawVal : true;
+    tagExp.rawAttributes[m.name] = attrVal;
+    parsedAttrs.push({ name: attrName, value: attrVal, index: m.startIndex });
   }
   tagExp.rawAttributesLen = count;
+  tagExp._parsedAttrs = parsedAttrs;
 }
 
 /**
- * Pass 2: run value parsers and push each attribute to the output builder.
+ * Pass 2: push each attribute (already parsed + name-processed by pass 1,
+ * see tagExp._parsedAttrs) to the output builder. No re-parsing, no
+ * re-running processAttrName — this is now a plain loop over cached data.
  *
- * @param {string} attrStr - raw attribute expression substring
+ * @param {Array<{name: string, value: *, index: number}>} parsedAttrs - tagExp._parsedAttrs from collectRawAttributes
  * @param {object} parser  - Xml2JsParser instance
- * @param {number} [attrsExpStart] - absolute document offset where `attrStr`
- *   begins (tagExp._attrsExpStart from buildTagExpObj). When provided, each
+ * @param {number} [attrsExpStart] - absolute document offset where the
+ *   attribute expression began (tagExp._attrsExpStart). When provided, each
  *   attribute's absolute document index is computed and passed to
  *   addAttribute() as a 4th argument: { index }. Line/col are intentionally
  *   NOT computed here — doing so would require re-scanning attrStr for
  *   newlines on every call, for a field most builders won't use; callers
  *   that need it can derive line/col from `index` plus the document text.
+ * @param {number} rawAttrMatchCount - tagExp._rawAttrMatchCount, used for the
+ *   maxAttributesPerTag limit check (counts all parsed attrs, including any
+ *   dropped by processAttrName, matching the limit's pre-existing semantics).
  */
-export function flushAttributes(attrStr, parser, attrsExpStart) {
-  if (!attrStr || attrStr.length === 0) return;
-  const matches = parseAttributes(attrStr);
-  const len = matches.length;
+export function flushAttributes(parsedAttrs, parser, attrsExpStart, rawAttrMatchCount) {
+  if (!parsedAttrs || parsedAttrs.length === 0) return;
 
   const maxAttrs = parser.options.limits?.maxAttributesPerTag;
-  if (maxAttrs !== undefined && maxAttrs !== null && len > maxAttrs) {
+  if (maxAttrs !== undefined && maxAttrs !== null && rawAttrMatchCount > maxAttrs) {
     const tagName = parser.currentTagDetail?.name ?? '(unknown)';
     throw new ParseError(
-      `Tag '${tagName}' has ${len} attributes, exceeding limit of ${maxAttrs}`,
+      `Tag '${tagName}' has ${rawAttrMatchCount} attributes, exceeding limit of ${maxAttrs}`,
       ErrorCode.LIMIT_MAX_ATTRIBUTES,
       { line: parser.source.line, col: parser.source.cols, index: parser.source.startIndex }
     );
   }
 
+  const len = parsedAttrs.length;
   for (let i = 0; i < len; i++) {
-    const attrName = parser.processAttrName(matches[i][1]);
-    if (attrName === false) continue;
-
-    const rawVal = matches[i][4];
-    const attrVal = rawVal !== undefined ? rawVal : true;
-
+    const a = parsedAttrs[i];
     const attrMeta = attrsExpStart !== undefined
-      ? { index: attrsExpStart + matches[i].startIndex }
+      ? { index: attrsExpStart + a.index }
       : undefined;
-
-    parser.outputBuilder.addAttribute(attrName, attrVal, parser.readonlyMatcher, attrMeta);
+    parser.outputBuilder.addAttribute(a.name, a.value, parser.readonlyMatcher, attrMeta);
   }
 }

package/src/DocTypeReader.js

@@ -1,5 +1,5 @@
 import { ParseError, ErrorCode } from './ParseError.js';
-import { name as isName, qName as isQName } from 'xml-naming';
+
 
 export function readDocType(parser) {
     parser.source.markTokenStart(1);
@@ -267,7 +267,7 @@ function readEntityExp(parser) {
             { line: source.line, col: source.cols, index: source.startIndex });
     }
 
-    validateEntityName(entityName, parser.xmlVersion);
+    validateEntityName(entityName, parser);
     skipSourceWhitespace(source);
 
     if (!source.canRead()) {
@@ -346,7 +346,7 @@ function readElementExp(parser) {
             { line: source.line, col: source.cols, index: source.startIndex });
     }
 
-    if (!isName(elementName, parser.xmlVersion)) {
+    if (!parser.getNameValidator('name')(elementName)) {
         throw new ParseError(`Invalid element name: "${elementName}"`,
             ErrorCode.INVALID_TAG,
             { line: source.line, col: source.cols, index: source.startIndex });
@@ -434,7 +434,7 @@ function readNotationExp(parser) {
             { line: source.line, col: source.cols, index: source.startIndex });
     }
 
-    validateEntityName(notationName, parser.xmlVersion);
+    validateEntityName(notationName, parser);
     skipSourceWhitespace(source);
 
     // Need all 6 chars of "SYSTEM" / "PUBLIC" before we can classify
@@ -512,8 +512,8 @@ function skipSourceWhitespace(source) {
     }
 }
 
-function validateEntityName(name, xmlVersion) {
-    if (isName(name, xmlVersion)) return name;
+function validateEntityName(name, parser) {
+    if (parser.getNameValidator('name')(name)) return name;
     throw new ParseError(
         `Invalid entity name "${name}"`,
         ErrorCode.ENTITY_INVALID_KEY,

package/src/InputSource/BufferSource.js

@@ -114,6 +114,31 @@ export default class BufferSource {
     return this.buffer.slice(from, from + n).toString();
   }
 
+  /**
+   * See StringSource.scanTagExpEnd() for full rationale. Byte-indexed —
+   * quote/`>` are single-byte ASCII, safe for multi-byte UTF-8 content too
+   * (a `>` byte never appears as a UTF-8 continuation byte). Buffer isn't a
+   * rope, so no equivalent of FeedableSource's charCodeAt/flatten concern.
+   */
+  scanTagExpEnd() {
+    const buf = this.buffer;
+    const len = buf.length;
+    const start = this.startIndex;
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = start; i < len; i++) {
+      const c = buf[i];
+      if (c === 39) { // '
+        if (!inDouble) inSingle = !inSingle;
+      } else if (c === 34) { // "
+        if (!inSingle) inDouble = !inDouble;
+      } else if (c === 62 && !inSingle && !inDouble) { // >
+        return i - start;
+      }
+    }
+    return -1;
+  }
+
   /**
    * 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
@@ -224,20 +249,9 @@ export default class BufferSource {
   }
 
   readFromBuffer(n, shouldUpdate) {
-    let ch;
-    if (n === 1) {
-      ch = this.buffer[this.startIndex];
-      if (ch === 10) { // '\n'
-        this.line++;
-        this.cols = 1;
-      } else {
-        this.cols++;
-      }
-      ch = String.fromCharCode(ch);
-    } else {
-      this.cols += n;
-      ch = this.buffer.slice(this.startIndex, this.startIndex + n).toString();
-    }
+    const ch = n === 1
+      ? String.fromCharCode(this.buffer[this.startIndex])
+      : this.buffer.slice(this.startIndex, this.startIndex + n).toString();
     if (shouldUpdate) this.updateBufferBoundary(n);
     return ch;
   }

package/src/InputSource/FeedableSource.js

@@ -1,4 +1,5 @@
 import { ParseError, ErrorCode } from '../ParseError.js';
+import { StringDecoder } from 'node:string_decoder';
 
 /**
  * FeedableSource — input source for the feed()/end() API.
@@ -78,6 +79,19 @@ export default class FeedableSource {
      * the next feed() double-counts every '\n' it consumed before failing.
      */
     this._marks = [null, null];
+
+    /**
+     * Lazily-created, persistent across the whole feed() session. Buffer
+     * chunks must go through this rather than Buffer#toString() per chunk —
+     * toString() decodes each chunk in isolation, so a multi-byte UTF-8
+     * character whose bytes straddle a chunk boundary gets corrupted (each
+     * half independently replaced with U+FFFD). StringDecoder holds back an
+     * incomplete trailing sequence internally and prepends it to the next
+     * write(), so a split character decodes correctly once the rest of its
+     * bytes arrive. Only created if Buffer input is ever fed — string-only
+     * callers never pay for it.
+     */
+    this._decoder = null;
   }
 
   /**
@@ -89,9 +103,28 @@ export default class FeedableSource {
    * the limit.
    *
    * @param {string|Buffer} data
+   * @returns {number} number of characters appended to the buffer (after
+   *   decoding) — callers that track fed-byte totals (e.g. XMLParser.feed's
+   *   batch threshold) should use this rather than the raw input length,
+   *   since a Buffer chunk ending mid-character may decode to fewer chars
+   *   than its byte length until the next chunk completes the sequence.
    */
   feed(data) {
-    const newData = typeof data === 'string' ? data : data.toString();
+    let newData;
+    if (typeof data === 'string') {
+      newData = data;
+    } else if (Buffer.isBuffer(data)) {
+      // Stateful decode: bytes of a multi-byte char split across two feed()
+      // calls are buffered internally by StringDecoder and correctly
+      // stitched together, instead of each chunk being decoded in isolation.
+      if (!this._decoder) this._decoder = new StringDecoder('utf8');
+      newData = this._decoder.write(data);
+    } else if (data?.toString) {
+      newData = data.toString();
+    } else {
+      throw new ParseError('feed() data must be a string or Buffer.', ErrorCode.DATA_MUST_BE_STRING);
+    }
+
     const liveBytes = this.buffer.length - this.startIndex;
 
     if (liveBytes + newData.length > this.maxBufferSize) {
@@ -103,10 +136,20 @@ export default class FeedableSource {
     }
 
     this.buffer += newData;
+    return newData.length;
   }
 
   /** Signal that no more data will be fed. */
   end() {
+    if (this._decoder) {
+      // Flush any final incomplete byte sequence held by the decoder. For
+      // well-formed UTF-8 input this is normally '' (nothing pending); a
+      // non-empty result here means the input was genuinely truncated
+      // mid-character, and StringDecoder's own U+FFFD substitution is the
+      // correct, standard behavior for that case.
+      const tail = this._decoder.end();
+      if (tail) this.buffer += tail;
+    }
     this.isComplete = true;
   }
 
@@ -214,6 +257,43 @@ export default class FeedableSource {
     return this.buffer.substring(from, from + n);
   }
 
+  /**
+   * Quote-aware scan, from the current read position, for the unquoted '>'
+   * that ends a tag expression. Used by readTagExp() — replaces the old
+   * per-char canRead(i)/readChAt(i) loop, which profiling showed as the
+   * single largest hotspot (~23-26% of parse time).
+   *
+   * IMPORTANT: bracket char access (`buf[i]`), not `charCodeAt(i)`. This
+   * source's buffer is built via repeated `+=` in feed() (a growing V8
+   * ConsString/rope). charCodeAt forces a full rope-flatten on access —
+   * confirmed via a crash (Runtime_StringCharCodeAt -> String::SlowFlatten)
+   * causing real O(n^2) memory growth when this was first written with
+   * charCodeAt. Bracket access matches what the pre-existing readChAt()
+   * already safely used.
+   *
+   * @returns {number} relative offset of the unquoted '>', or -1 if the
+   *   buffer runs out first — caller treats that as UNEXPECTED_END, the
+   *   normal retryable chunk-boundary signal for this source.
+   */
+  scanTagExpEnd() {
+    const buf = this.buffer;
+    const len = buf.length;
+    const start = this.startIndex;
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = start; i < len; i++) {
+      const c = buf[i];
+      if (c === "'") {
+        if (!inDouble) inSingle = !inSingle;
+      } else if (c === '"') {
+        if (!inSingle) inDouble = !inDouble;
+      } else if (c === '>' && !inSingle && !inDouble) {
+        return i - start;
+      }
+    }
+    return -1;
+  }
+
   /**
    * Read until stop string is found.
    * @param {string} stopStr
@@ -341,8 +421,14 @@ export default class FeedableSource {
     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) {
+    // No "any mark active" gate here — flush()'s own min(startIndex, marks...)
+    // origin computation already guarantees any in-progress token (at either
+    // mark level) survives the trim. A separate boolean gate on top of that
+    // was redundant, and since _marks[0] is set on every parseXml() loop
+    // iteration and never nulled outside of rewindToMark() (an error path),
+    // that gate was effectively permanent — flush() never ran in normal
+    // operation. See specs/flushArchitecture_spec.js for the regression test.
+    if (this.autoFlush && this.startIndex >= this.flushThreshold) {
       this.flush();
     }
   }
@@ -353,7 +439,10 @@ export default class FeedableSource {
    *
    * The flush origin is the minimum of all active mark positions, so that any
    * in-progress token (at either mark level) is preserved in the buffer and
-   * can be re-read after the flush.
+   * can be re-read after the flush. This is the sole safety mechanism for
+   * flush() — callers do not need to additionally check "is a mark active"
+   * before calling this; an active mark simply caps how much origin can
+   * advance, rather than blocking the call outright.
    *
    * If no marks are active, the origin is startIndex itself — everything
    * before the current read position is discarded.

package/src/InputSource/StreamSource.js

@@ -28,7 +28,11 @@ export default class StreamSource extends FeedableSource {
   attachStream(readable, onChunk, onEnd, onError) {
     readable.on('data', chunk => {
       try {
-        this.feed(typeof chunk === 'string' ? chunk : chunk.toString());
+        // Pass the raw chunk (Buffer or string) straight through — feed()
+        // decodes Buffers via a persistent StringDecoder so a multi-byte
+        // UTF-8 character split across two chunks decodes correctly instead
+        // of each half being independently mangled by a per-chunk toString().
+        this.feed(chunk);
         onChunk(null); // chunk appended successfully — caller runs parseXml()
       } catch (err) {
         onChunk(err); // buffer overflow or coercion failure

package/src/InputSource/StringSource.js

@@ -127,6 +127,35 @@ export default class StringSource {
     return this.buffer.substring(from, from + n);
   }
 
+  /**
+   * Quote-aware scan, from the current read position, for the unquoted '>'
+   * that ends a tag expression (`<tag attr="...">`). Used by readTagExp().
+   * Direct-buffer, bracket-indexed (not charCodeAt — see FeedableSource's
+   * copy of this method for why that matters there; kept identical here
+   * for consistency even though StringSource's buffer is never re-concatenated).
+   *
+   * @returns {number} relative offset (from startIndex) of the unquoted '>',
+   *   or -1 if the buffer is exhausted first (malformed input for StringSource).
+   */
+  scanTagExpEnd() {
+    const buf = this.buffer;
+    const len = buf.length;
+    const start = this.startIndex;
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = start; i < len; i++) {
+      const c = buf[i];
+      if (c === "'") {
+        if (!inDouble) inSingle = !inSingle;
+      } else if (c === '"') {
+        if (!inSingle) inDouble = !inDouble;
+      } else if (c === '>' && !inSingle && !inDouble) {
+        return i - start;
+      }
+    }
+    return -1;
+  }
+
   /**
    * Scan buffer[this.startIndex, end) for '\n' and advance line/cols to match,
    * mirroring readCh()'s per-char logic. Does NOT touch startIndex — callers
@@ -251,8 +280,12 @@ export default class StringSource {
     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) {
+    // See FeedableSource.updateBufferBoundary() for why there is no "any mark
+    // active" gate here — flush()'s own min-origin computation already
+    // protects any in-progress token; a separate gate was redundant and, since
+    // marks are effectively always set in normal operation, made flush()
+    // permanently unreachable. See specs/flushArchitecture_spec.js.
+    if (this.autoFlush && this.startIndex >= this.flushThreshold) {
       this.flush();
     }
   }

package/src/XMLParser.js

@@ -183,19 +183,15 @@ export default class XMLParser {
       this._initFeedSession();
     }
 
-    let str;
-    if (typeof data === 'string') {
-      str = data;
-    } else if (Buffer.isBuffer(data)) {
-      str = data.toString();
-    } else if (data?.toString) {
-      str = data.toString();
-    } else {
-      throw new ParseError('feed() data must be a string or Buffer.', ErrorCode.DATA_MUST_BE_STRING);
-    }
-
-    this._feedSource.feed(str);
-    this._pendingBytes += str.length;
+    // Pass raw data straight through — do NOT pre-convert Buffers to string
+    // here. FeedableSource.feed() decodes Buffers via a persistent
+    // StringDecoder so a multi-byte UTF-8 character split across two feed()
+    // calls decodes correctly; converting each chunk with .toString() first
+    // (as this used to do) decodes each chunk in isolation and corrupts a
+    // split character. feed() itself validates the type and throws
+    // DATA_MUST_BE_STRING for anything unsupported.
+    const appendedLength = this._feedSource.feed(data);
+    this._pendingBytes += appendedLength;
 
     if (this._pendingBytes >= this._batchThreshold) {
       this._runParse();

package/src/Xml2JsParser.js

@@ -8,7 +8,7 @@ import { readDocType } from './DocTypeReader.js';
 import { DANGEROUS_PROPERTY_NAMES, criticalProperties } from './util.js';
 import AutoCloseHandler from './AutoCloseHandler.js';
 import { ParseError, ErrorCode } from './ParseError.js';
-import { name as isName, qName as isQName } from 'xml-naming';
+import { createValidator } from 'xml-naming';
 
 class TagDetail {
   /**
@@ -66,6 +66,14 @@ export default class Xml2JsParser {
     this.tagsStack = [];
     this._stopNodeProcessor = null;
     this._exitIfTriggered = false;
+    // Lazily-built, memoized xml-naming validators (v0.3.0 createValidator).
+    // Lazy because xmlDec.version isn't final until the optional <?xml?>
+    // declaration (if any) has been read — which happens after this method
+    // runs but before any tag name is ever validated. Reset here (once per
+    // document/session, see XMLParser._createParser / feed() call sites) so
+    // a reused Xml2JsParser instance never validates against a stale
+    // xmlVersion or leaks one document's name cache into the next.
+    this._nameValidators = Object.create(null);
     this.xmlDec = {
       version: 1.0,
       lang: null,
@@ -156,13 +164,18 @@ export default class Xml2JsParser {
           { line: this.source.line, col: this.source.cols, index: this.source.startIndex }
         );
 
-        if (nextChar === '!' || nextChar === '?') {
+        //sorted frequency wise
+        if (nextChar === '/') {
+          this.source.updateBufferBoundary();
+          this.readClosingTag(tagStart);
+        } else if (nextChar === '!') {
           this.source.updateBufferBoundary();
           this.addTextNode();
           this.readSpecialTag(nextChar);
-        } else if (nextChar === '/') {
+        } else if (nextChar === '?') {
           this.source.updateBufferBoundary();
-          this.readClosingTag(tagStart);
+          this.addTextNode();
+          readPiTag(this);
         } else {
           this.readOpeningTag(tagStart);
         }
@@ -365,7 +378,7 @@ export default class Xml2JsParser {
     const skipTagConfig = stopNodeConfig ? null : this.isSkipTag();
 
     if (!options.skip.attributes && !skipTagConfig) {
-      flushAttributes(tagExp._attrsExp, this, tagExp._attrsExpStart);
+      flushAttributes(tagExp._parsedAttrs, this, tagExp._attrsExpStart, tagExp._rawAttrMatchCount);
     }
 
     // Stop-node and skip-tag checks AFTER attributes are set so attribute conditions work.
@@ -526,8 +539,6 @@ export default class Xml2JsParser {
           this.outputBuilder.addInputEntities(docTypeEntities);
         }
       }
-    } else if (startCh === "?") {
-      readPiTag(this);
     } else {
       throw new ParseError(`Invalid tag '<${startCh}'`, ErrorCode.INVALID_TAG, { line: this.source.line, col: this.source.cols, index: this.source.startIndex });
     }
@@ -543,10 +554,34 @@ export default class Xml2JsParser {
     }
   }
 
+  /**
+   * Returns a memoized xml-naming validator for the given production
+   * ('qName' for tag/attribute names, 'name' for DOCTYPE entity/element/
+   * notation names), built lazily on first use and cached per parser
+   * instance for the rest of the document/session.
+   *
+   * xmlDec.version is stored as a number (1.0 / 1.1) but xml-naming's
+   * xmlVersion option is the string '1.0'/'1.1' — normalized here rather
+   * than changing xmlDec's public shape (it's forwarded as-is to
+   * outputBuilder.addDeclaration(), so its type is part of the builder
+   * contract, not just an internal detail).
+   *
+   * @param {'name'|'qName'} production
+   */
+  getNameValidator(production) {
+    let validator = this._nameValidators[production];
+    if (!validator) {
+      const xmlVersion = this.xmlDec.version === 1.1 || this.xmlDec.version === '1.1' ? '1.1' : '1.0';
+      validator = createValidator(production, { xmlVersion });
+      this._nameValidators[production] = validator;
+    }
+    return validator;
+  }
+
   processAttrName(attrName) {
     const options = this.options;
     attrName = resolveNsPrefix(attrName, options.skip.nsPrefix);
-    if (!isQName(attrName, this.xmlDec.version)) { //TODO: make it optional
+    if (!this.getNameValidator('qName')(attrName)) { //TODO: make it optional
       throw new ParseError(`Invalid attribute name: ${attrName}`, ErrorCode.INVALID_ATTRIBUTE_NAME);
     }
     attrName = sanitizeName(attrName, options.onDangerousProperty);