@patrickdk77/office-defuse 0.0.0-stage → 0.1.0

package/dist/xml.js

@@ -0,0 +1,1105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XmlTokenizer = exports.isNcName = exports.unknownEntity = exports.showReferences = exports.UNKNOWN = exports.XMLNS_NS = exports.XML_NS = void 0;
+exports.attr = attr;
+const node_util_1 = require("node:util");
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+exports.XML_NS = 'http://www.w3.org/XML/1998/namespace';
+exports.XMLNS_NS = 'http://www.w3.org/2000/xmlns/';
+/**
+ * Stands in text for a reference to an external entity, whose content office-defuse never fetches: UNKNOWN, the
+ * entity's name, UNKNOWN again. U+FFFF cannot occur in XML, so nothing a part holds is taken for it.
+ */
+exports.UNKNOWN = String.fromCharCode(0xffff);
+/** One reference to an external entity, with the entity's name as its group. Built from UNKNOWN so the source stays ASCII. */
+const UNKNOWN_NAME = `${exports.UNKNOWN}([^${exports.UNKNOWN}]*)${exports.UNKNOWN}`;
+const UNKNOWN_REFERENCE = new RegExp(UNKNOWN_NAME, 'g');
+const UNKNOWN_FIRST = new RegExp(UNKNOWN_NAME);
+/** A value with each reference to an external entity written back as `&name;`, for a finding to show. */
+const showReferences = (s) => (s.includes(exports.UNKNOWN) ? s.replace(UNKNOWN_REFERENCE, '&$1;') : s);
+exports.showReferences = showReferences;
+/** The name of the first external entity whose content stands in `s`, or undefined when none does. */
+const unknownEntity = (s) => UNKNOWN_FIRST.exec(s)?.[1];
+exports.unknownEntity = unknownEntity;
+/** The value of the attribute with this namespace and local name. */
+function attr(el, ns, local) {
+    for (const a of el.attributes)
+        if (a.local === local && a.ns === ns)
+            return a.value;
+    return undefined;
+}
+// XML 1.0 fifth edition NameStartChar and the further NameChar ranges, without the colon, which namespaces reserve.
+const NAME_START = 'A-Z_a-z\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2FF}\\u{370}-\\u{37D}\\u{37F}-\\u{1FFF}\\u{200C}-\\u{200D}\\u{2070}-\\u{218F}\\u{2C00}-\\u{2FEF}\\u{3001}-\\u{D7FF}\\u{F900}-\\u{FDCF}\\u{FDF0}-\\u{FFFD}\\u{10000}-\\u{EFFFF}';
+const NAME_MORE = '\\-.0-9\\u{B7}\\u{300}-\\u{36F}\\u{203F}-\\u{2040}';
+const NC_NAME = new RegExp(`^[${NAME_START}][${NAME_START}${NAME_MORE}]*$`, 'u');
+/** A name token, as an enumerated attribute type lists them. */
+const NMTOKEN = new RegExp(`^[${NAME_START}${NAME_MORE}:]+$`, 'u');
+/** An XML name without a colon. */
+const isNcName = (s) => NC_NAME.test(s);
+exports.isNcName = isNcName;
+/** A name with at most one colon, between two names without one. */
+const isQName = (s) => {
+    const colon = s.indexOf(':');
+    return colon < 0 ? (0, exports.isNcName)(s) : (0, exports.isNcName)(s.slice(0, colon)) && (0, exports.isNcName)(s.slice(colon + 1));
+};
+const PREDEFINED = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" };
+/** Longest reference read: "&#x" with eight digits and ";" is 12, and leading zeros are legal. */
+const MAX_REFERENCE = 64;
+/** The characters a public identifier may hold. */
+const PUBID = /^[-a-zA-Z0-9 \r\n'()+,./:=?;!*#@$_%]*$/;
+/** Characters that end a name inside a document type declaration. */
+const NAME_END = /[\s>[\]"'%;&<]/;
+/** Attribute types other than CDATA, whose values are normalized further. NOTATION and enumerations are read apart. */
+const TOKENIZED_TYPES = new Set(['ID', 'IDREF', 'IDREFS', 'ENTITY', 'ENTITIES', 'NMTOKEN', 'NMTOKENS']);
+const LIMIT_DETAILS = new Set([types_1.OfficeDetail.XmlDepth, types_1.OfficeDetail.XmlTokenSize, types_1.OfficeDetail.XmlEntityDepth, types_1.OfficeDetail.XmlEntityExpansions, types_1.OfficeDetail.XmlEntitySize]);
+const isSpace = (c) => c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d;
+/** A character XML 1.0 allows. The decoders leave no lone surrogates, so the halves of a pair pass here. */
+const isXmlChar = (c) => c === 0x09 || c === 0x0a || c === 0x0d || (c >= 0x20 && c !== 0xfffe && c !== 0xffff);
+const isCodePointAllowed = (c) => c === 0x09 || c === 0x0a || c === 0x0d || (c >= 0x20 && c <= 0xd7ff) || (c >= 0xe000 && c <= 0xfffd) || (c >= 0x10000 && c <= 0x10ffff);
+/** The further normalization of XML 1.0 (3.3.3) for an attribute declared with a type other than CDATA. */
+const tokenize = (v) => v.replace(/ {2,}/g, ' ').replace(/^ | $/g, '');
+/** A cursor over a whole document type declaration, or over the text of a parameter entity read inside one. */
+class Cursor {
+    s;
+    normalized;
+    fail;
+    i;
+    /**
+     * `normalized` marks the text of a parameter entity. Its line ends were normalized where it was declared, so a CR
+     * in it, which only a character reference makes, stays a character of its own.
+     */
+    constructor(s, start, normalized, fail) {
+        this.s = s;
+        this.normalized = normalized;
+        this.fail = fail;
+        this.i = start;
+    }
+    /** Skips white space and tells whether there was any. */
+    space() {
+        const from = this.i;
+        while (this.i < this.s.length && isSpace(this.s.charCodeAt(this.i)))
+            this.i++;
+        return this.i > from;
+    }
+    needSpace(where) {
+        if (!this.space())
+            this.fail(`No white space ${where}`);
+    }
+    /** Steps over `word` when it is next, and tells whether it was. */
+    skip(word) {
+        if (!this.s.startsWith(word, this.i))
+            return false;
+        this.i += word.length;
+        return true;
+    }
+    /** Everything up to white space or a delimiter, for the caller to check as a name. */
+    name() {
+        const from = this.i;
+        while (this.i < this.s.length && !NAME_END.test(this.s[this.i]))
+            this.i++;
+        return this.s.slice(from, this.i);
+    }
+    /** A quoted literal, without its quotes. */
+    literal(what) {
+        const q = this.s[this.i];
+        if (q !== '"' && q !== "'")
+            this.fail(`${what} is not quoted`);
+        const from = this.i + 1;
+        const close = this.s.indexOf(q, from);
+        if (close < 0)
+            this.fail(`${what} is not closed`);
+        this.i = close + 1;
+        return this.s.slice(from, close);
+    }
+    /**
+     * Steps past the ">" that ends an element type or notation declaration, over quoted literals. A parameter entity
+     * reference may not stand inside a declaration of the internal subset, and nothing else there uses "%".
+     */
+    declarationEnd() {
+        for (; this.i < this.s.length; this.i++) {
+            const c = this.s[this.i];
+            if (c === '>') {
+                this.i++;
+                return;
+            }
+            if (c === '%')
+                this.fail('A parameter entity reference inside a declaration');
+            if (c === '"' || c === "'") {
+                const close = this.s.indexOf(c, this.i + 1);
+                if (close < 0)
+                    break;
+                this.i = close;
+            }
+        }
+        this.fail('A declaration in the internal subset does not end');
+    }
+}
+/**
+ * A streaming XML 1.0 tokenizer with namespaces. It refuses references to entities nothing declares, encodings other
+ * than UTF-8 and UTF-16, and anything not well-formed. It holds one markup token at a time; text goes to the handler
+ * in pieces.
+ *
+ * A document type declaration goes to `notes.doctype`. No external DTD or other external entity is ever loaded. The
+ * internal subset is read as XML 1.0 (5.1) has a processor read it that reads internal parameter entities and no
+ * external ones: it keeps the general entities and attribute-list declarations, reads the text of each internal
+ * parameter entity it refers to, and skips the entity and attribute-list declarations after a parameter entity it
+ * does not read, unless the XML declaration says standalone="yes".
+ *
+ * A reference to an internal entity is expanded, within the entity limits, and the handler sees its text, markup
+ * included, as if the part held it. A reference to an external entity in content goes to `notes.externalEntity`, and
+ * stands in the text as UNKNOWN marks it. One in an attribute value, directly or through other entities, is refused,
+ * as XML 1.0 refuses it. An attribute an element leaves out gets the default its attribute-list declaration gives, and
+ * an attribute declared with a type other than CDATA is normalized further, as expat does. Each default added counts
+ * as an expansion against the entity limits.
+ */
+class XmlTokenizer {
+    handler;
+    limits;
+    part;
+    decoder;
+    head = new Uint8Array(0);
+    buf = '';
+    pos = 0;
+    /** Offset in the decoded text of buf[0]. */
+    base = 0;
+    stack = [];
+    rootSeen = false;
+    doctypeSeen = false;
+    /** The XML declaration says standalone="yes". */
+    standalone = false;
+    encoding = 'utf-8';
+    /** The last text piece ended in CR, so an LF that starts the next piece belongs to the same line end. */
+    lastCr = false;
+    scan;
+    /** General entities the internal subset declares, by name. */
+    entities = new Map();
+    /** Parameter entities the internal subset declares, by name. */
+    parameters = new Map();
+    /** What the attribute-list declarations say, by element type as written. */
+    declared = new Map();
+    /** The entities being expanded, outermost first. A parameter entity's name has "%" in front. */
+    active = [];
+    /** While entity text is read, the offsets of the outermost reference, which its elements report. */
+    span;
+    /** The stack depth at which the entity text being read started. Its end tags close nothing below it. */
+    floor = 0;
+    vml;
+    notes;
+    budget;
+    /**
+     * `options.vml` reads the dialect Office writes in VML drawing parts, which is not well-formed XML: it skips the
+     * `<![if ...]>` and `<![endif]>` markers around content and takes an unclosed `<br>` as an empty element. Both
+     * branches of a marker reach the handler.
+     */
+    constructor(handler, limits, part, options = {}) {
+        this.handler = handler;
+        this.limits = limits;
+        this.part = part;
+        this.vml = options.vml ?? false;
+        this.notes = options.notes ?? {};
+        this.budget = options.budget ?? { expansions: 0, size: 0 };
+    }
+    stop(detail, message) {
+        const category = LIMIT_DETAILS.has(detail) ? types_1.OfficeCategory.Limit : types_1.OfficeCategory.Xml;
+        throw new errors_1.StopError(category, detail, `${this.part}: ${message}`, { part: this.part, reason: message }, this.part);
+    }
+    malformed(message) {
+        return this.stop(types_1.OfficeDetail.Malformed, message);
+    }
+    write(bytes) {
+        if (this.decoder) {
+            this.feed(this.decode(this.decoder, bytes, true), false);
+            return;
+        }
+        this.head = this.head.length ? Buffer.concat([this.head, bytes]) : bytes;
+        if (this.head.length >= 4)
+            this.begin();
+    }
+    end() {
+        const decoder = this.decoder ?? this.begin();
+        this.feed(this.decode(decoder, new Uint8Array(0), false), true);
+        if (this.stack.length)
+            this.malformed(`<${this.stack[this.stack.length - 1].el.qname}> is never closed`);
+        if (!this.rootSeen)
+            this.malformed('There is no root element');
+    }
+    /** Picks the encoding from the first bytes, as XML 1.0 Appendix F does, and reads the bytes held so far. */
+    begin() {
+        const b = this.head;
+        const at = (i) => (i < b.length ? b[i] : -1);
+        if ((at(0) === 0 && at(1) === 0) || (at(0) === 0xff && at(1) === 0xfe && at(2) === 0 && at(3) === 0) || (at(0) === 0x3c && at(1) === 0 && at(2) === 0 && at(3) === 0)) {
+            this.stop(types_1.OfficeDetail.Encoding, 'UTF-32 is not an encoding Office reads');
+        }
+        let skip = 0;
+        if (at(0) === 0xef && at(1) === 0xbb && at(2) === 0xbf)
+            skip = 3;
+        else if (at(0) === 0xff && at(1) === 0xfe) {
+            this.encoding = 'utf-16le';
+            skip = 2;
+        }
+        else if (at(0) === 0xfe && at(1) === 0xff) {
+            this.encoding = 'utf-16be';
+            skip = 2;
+        }
+        else if (at(0) === 0x3c && at(1) === 0 && at(2) === 0x3f && at(3) === 0)
+            this.encoding = 'utf-16le';
+        else if (at(0) === 0 && at(1) === 0x3c && at(2) === 0 && at(3) === 0x3f)
+            this.encoding = 'utf-16be';
+        const decoder = new node_util_1.TextDecoder(this.encoding, { fatal: true, ignoreBOM: true });
+        this.decoder = decoder;
+        this.head = new Uint8Array(0);
+        this.feed(this.decode(decoder, b.subarray(skip), true), false);
+        return decoder;
+    }
+    decode(decoder, bytes, more) {
+        try {
+            return decoder.decode(bytes, { stream: more });
+        }
+        catch {
+            return this.stop(types_1.OfficeDetail.Encoding, `Bytes that are not valid ${this.encoding.toUpperCase()}`);
+        }
+    }
+    /** Checks the XML declaration against the encoding the bytes are in, and notes whether it says standalone="yes". */
+    declaration(body) {
+        const version = /\bversion\s*=\s*(["'])([^"']*)\1/.exec(body)?.[2];
+        if (version !== '1.0')
+            this.malformed(`XML version ${version ?? 'missing'}`);
+        this.standalone = /\bstandalone\s*=\s*(["'])yes\1/.test(body);
+        const declared = /\bencoding\s*=\s*(["'])([^"']*)\1/.exec(body)?.[2]?.toLowerCase();
+        if (declared === undefined)
+            return;
+        const ok = this.encoding === 'utf-8' ? declared === 'utf-8' || declared === 'utf8' : declared === 'utf-16' || declared === this.encoding;
+        if (!ok)
+            this.stop(types_1.OfficeDetail.Encoding, `The declaration says ${declared}, the bytes are ${this.encoding.toUpperCase()}`);
+    }
+    feed(text, final) {
+        this.buf = this.pos < this.buf.length ? this.buf.slice(this.pos) + text : text;
+        this.base += this.pos;
+        this.pos = 0;
+        this.loop(final);
+    }
+    /** Reads the text and markup in buf from pos. Entity text is read with `final` set, since all of it is there. */
+    loop(final) {
+        for (;;) {
+            const lt = this.buf.indexOf('<', this.pos);
+            if (lt !== this.pos) {
+                // Text up to the next tag, or what can be decoded of it so far.
+                let end = lt < 0 ? this.buf.length : lt;
+                if (lt < 0 && !final) {
+                    const amp = this.buf.lastIndexOf('&');
+                    if (amp >= this.pos && this.buf.indexOf(';', amp) < 0) {
+                        if (this.buf.length - amp > MAX_REFERENCE)
+                            this.malformed('An unterminated reference');
+                        end = amp;
+                    }
+                }
+                if (end > this.pos)
+                    this.text(this.buf.slice(this.pos, end), this.base + this.pos);
+                this.pos = end;
+                if (lt < 0)
+                    break;
+            }
+            // At the end of the part, markup is read whole or refused, so nothing is left over.
+            if (!this.markup(final))
+                break;
+        }
+    }
+    /** The offset in the decoded text of buf[i], or while entity text is read, that of the reference to it. */
+    at(i, end = false) {
+        if (this.span)
+            return this.span[end ? 1 : 0];
+        return this.base + i;
+    }
+    /**
+     * Character data at `offset` in the decoded text. References are expanded and line ends turned into LF. Entity
+     * text had its line ends normalized where it was declared, so a CR in it, which only a character reference makes,
+     * stays.
+     */
+    text(raw, offset) {
+        const normalized = this.span !== undefined;
+        let out = '';
+        let from = 0;
+        let i = 0;
+        if (!normalized && this.lastCr && raw.charCodeAt(0) === 0x0a) {
+            from = 1;
+            i = 1;
+        }
+        for (; i < raw.length; i++) {
+            const c = raw.charCodeAt(i);
+            if (c === 0x26) {
+                const semi = raw.indexOf(';', i);
+                if (semi < 0 || semi - i > MAX_REFERENCE)
+                    this.malformed('An unterminated reference');
+                const name = raw.slice(i + 1, semi);
+                const plain = this.plainReference(name);
+                if (plain !== undefined)
+                    out += raw.slice(from, i) + plain;
+                else {
+                    this.characters(out + raw.slice(from, i));
+                    out = '';
+                    this.contentReference(name, offset + i, offset + semi + 1);
+                }
+                i = semi;
+                from = semi + 1;
+            }
+            else if (c === 0x0d && !normalized) {
+                out += `${raw.slice(from, i)}\n`;
+                if (raw.charCodeAt(i + 1) === 0x0a)
+                    i++;
+                from = i + 1;
+            }
+            else if (!isXmlChar(c)) {
+                this.malformed(`Character U+${c.toString(16).padStart(4, '0')} is not allowed in XML`);
+            }
+        }
+        if (!normalized)
+            this.lastCr = raw.charCodeAt(raw.length - 1) === 0x0d;
+        this.characters(from === 0 ? raw : out + raw.slice(from));
+    }
+    /** Hands decoded text to the handler. Outside the root element only white space may stand. */
+    characters(decoded) {
+        if (!this.stack.length) {
+            for (let i = 0; i < decoded.length; i++)
+                if (!isSpace(decoded.charCodeAt(i)))
+                    this.malformed('Text outside the root element');
+            return;
+        }
+        if (decoded.length)
+            this.handler.text?.(decoded);
+    }
+    /**
+     * Normalizes an attribute value as XML 1.0 (3.3.3) says: references expanded, and each white space character a
+     * space, except one written as a character reference. `normalized` marks entity text, whose line ends were
+     * normalized where it was declared, so a CR and LF in it are two characters.
+     */
+    attributeValue(raw, normalized) {
+        let out = '';
+        let from = 0;
+        for (let i = 0; i < raw.length; i++) {
+            const c = raw.charCodeAt(i);
+            if (c === 0x26) {
+                const semi = raw.indexOf(';', i);
+                if (semi < 0 || semi - i > MAX_REFERENCE)
+                    this.malformed('An unterminated reference');
+                const name = raw.slice(i + 1, semi);
+                out += raw.slice(from, i) + (this.plainReference(name) ?? this.attributeReference(name));
+                i = semi;
+                from = semi + 1;
+            }
+            else if (c === 0x0d && !normalized) {
+                out += `${raw.slice(from, i)} `;
+                if (raw.charCodeAt(i + 1) === 0x0a)
+                    i++;
+                from = i + 1;
+            }
+            else if (c === 0x0a || c === 0x09 || c === 0x0d) {
+                out += `${raw.slice(from, i)} `;
+                from = i + 1;
+            }
+            else if (c === 0x3c) {
+                this.malformed('"<" in an attribute value');
+            }
+            else if (!isXmlChar(c)) {
+                this.malformed(`Character U+${c.toString(16).padStart(4, '0')} is not allowed in XML`);
+            }
+        }
+        return from === 0 ? raw : out + raw.slice(from);
+    }
+    /** The text a predefined entity or a character reference stands for, or undefined for any other entity. */
+    plainReference(name) {
+        if (Object.hasOwn(PREDEFINED, name))
+            return PREDEFINED[name];
+        if (name.startsWith('#'))
+            return this.characterReference(name);
+        if (!(0, exports.isNcName)(name))
+            this.malformed('A malformed reference');
+        return undefined;
+    }
+    characterReference(name) {
+        const m = /^#(?:x([0-9a-fA-F]+)|([0-9]+))$/.exec(name);
+        if (!m)
+            this.malformed('A malformed reference');
+        const code = m[1] !== undefined ? Number.parseInt(m[1], 16) : Number.parseInt(m[2], 10);
+        if (!isCodePointAllowed(code))
+            this.malformed(`A character reference to U+${code.toString(16)}`);
+        return String.fromCodePoint(code);
+    }
+    /** The entity a reference names. A reference to one nothing declares is refused. */
+    entity(name) {
+        const e = this.entities.get(name);
+        if (!e)
+            this.malformed(`A reference to entity "${name}", which nothing declares`);
+        return e;
+    }
+    /** Starts expanding an entity, within the limits. */
+    enter(name, text) {
+        if (this.active.includes(name))
+            this.malformed(`Entity "${name}" refers to itself`);
+        if (this.active.length >= this.limits.entityDepth)
+            this.stop(types_1.OfficeDetail.XmlEntityDepth, `Entity references nest deeper than ${this.limits.entityDepth}`);
+        this.charge(text.length);
+        this.active.push(name);
+    }
+    /**
+     * Counts one expansion of `size` characters of declared text, an entity's or an attribute default's, against the
+     * limits, so a document type cannot make the part cost more than they allow.
+     */
+    charge(size) {
+        this.budget.expansions += 1;
+        if (this.budget.expansions > this.limits.entityExpansions)
+            this.stop(types_1.OfficeDetail.XmlEntityExpansions, `More than ${this.limits.entityExpansions} entities and attribute defaults expanded`);
+        this.budget.size += size;
+        if (this.budget.size > this.limits.entitySize)
+            this.stop(types_1.OfficeDetail.XmlEntitySize, `More than ${this.limits.entitySize} characters of entity text and attribute defaults expanded`);
+    }
+    /** A reference to a general entity in content. Its text is read as content, in place of the reference. */
+    contentReference(name, start, end) {
+        if (!this.stack.length)
+            this.malformed('An entity reference outside the root element');
+        const e = this.entity(name);
+        const span = this.span ?? [start, end];
+        if (!('text' in e)) {
+            if (e.notation !== undefined)
+                this.malformed(`A reference to entity "${name}", whose data is not XML`);
+            this.notes.externalEntity?.({ name, ...(e.publicId === undefined ? {} : { publicId: e.publicId }), systemId: e.systemId, start: span[0], end: span[1] });
+            this.characters(exports.UNKNOWN + name + exports.UNKNOWN);
+            return;
+        }
+        this.enter(name, e.text);
+        const { buf, pos, base, floor, span: outer } = this;
+        this.buf = e.text;
+        this.pos = 0;
+        this.base = 0;
+        this.floor = this.stack.length;
+        this.span = span;
+        this.loop(true);
+        if (this.stack.length !== this.floor)
+            this.malformed(`The text of entity "${name}" leaves <${this.stack[this.stack.length - 1].el.qname}> open`);
+        this.buf = buf;
+        this.pos = pos;
+        this.base = base;
+        this.floor = floor;
+        this.span = outer;
+        this.active.pop();
+    }
+    /** A reference to a general entity in an attribute value. Its text is normalized into the value. */
+    attributeReference(name) {
+        const e = this.entity(name);
+        if (!('text' in e))
+            this.malformed(`A reference to external entity "${name}" in an attribute value`);
+        this.enter(name, e.text);
+        const value = this.attributeValue(e.text, true);
+        this.active.pop();
+        return value;
+    }
+    /** Reads one markup token at pos. Returns false when the buffer does not yet hold all of it. */
+    markup(final) {
+        const b = this.buf;
+        const p = this.pos;
+        // Enough to tell every kind of markup apart: "<!NOTATION" is the longest opening.
+        if (b.length - p < 10 && !final)
+            return false;
+        let close;
+        if (b.startsWith('<?', p)) {
+            close = b.indexOf('?>', p + 2);
+            if (close < 0)
+                return this.wait(final);
+            this.instruction(b.slice(p + 2, close));
+            return this.advance(close + 2);
+        }
+        if (b.startsWith('<!--', p)) {
+            close = b.indexOf('-->', p + 4);
+            if (close < 0)
+                return this.wait(final);
+            this.checkChars(b, p + 4, close);
+            return this.advance(close + 3);
+        }
+        if (b.startsWith('<![CDATA[', p)) {
+            close = b.indexOf(']]>', p + 9);
+            if (close < 0)
+                return this.wait(final);
+            if (!this.stack.length)
+                this.malformed('A CDATA section outside the root element');
+            const raw = b.slice(p + 9, close);
+            this.checkChars(raw, 0, raw.length);
+            const t = this.span ? raw : raw.replace(/\r\n?/g, '\n');
+            if (t.length)
+                this.handler.text?.(t);
+            this.lastCr = false;
+            return this.advance(close + 3);
+        }
+        if (this.vml && b.startsWith('<![', p)) {
+            close = b.indexOf(']>', p + 3);
+            if (close < 0)
+                return this.wait(final);
+            const marker = b.slice(p + 3, close);
+            if (!/^(if\s|endif$)/.test(marker))
+                this.malformed('An unknown <![ marker');
+            this.checkChars(marker, 0, marker.length);
+            return this.advance(close + 2);
+        }
+        if (b.startsWith('<!DOCTYPE', p)) {
+            if (this.rootSeen || this.doctypeSeen)
+                this.malformed('A document type declaration after the root element, or a second one');
+            close = this.scanDoctype(b, p);
+            if (close < 0)
+                return this.wait(final);
+            this.doctype(b.slice(p, close), this.at(p), this.at(close));
+            return this.advance(close);
+        }
+        if (b.startsWith('<!', p)) {
+            if (/^<!(ENTITY|ELEMENT|ATTLIST|NOTATION)/.test(b.slice(p, p + 10)))
+                this.malformed('A markup declaration outside the document type declaration');
+            this.malformed('An unknown <! declaration');
+        }
+        if (b.startsWith('</', p)) {
+            close = b.indexOf('>', p + 2);
+            if (close < 0)
+                return this.wait(final);
+            this.endTag(b.slice(p + 2, close), this.at(p), this.at(close + 1, true));
+            return this.advance(close + 1);
+        }
+        // A start tag ends at the first ">" outside a quoted value.
+        let i = p + 1;
+        for (;;) {
+            if (i >= b.length)
+                return this.wait(final);
+            const c = b.charCodeAt(i);
+            if (c === 0x22 || c === 0x27) {
+                const q = b.indexOf(c === 0x22 ? '"' : "'", i + 1);
+                if (q < 0)
+                    return this.wait(final);
+                i = q + 1;
+                continue;
+            }
+            if (c === 0x3e)
+                break;
+            if (c === 0x3c)
+                this.malformed('"<" inside a tag');
+            i++;
+        }
+        this.startTag(b.slice(p + 1, i), this.at(p), this.at(i + 1, true));
+        return this.advance(i + 1);
+    }
+    wait(final) {
+        if (final)
+            this.malformed(this.span ? 'Entity text ends inside markup' : 'The part ends inside markup');
+        if (this.buf.length - this.pos > this.limits.tokenSize)
+            this.stop(types_1.OfficeDetail.XmlTokenSize, `A token is longer than ${this.limits.tokenSize} characters`);
+        return false;
+    }
+    advance(to) {
+        if (to - this.pos > this.limits.tokenSize)
+            this.stop(types_1.OfficeDetail.XmlTokenSize, `A token is longer than ${this.limits.tokenSize} characters`);
+        this.pos = to;
+        this.lastCr = false;
+        return true;
+    }
+    checkChars(s, from, to) {
+        for (let i = from; i < to; i++) {
+            const c = s.charCodeAt(i);
+            if (!isXmlChar(c))
+                this.malformed(`Character U+${c.toString(16).padStart(4, '0')} is not allowed in XML`);
+        }
+    }
+    instruction(body) {
+        this.checkChars(body, 0, body.length);
+        const space = body.search(/\s/);
+        const target = space < 0 ? body : body.slice(0, space);
+        if (target.toLowerCase() === 'xml') {
+            if (this.span || this.base + this.pos !== 0)
+                this.malformed('An XML declaration that is not at the start');
+            this.declaration(body);
+            return;
+        }
+        if (!(0, exports.isNcName)(target))
+            this.malformed('A processing instruction without a valid target');
+    }
+    /**
+     * Finds the end of the document type declaration at p: the ">" outside its literals and its internal subset, where
+     * comments, processing instructions and declarations may hold either. Returns the offset after it, or -1 when buf
+     * does not hold all of it yet. The scan goes on from where it stopped.
+     */
+    scanDoctype(b, p) {
+        const s = this.scan ?? { at: 9, mode: 'outside', quote: '' };
+        this.scan = s;
+        let i = p + s.at;
+        for (; i < b.length; i++) {
+            const c = b[i];
+            if (s.quote) {
+                if (c === s.quote)
+                    s.quote = '';
+            }
+            else if (s.mode === 'outside' || s.mode === 'declaration') {
+                if (c === '"' || c === "'")
+                    s.quote = c;
+                else if (c === '[' && s.mode === 'outside')
+                    s.mode = 'subset';
+                else if (c === '>' && s.mode === 'declaration')
+                    s.mode = 'subset';
+                else if (c === '>') {
+                    this.scan = undefined;
+                    return i + 1;
+                }
+            }
+            else if (s.mode === 'subset') {
+                if (c === ']')
+                    s.mode = 'outside';
+                else if (c === '<') {
+                    // Nothing whole is that short, and "<!--" may not have arrived whole yet.
+                    if (b.length - i < 4)
+                        break;
+                    if (b.startsWith('<!--', i)) {
+                        s.mode = 'comment';
+                        i += 3;
+                    }
+                    else if (b[i + 1] === '?') {
+                        s.mode = 'instruction';
+                        i += 1;
+                    }
+                    else
+                        s.mode = 'declaration';
+                }
+            }
+            else {
+                const end = s.mode === 'comment' ? '-->' : '?>';
+                if (c === end[0]) {
+                    if (b.length - i < end.length)
+                        break;
+                    if (b.startsWith(end, i)) {
+                        s.mode = 'subset';
+                        i += end.length - 1;
+                    }
+                }
+            }
+        }
+        s.at = i - p;
+        return -1;
+    }
+    /** Reads a whole document type declaration, keeping the entities and attributes its internal subset declares. */
+    doctype(token, start, end) {
+        this.checkChars(token, 0, token.length);
+        const r = new Cursor(token, 9, false, m => this.malformed(m));
+        r.needSpace('after <!DOCTYPE');
+        const name = r.name();
+        if (!isQName(name))
+            this.malformed(`"${name.slice(0, 40)}" is not a valid name`);
+        const id = r.space() ? this.externalId(r) : undefined;
+        if (id)
+            r.space();
+        const s = { unread: false, entities: 0, externalEntities: 0, attributeDefaults: 0, skipped: 0 };
+        const internalSubset = r.skip('[');
+        if (internalSubset) {
+            this.declarations(r, s, false);
+            r.space();
+        }
+        // The scan ended the token at a ">", so it is the last character.
+        if (r.i !== token.length - 1)
+            this.malformed('The document type declaration does not end where it should');
+        this.doctypeSeen = true;
+        const { entities, externalEntities, attributeDefaults, skipped } = s;
+        this.notes.doctype?.({ name, ...id, internalSubset, entities, externalEntities, attributeDefaults, skipped, start, end });
+    }
+    /** SYSTEM and a system literal, or PUBLIC and a public and a system literal, or undefined when neither is next. */
+    externalId(r) {
+        if (r.skip('SYSTEM')) {
+            r.needSpace('after SYSTEM');
+            return { systemId: r.literal('A system identifier') };
+        }
+        if (!r.skip('PUBLIC'))
+            return undefined;
+        r.needSpace('after PUBLIC');
+        const publicId = r.literal('A public identifier');
+        if (!PUBID.test(publicId))
+            this.malformed('A public identifier holds a character it may not');
+        r.needSpace('after the public identifier');
+        return { publicId, systemId: r.literal('A system identifier') };
+    }
+    /**
+     * Reads markup declarations: the internal subset up to and past its "]", or with `nested` the whole text of a
+     * parameter entity.
+     */
+    declarations(r, s, nested) {
+        for (;;) {
+            r.space();
+            if (nested && r.i === r.s.length)
+                return;
+            if (!nested && r.skip(']'))
+                return;
+            if (r.skip('<!--')) {
+                const close = r.s.indexOf('-->', r.i);
+                if (close < 0)
+                    this.malformed('A comment in the internal subset does not end');
+                r.i = close + 3;
+            }
+            else if (r.skip('<?')) {
+                const close = r.s.indexOf('?>', r.i);
+                if (close < 0)
+                    this.malformed('A processing instruction in the internal subset does not end');
+                const target = r.s.slice(r.i, close).split(/\s/, 1)[0];
+                if (!(0, exports.isNcName)(target) || target.toLowerCase() === 'xml')
+                    this.malformed('A processing instruction without a valid target');
+                r.i = close + 2;
+            }
+            else if (r.skip('<!ENTITY'))
+                this.entityDeclaration(r, s);
+            else if (r.skip('<!ATTLIST'))
+                this.attributeListDeclaration(r, s);
+            else if (r.skip('<!ELEMENT') || r.skip('<!NOTATION')) {
+                r.needSpace('after the declaration keyword');
+                r.declarationEnd();
+            }
+            else if (r.skip('%'))
+                this.parameterReference(r, s);
+            else if (r.skip('<!['))
+                this.malformed('A conditional section, which only an external subset may hold');
+            else
+                this.malformed('An unknown declaration in the internal subset');
+        }
+    }
+    /**
+     * A parameter entity reference between declarations. An internal entity's text is read as declarations, with a
+     * space on each side as XML 1.0 (4.4.8) says. An external or undeclared one is not read, and the entity and
+     * attribute-list declarations after it are skipped, since it could have declared the same names first.
+     */
+    parameterReference(r, s) {
+        const name = r.name();
+        if (!(0, exports.isNcName)(name) || !r.skip(';'))
+            this.malformed('A malformed parameter entity reference');
+        const e = this.parameters.get(name);
+        if (!e || !('text' in e)) {
+            if (!this.standalone)
+                s.unread = true;
+            return;
+        }
+        this.enter(`%${name}`, e.text);
+        this.declarations(new Cursor(` ${e.text} `, 0, true, m => this.malformed(m)), s, true);
+        this.active.pop();
+    }
+    /**
+     * Reads an entity declaration after its keyword, and keeps the entity unless it comes after a parameter entity that
+     * was not read, or gives one of the predefined names, or a name already declared: the first declaration binds.
+     */
+    entityDeclaration(r, s) {
+        r.needSpace('after <!ENTITY');
+        const parameter = r.skip('%');
+        if (parameter)
+            r.needSpace('after %');
+        const name = r.name();
+        if (!(0, exports.isNcName)(name))
+            this.malformed(`"${name.slice(0, 40)}" is not a valid entity name`);
+        r.needSpace('after the entity name');
+        let entity;
+        const q = r.s[r.i];
+        if (q === '"' || q === "'")
+            entity = { text: this.entityValue(r.literal('An entity value'), r.normalized) };
+        else {
+            const id = this.externalId(r);
+            if (!id)
+                this.malformed('An entity declaration with neither a value nor an external identifier');
+            entity = id;
+            if (!parameter && r.space() && r.skip('NDATA')) {
+                r.needSpace('after NDATA');
+                const notation = r.name();
+                if (!(0, exports.isNcName)(notation))
+                    this.malformed('NDATA without a notation name');
+                entity = { ...id, notation };
+            }
+        }
+        r.space();
+        if (!r.skip('>'))
+            this.malformed('An entity declaration does not end where it should');
+        if (s.unread) {
+            s.skipped++;
+            return;
+        }
+        const map = parameter ? this.parameters : this.entities;
+        if (map.has(name) || (!parameter && Object.hasOwn(PREDEFINED, name)))
+            return;
+        map.set(name, entity);
+        if (parameter)
+            return;
+        s.entities++;
+        if (!('text' in entity))
+            s.externalEntities++;
+    }
+    /**
+     * The text an entity value expands to: line ends normalized, unless `normalized` says they were, and character
+     * references replaced. References to general entities stay as written, to be expanded where the entity is used. A
+     * parameter entity reference cannot stand inside a declaration in the internal subset.
+     */
+    entityValue(raw, normalized) {
+        let out = '';
+        let from = 0;
+        for (let i = 0; i < raw.length; i++) {
+            const c = raw.charCodeAt(i);
+            if (c === 0x25)
+                this.malformed('A parameter entity reference inside a declaration');
+            else if (c === 0x26) {
+                const semi = raw.indexOf(';', i);
+                if (semi < 0)
+                    this.malformed('An unterminated reference');
+                const name = raw.slice(i + 1, semi);
+                if (name.startsWith('#')) {
+                    out += raw.slice(from, i) + this.characterReference(name);
+                    from = semi + 1;
+                }
+                else if (!(0, exports.isNcName)(name))
+                    this.malformed('A malformed reference');
+                i = semi;
+            }
+            else if (c === 0x0d && !normalized) {
+                out += `${raw.slice(from, i)}\n`;
+                if (raw.charCodeAt(i + 1) === 0x0a)
+                    i++;
+                from = i + 1;
+            }
+        }
+        return out + raw.slice(from);
+    }
+    /**
+     * Reads an attribute-list declaration after its keyword. Each attribute it names for the first time is kept, with
+     * its default normalized now, as the entities declared so far give it. After a parameter entity that was not read,
+     * the declaration is skipped.
+     */
+    attributeListDeclaration(r, s) {
+        r.needSpace('after <!ATTLIST');
+        const element = r.name();
+        if (!isQName(element))
+            this.malformed(`"${element.slice(0, 40)}" is not a valid name`);
+        const defs = [];
+        for (;;) {
+            const spaced = r.space();
+            if (r.skip('>'))
+                break;
+            if (!spaced)
+                this.malformed('No white space before an attribute definition');
+            const name = r.name();
+            if (!isQName(name))
+                this.malformed(`"${name.slice(0, 40)}" is not a valid name`);
+            r.needSpace('after the attribute name');
+            const tokenized = this.attributeType(r);
+            r.needSpace('after the attribute type');
+            let raw;
+            if (!r.skip('#REQUIRED') && !r.skip('#IMPLIED')) {
+                if (r.skip('#FIXED'))
+                    r.needSpace('after #FIXED');
+                raw = r.literal('A default value');
+                if (raw.includes('<'))
+                    this.malformed('"<" in an attribute value');
+            }
+            defs.push([name, tokenized, raw]);
+        }
+        if (s.unread) {
+            s.skipped++;
+            return;
+        }
+        let declared = this.declared.get(element);
+        if (!declared) {
+            declared = { names: new Set(), tokenized: new Set(), defaults: [] };
+            this.declared.set(element, declared);
+        }
+        for (const [name, tokenized, raw] of defs) {
+            const value = raw === undefined ? undefined : this.attributeValue(raw, r.normalized);
+            if (declared.names.has(name))
+                continue;
+            declared.names.add(name);
+            if (tokenized)
+                declared.tokenized.add(name);
+            if (value === undefined)
+                continue;
+            declared.defaults.push([name, tokenized ? tokenize(value) : value]);
+            s.attributeDefaults++;
+        }
+    }
+    /** Reads an attribute type and tells whether its values are tokens, normalized further than CDATA. */
+    attributeType(r) {
+        if (r.s[r.i] === '(') {
+            this.enumeration(r);
+            return true;
+        }
+        const type = r.name();
+        if (type === 'CDATA')
+            return false;
+        if (type === 'NOTATION') {
+            r.needSpace('after NOTATION');
+            this.enumeration(r);
+        }
+        else if (!TOKENIZED_TYPES.has(type))
+            this.malformed(`"${type.slice(0, 40)}" is not an attribute type`);
+        return true;
+    }
+    /** An enumerated type: name tokens between parentheses, separated by "|". */
+    enumeration(r) {
+        if (!r.skip('('))
+            this.malformed('An enumerated attribute type does not start with "("');
+        for (;;) {
+            r.space();
+            const from = r.i;
+            while (r.i < r.s.length && !/[\s|()>]/.test(r.s[r.i]))
+                r.i++;
+            if (!NMTOKEN.test(r.s.slice(from, r.i)))
+                this.malformed('An enumerated attribute type holds something other than a name token');
+            r.space();
+            if (r.skip(')'))
+                return;
+            if (!r.skip('|'))
+                this.malformed('An enumerated attribute type does not end with ")"');
+        }
+    }
+    lookup(prefix) {
+        if (prefix === 'xml')
+            return exports.XML_NS;
+        for (let i = this.stack.length - 1; i >= 0; i--) {
+            const v = this.stack[i].scope?.get(prefix);
+            if (v !== undefined)
+                return v;
+        }
+        return prefix === '' ? '' : undefined;
+    }
+    split(qname) {
+        const colon = qname.indexOf(':');
+        if (colon < 0) {
+            if (!(0, exports.isNcName)(qname))
+                this.malformed(`"${qname.slice(0, 40)}" is not a valid name`);
+            return ['', qname];
+        }
+        const prefix = qname.slice(0, colon);
+        const local = qname.slice(colon + 1);
+        if (!(0, exports.isNcName)(prefix) || !(0, exports.isNcName)(local))
+            this.malformed(`"${qname.slice(0, 40)}" is not a valid name`);
+        return [prefix, local];
+    }
+    startTag(body, start, end) {
+        if (this.rootSeen && !this.stack.length)
+            this.malformed('A second root element');
+        let i = 0;
+        const n = body.length;
+        while (i < n && !isSpace(body.charCodeAt(i)) && body[i] !== '/')
+            i++;
+        const qname = body.slice(0, i);
+        const raw = [];
+        let selfClosing = this.vml && qname.toLowerCase() === 'br';
+        for (;;) {
+            const before = i;
+            while (i < n && isSpace(body.charCodeAt(i)))
+                i++;
+            if (i >= n)
+                break;
+            if (body[i] === '/') {
+                if (i !== n - 1)
+                    this.malformed('"/" inside a tag');
+                selfClosing = true;
+                break;
+            }
+            if (i === before)
+                this.malformed('Attributes without white space between them');
+            const nameStart = i;
+            while (i < n && !isSpace(body.charCodeAt(i)) && body[i] !== '=')
+                i++;
+            const name = body.slice(nameStart, i);
+            while (i < n && isSpace(body.charCodeAt(i)))
+                i++;
+            if (body[i] !== '=')
+                this.malformed(`Attribute ${name.slice(0, 40)} has no value`);
+            i++;
+            while (i < n && isSpace(body.charCodeAt(i)))
+                i++;
+            const quote = body[i];
+            if (quote !== '"' && quote !== "'")
+                this.malformed(`Attribute ${name.slice(0, 40)} has an unquoted value`);
+            // markup() ended the tag at the first ">" outside quotes, so the value closes inside the tag.
+            const close = body.indexOf(quote, i + 1);
+            raw.push([name, this.attributeValue(body.slice(i + 1, close), this.span !== undefined)]);
+            i = close + 1;
+        }
+        // Attribute-list declarations normalize the attributes they type, and add the defaults the tag leaves out. Each
+        // default added counts against the entity limits, so declarations cannot multiply the work of a long part.
+        const declared = this.declared.get(qname);
+        if (declared) {
+            const given = new Set();
+            for (const a of raw) {
+                given.add(a[0]);
+                if (declared.tokenized.has(a[0]))
+                    a[1] = tokenize(a[1]);
+            }
+            for (const [name, value] of declared.defaults) {
+                if (given.has(name))
+                    continue;
+                this.charge(value.length);
+                raw.push([name, value]);
+            }
+        }
+        const scope = new Map();
+        const plain = [];
+        const qnames = new Set();
+        for (const [name, value] of raw) {
+            if (qnames.has(name))
+                this.malformed(`Attribute ${name.slice(0, 40)} appears twice`);
+            qnames.add(name);
+            if (name === 'xmlns') {
+                if (value === exports.XML_NS || value === exports.XMLNS_NS)
+                    this.malformed('The default namespace bound to a reserved namespace');
+                scope.set('', value);
+            }
+            else if (name.startsWith('xmlns:')) {
+                const prefix = name.slice(6);
+                if (!(0, exports.isNcName)(prefix))
+                    this.malformed(`"${name.slice(0, 40)}" is not a valid namespace declaration`);
+                if (prefix === 'xmlns')
+                    this.malformed('The xmlns prefix declared');
+                if (value === '')
+                    this.malformed(`Prefix ${prefix} bound to no namespace`);
+                if ((prefix === 'xml') !== (value === exports.XML_NS) || value === exports.XMLNS_NS)
+                    this.malformed(`Prefix ${prefix} bound to a reserved namespace`);
+                scope.set(prefix, value);
+            }
+            else
+                plain.push([name, value]);
+        }
+        const depth = this.stack.length + 1;
+        if (depth > this.limits.depth)
+            this.stop(types_1.OfficeDetail.XmlDepth, `Elements nest deeper than ${this.limits.depth}`);
+        const el = { ns: '', local: '', qname, attributes: [], depth, start, end };
+        const open = { el, scope: scope.size ? scope : undefined };
+        this.stack.push(open);
+        const [prefix, local] = this.split(qname);
+        const ns = this.lookup(prefix);
+        if (ns === undefined)
+            this.malformed(`Prefix ${prefix} is not declared`);
+        el.ns = ns;
+        el.local = local;
+        const expanded = new Set();
+        for (const [name, value] of plain) {
+            const [p, l] = this.split(name);
+            const ans = p === '' ? '' : this.lookup(p);
+            if (ans === undefined)
+                this.malformed(`Prefix ${p} is not declared`);
+            const key = `${ans} ${l}`;
+            if (expanded.has(key))
+                this.malformed(`Attribute ${l} appears twice in one namespace`);
+            expanded.add(key);
+            el.attributes.push({ ns: ans, local: l, qname: name, value });
+        }
+        this.rootSeen = true;
+        this.handler.start?.(el);
+        if (selfClosing) {
+            this.stack.pop();
+            this.handler.end?.(el, start, end);
+        }
+    }
+    endTag(body, start, end) {
+        let n = body.length;
+        while (n > 0 && isSpace(body.charCodeAt(n - 1)))
+            n--;
+        const qname = body.slice(0, n);
+        const top = this.stack.length > this.floor ? this.stack.pop() : undefined;
+        if (!top)
+            this.malformed(this.floor ? `</${qname.slice(0, 40)}> closes an element from outside the entity text it stands in` : `</${qname.slice(0, 40)}> closes nothing`);
+        if (top.el.qname !== qname)
+            this.malformed(`</${qname.slice(0, 40)}> closes <${top.el.qname.slice(0, 40)}>`);
+        this.handler.end?.(top.el, start, end);
+    }
+}
+exports.XmlTokenizer = XmlTokenizer;