A team of long-lived bots for DeepSeek Harness, with main bots, bot-to-bot messages and group chats.
Fix stable Word batch references and paragraph-end replacements
Fei241149c528fc5f49
diff --cc ds-bot/office.jsindex 84991b56,00000000..ada743e1mode 100644,000000..100644--- a/ds-bot/office.js+++ b/ds-bot/office.js@@@ -1,8881 -1,0 +1,8889 @@@+#!/usr/bin/env node+// Generated from src/office by `npm run build` (scripts/build-client.mjs). Do not edit by hand.+var __create = Object.create;+var __defProp = Object.defineProperty;+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;+var __getOwnPropNames = Object.getOwnPropertyNames;+var __getProtoOf = Object.getPrototypeOf;+var __hasOwnProp = Object.prototype.hasOwnProperty;+var __commonJS = (cb, mod) => function __require() {+ try {+ return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;+ } catch (e) {+ throw mod = 0, e;+ }+};+var __export = (target, all) => {+ for (var name in all)+ __defProp(target, name, { get: all[name], enumerable: true });+};+var __copyProps = (to, from, except, desc) => {+ if (from && typeof from === "object" || typeof from === "function") {+ for (let key of __getOwnPropNames(from))+ if (!__hasOwnProp.call(to, key) && key !== except)+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });+ }+ return to;+};+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(+ // If the importer is in node compatibility mode or this is not an ESM+ // file that has been converted to a CommonJS file using a Babel-+ // compatible transform (i.e. "__esModule" has not been set), then set+ // "default" to the CommonJS "module.exports" for node compatibility.+ isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,+ mod+));++// node_modules/@xmldom/xmldom/lib/conventions.js+var require_conventions = __commonJS({+ "node_modules/@xmldom/xmldom/lib/conventions.js"(exports) {+ "use strict";+ function find(list, predicate, ac) {+ if (ac === void 0) {+ ac = Array.prototype;+ }+ if (list && typeof ac.find === "function") {+ return ac.find.call(list, predicate);+ }+ for (var i = 0; i < list.length; i++) {+ if (hasOwn(list, i)) {+ var item = list[i];+ if (predicate.call(void 0, item, i, list)) {+ return item;+ }+ }+ }+ }+ function freeze(object, oc) {+ if (oc === void 0) {+ oc = Object;+ }+ if (oc && typeof oc.getOwnPropertyDescriptors === "function") {+ object = oc.create(null, oc.getOwnPropertyDescriptors(object));+ }+ return oc && typeof oc.freeze === "function" ? oc.freeze(object) : object;+ }+ function hasOwn(object, key) {+ return Object.prototype.hasOwnProperty.call(object, key);+ }+ function assign(target, source) {+ if (target === null || typeof target !== "object") {+ throw new TypeError("target is not an object");+ }+ for (var key in source) {+ if (hasOwn(source, key)) {+ target[key] = source[key];+ }+ }+ return target;+ }+ var HTML_BOOLEAN_ATTRIBUTES = freeze({+ allowfullscreen: true,+ async: true,+ autofocus: true,+ autoplay: true,+ checked: true,+ controls: true,+ default: true,+ defer: true,+ disabled: true,+ formnovalidate: true,+ hidden: true,+ ismap: true,+ itemscope: true,+ loop: true,+ multiple: true,+ muted: true,+ nomodule: true,+ novalidate: true,+ open: true,+ playsinline: true,+ readonly: true,+ required: true,+ reversed: true,+ selected: true+ });+ function isHTMLBooleanAttribute(name) {+ return hasOwn(HTML_BOOLEAN_ATTRIBUTES, name.toLowerCase());+ }+ var HTML_VOID_ELEMENTS = freeze({+ area: true,+ base: true,+ br: true,+ col: true,+ embed: true,+ hr: true,+ img: true,+ input: true,+ link: true,+ meta: true,+ param: true,+ source: true,+ track: true,+ wbr: true+ });+ function isHTMLVoidElement(tagName) {+ return hasOwn(HTML_VOID_ELEMENTS, tagName.toLowerCase());+ }+ var HTML_RAW_TEXT_ELEMENTS = freeze({+ script: false,+ style: false,+ textarea: true,+ title: true+ });+ function isHTMLRawTextElement(tagName) {+ var key = tagName.toLowerCase();+ return hasOwn(HTML_RAW_TEXT_ELEMENTS, key) && !HTML_RAW_TEXT_ELEMENTS[key];+ }+ function isHTMLEscapableRawTextElement(tagName) {+ var key = tagName.toLowerCase();+ return hasOwn(HTML_RAW_TEXT_ELEMENTS, key) && HTML_RAW_TEXT_ELEMENTS[key];+ }+ function isHTMLMimeType(mimeType) {+ return mimeType === MIME_TYPE.HTML;+ }+ function hasDefaultHTMLNamespace(mimeType) {+ return isHTMLMimeType(mimeType) || mimeType === MIME_TYPE.XML_XHTML_APPLICATION;+ }+ var MIME_TYPE = freeze({+ /**+ * `text/html`, the only mime type that triggers treating an XML document as HTML.+ *+ * @see https://www.iana.org/assignments/media-types/text/html IANA MimeType registration+ * @see https://en.wikipedia.org/wiki/HTML Wikipedia+ * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMParser/parseFromString MDN+ * @see https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#dom-domparser-parsefromstring+ * WHATWG HTML Spec+ */+ HTML: "text/html",+ /**+ * `application/xml`, the standard mime type for XML documents.+ *+ * @see https://www.iana.org/assignments/media-types/application/xml IANA MimeType+ * registration+ * @see https://tools.ietf.org/html/rfc7303#section-9.1 RFC 7303+ * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia+ */+ XML_APPLICATION: "application/xml",+ /**+ * `text/xml`, an alias for `application/xml`.+ *+ * @see https://tools.ietf.org/html/rfc7303#section-9.2 RFC 7303+ * @see https://www.iana.org/assignments/media-types/text/xml IANA MimeType registration+ * @see https://en.wikipedia.org/wiki/XML_and_MIME Wikipedia+ */+ XML_TEXT: "text/xml",+ /**+ * `application/xhtml+xml`, indicates an XML document that has the default HTML namespace,+ * but is parsed as an XML document.+ *+ * @see https://www.iana.org/assignments/media-types/application/xhtml+xml IANA MimeType+ * registration+ * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument WHATWG DOM Spec+ * @see https://en.wikipedia.org/wiki/XHTML Wikipedia+ */+ XML_XHTML_APPLICATION: "application/xhtml+xml",+ /**+ * `image/svg+xml`,+ *+ * @see https://www.iana.org/assignments/media-types/image/svg+xml IANA MimeType registration+ * @see https://www.w3.org/TR/SVG11/ W3C SVG 1.1+ * @see https://en.wikipedia.org/wiki/Scalable_Vector_Graphics Wikipedia+ */+ XML_SVG_IMAGE: "image/svg+xml"+ });+ var _MIME_TYPES = Object.keys(MIME_TYPE).map(function(key) {+ return MIME_TYPE[key];+ });+ function isValidMimeType(mimeType) {+ return _MIME_TYPES.indexOf(mimeType) > -1;+ }+ var NAMESPACE = freeze({+ /**+ * The XHTML namespace.+ *+ * @see http://www.w3.org/1999/xhtml+ */+ HTML: "http://www.w3.org/1999/xhtml",+ /**+ * The SVG namespace.+ *+ * @see http://www.w3.org/2000/svg+ */+ SVG: "http://www.w3.org/2000/svg",+ /**+ * The `xml:` namespace.+ *+ * @see http://www.w3.org/XML/1998/namespace+ */+ XML: "http://www.w3.org/XML/1998/namespace",+ /**+ * The `xmlns:` namespace.+ *+ * @see https://www.w3.org/2000/xmlns/+ */+ XMLNS: "http://www.w3.org/2000/xmlns/"+ });+ exports.assign = assign;+ exports.find = find;+ exports.freeze = freeze;+ exports.HTML_BOOLEAN_ATTRIBUTES = HTML_BOOLEAN_ATTRIBUTES;+ exports.HTML_RAW_TEXT_ELEMENTS = HTML_RAW_TEXT_ELEMENTS;+ exports.HTML_VOID_ELEMENTS = HTML_VOID_ELEMENTS;+ exports.hasDefaultHTMLNamespace = hasDefaultHTMLNamespace;+ exports.hasOwn = hasOwn;+ exports.isHTMLBooleanAttribute = isHTMLBooleanAttribute;+ exports.isHTMLRawTextElement = isHTMLRawTextElement;+ exports.isHTMLEscapableRawTextElement = isHTMLEscapableRawTextElement;+ exports.isHTMLMimeType = isHTMLMimeType;+ exports.isHTMLVoidElement = isHTMLVoidElement;+ exports.isValidMimeType = isValidMimeType;+ exports.MIME_TYPE = MIME_TYPE;+ exports.NAMESPACE = NAMESPACE;+ }+});++// node_modules/@xmldom/xmldom/lib/errors.js+var require_errors = __commonJS({+ "node_modules/@xmldom/xmldom/lib/errors.js"(exports) {+ "use strict";+ var conventions = require_conventions();+ function extendError(constructor, writableName) {+ constructor.prototype = Object.create(Error.prototype, {+ constructor: { value: constructor },+ name: { value: constructor.name, enumerable: true, writable: writableName }+ });+ }+ var DOMExceptionName = conventions.freeze({+ /**+ * the default value as defined by the spec+ */+ Error: "Error",+ /**+ * @deprecated+ * Use RangeError instead.+ */+ IndexSizeError: "IndexSizeError",+ /**+ * @deprecated+ * Just to match the related static code, not part of the spec.+ */+ DomstringSizeError: "DomstringSizeError",+ HierarchyRequestError: "HierarchyRequestError",+ WrongDocumentError: "WrongDocumentError",+ InvalidCharacterError: "InvalidCharacterError",+ /**+ * @deprecated+ * Just to match the related static code, not part of the spec.+ */+ NoDataAllowedError: "NoDataAllowedError",+ NoModificationAllowedError: "NoModificationAllowedError",+ NotFoundError: "NotFoundError",+ NotSupportedError: "NotSupportedError",+ InUseAttributeError: "InUseAttributeError",+ InvalidStateError: "InvalidStateError",+ SyntaxError: "SyntaxError",+ InvalidModificationError: "InvalidModificationError",+ NamespaceError: "NamespaceError",+ /**+ * @deprecated+ * Use TypeError for invalid arguments,+ * "NotSupportedError" DOMException for unsupported operations,+ * and "NotAllowedError" DOMException for denied requests instead.+ */+ InvalidAccessError: "InvalidAccessError",+ /**+ * @deprecated+ * Just to match the related static code, not part of the spec.+ */+ ValidationError: "ValidationError",+ /**+ * @deprecated+ * Use TypeError instead.+ */+ TypeMismatchError: "TypeMismatchError",+ SecurityError: "SecurityError",+ NetworkError: "NetworkError",+ AbortError: "AbortError",+ /**+ * @deprecated+ * Just to match the related static code, not part of the spec.+ */+ URLMismatchError: "URLMismatchError",+ QuotaExceededError: "QuotaExceededError",+ TimeoutError: "TimeoutError",+ InvalidNodeTypeError: "InvalidNodeTypeError",+ DataCloneError: "DataCloneError",+ EncodingError: "EncodingError",+ NotReadableError: "NotReadableError",+ UnknownError: "UnknownError",+ ConstraintError: "ConstraintError",+ DataError: "DataError",+ TransactionInactiveError: "TransactionInactiveError",+ ReadOnlyError: "ReadOnlyError",+ VersionError: "VersionError",+ OperationError: "OperationError",+ NotAllowedError: "NotAllowedError",+ OptOutError: "OptOutError"+ });+ var DOMExceptionNames = Object.keys(DOMExceptionName);+ function isValidDomExceptionCode(value) {+ return typeof value === "number" && value >= 1 && value <= 25;+ }+ function endsWithError(value) {+ return typeof value === "string" && value.substring(value.length - DOMExceptionName.Error.length) === DOMExceptionName.Error;+ }+ function DOMException(messageOrCode, nameOrMessage) {+ if (isValidDomExceptionCode(messageOrCode)) {+ this.name = DOMExceptionNames[messageOrCode];+ this.message = nameOrMessage || "";+ } else {+ this.message = messageOrCode;+ this.name = endsWithError(nameOrMessage) ? nameOrMessage : DOMExceptionName.Error;+ }+ if (Error.captureStackTrace) Error.captureStackTrace(this, DOMException);+ }+ extendError(DOMException, true);+ Object.defineProperties(DOMException.prototype, {+ code: {+ enumerable: true,+ get: function() {+ var code = DOMExceptionNames.indexOf(this.name);+ if (isValidDomExceptionCode(code)) return code;+ return 0;+ }+ }+ });+ var ExceptionCode = {+ INDEX_SIZE_ERR: 1,+ DOMSTRING_SIZE_ERR: 2,+ HIERARCHY_REQUEST_ERR: 3,+ WRONG_DOCUMENT_ERR: 4,+ INVALID_CHARACTER_ERR: 5,+ NO_DATA_ALLOWED_ERR: 6,+ NO_MODIFICATION_ALLOWED_ERR: 7,+ NOT_FOUND_ERR: 8,+ NOT_SUPPORTED_ERR: 9,+ INUSE_ATTRIBUTE_ERR: 10,+ INVALID_STATE_ERR: 11,+ SYNTAX_ERR: 12,+ INVALID_MODIFICATION_ERR: 13,+ NAMESPACE_ERR: 14,+ INVALID_ACCESS_ERR: 15,+ VALIDATION_ERR: 16,+ TYPE_MISMATCH_ERR: 17,+ SECURITY_ERR: 18,+ NETWORK_ERR: 19,+ ABORT_ERR: 20,+ URL_MISMATCH_ERR: 21,+ QUOTA_EXCEEDED_ERR: 22,+ TIMEOUT_ERR: 23,+ INVALID_NODE_TYPE_ERR: 24,+ DATA_CLONE_ERR: 25+ };+ var entries = Object.entries(ExceptionCode);+ for (i = 0; i < entries.length; i++) {+ key = entries[i][0];+ DOMException[key] = entries[i][1];+ }+ var key;+ var i;+ function ParseError(message, locator, cause) {+ this.message = message;+ this.locator = locator;+ this.cause = cause;+ if (Error.captureStackTrace) Error.captureStackTrace(this, ParseError);+ }+ extendError(ParseError);+ exports.DOMException = DOMException;+ exports.DOMExceptionName = DOMExceptionName;+ exports.ExceptionCode = ExceptionCode;+ exports.ParseError = ParseError;+ }+});++// node_modules/@xmldom/xmldom/lib/grammar.js+var require_grammar = __commonJS({+ "node_modules/@xmldom/xmldom/lib/grammar.js"(exports) {+ "use strict";+ function detectUnicodeSupport(RegExpImpl) {+ try {+ if (typeof RegExpImpl !== "function") {+ RegExpImpl = RegExp;+ }+ var match = new RegExpImpl("𝌆", "u").exec("𝌆");+ return !!match && match[0].length === 2;+ } catch (error) {+ }+ return false;+ }+ var UNICODE_SUPPORT = detectUnicodeSupport();+ function chars(regexp) {+ if (regexp.source[0] !== "[") {+ throw new Error(regexp + " can not be used with chars");+ }+ return regexp.source.slice(1, regexp.source.lastIndexOf("]"));+ }+ function chars_without(regexp, search) {+ if (regexp.source[0] !== "[") {+ throw new Error("/" + regexp.source + "/ can not be used with chars_without");+ }+ if (!search || typeof search !== "string") {+ throw new Error(JSON.stringify(search) + " is not a valid search");+ }+ if (regexp.source.indexOf(search) === -1) {+ throw new Error('"' + search + '" is not is /' + regexp.source + "/");+ }+ if (search === "-" && regexp.source.indexOf(search) !== 1) {+ throw new Error('"' + search + '" is not at the first postion of /' + regexp.source + "/");+ }+ return new RegExp(regexp.source.replace(search, ""), UNICODE_SUPPORT ? "u" : "");+ }+ function reg(args) {+ var self = this;+ return new RegExp(+ Array.prototype.slice.call(arguments).map(function(part) {+ var isStr = typeof part === "string";+ if (isStr && self === void 0 && part === "|") {+ throw new Error("use regg instead of reg to wrap expressions with `|`!");+ }+ return isStr ? part : part.source;+ }).join(""),+ UNICODE_SUPPORT ? "u" : ""+ );+ }+ function regg(args) {+ if (arguments.length === 0) {+ throw new Error("no parameters provided");+ }+ return reg.apply(regg, ["(?:"].concat(Array.prototype.slice.call(arguments), [")"]));+ }+ var UNICODE_REPLACEMENT_CHARACTER = "�";+ var Char = /[-\x09\x0A\x0D\x20-\x2C\x2E-\uD7FF\uE000-\uFFFD]/;+ if (UNICODE_SUPPORT) {+ Char = reg("[", chars(Char), "\\u{10000}-\\u{10FFFF}", "]");+ }+ var InvalidChar = new RegExp("[^" + chars(Char) + "]", UNICODE_SUPPORT ? "u" : "");+ var _SChar = /[\x20\x09\x0D\x0A]/;+ var SChar_s = chars(_SChar);+ var S = reg(_SChar, "+");+ var S_OPT = reg(_SChar, "*");+ var NameStartChar = /[:_a-zA-Z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;+ if (UNICODE_SUPPORT) {+ NameStartChar = reg("[", chars(NameStartChar), "\\u{10000}-\\u{10FFFF}", "]");+ }+ var NameStartChar_s = chars(NameStartChar);+ var NameChar = reg("[", NameStartChar_s, chars(/[-.0-9\xB7]/), chars(/[\u0300-\u036F\u203F-\u2040]/), "]");+ var Name = reg(NameStartChar, NameChar, "*");+ var Name_exact = reg("^", Name, "$");+ var Nmtoken = reg(NameChar, "+");+ var EntityRef = reg("&", Name, ";");+ var CharRef = regg(/&#[0-9]+;|&#x[0-9a-fA-F]+;/);+ var Reference = regg(EntityRef, "|", CharRef);+ var PEReference = reg("%", Name, ";");+ var EntityValue = regg(+ reg('"', regg(/[^%&"]/, "|", PEReference, "|", Reference), "*", '"'),+ "|",+ reg("'", regg(/[^%&']/, "|", PEReference, "|", Reference), "*", "'")+ );+ var AttValue = regg('"', regg(/[^<&"]/, "|", Reference), "*", '"', "|", "'", regg(/[^<&']/, "|", Reference), "*", "'");+ var NCNameStartChar = chars_without(NameStartChar, ":");+ var NCNameChar = chars_without(NameChar, ":");+ var NCName = reg(NCNameStartChar, NCNameChar, "*");+ var NCName_exact = reg("^", NCName, "$");+ var QName = reg(NCName, regg(":", NCName), "?");+ var QName_exact = reg("^", QName, "$");+ var QName_group = reg("(", QName, ")");+ var SystemLiteral = regg(/"[^"]*"|'[^']*'/);+ var PI = reg(/^<\?/, "(", Name, ")", regg(S, "(?!", _SChar, ")(", Char, "*?)"), "?", /\?>/);+ var PubidChar = /[\x20\x0D\x0Aa-zA-Z0-9-'()+,./:=?;!*#@$_%]/;+ var PubidLiteral = regg('"', PubidChar, '*"', "|", "'", chars_without(PubidChar, "'"), "*'");+ var COMMENT_START = "<!--";+ var COMMENT_END = "-->";+ var Comment = reg(COMMENT_START, regg(chars_without(Char, "-"), "|", reg("-", chars_without(Char, "-"))), "*", COMMENT_END);+ var PCDATA = "#PCDATA";+ var Mixed = regg(+ reg(/\(/, S_OPT, PCDATA, regg(S_OPT, /\|/, S_OPT, QName), "*", S_OPT, /\)\*/),+ "|",+ reg(/\(/, S_OPT, PCDATA, S_OPT, /\)/)+ );+ var _children_quantity = /[?*+]?/;+ var children = reg(+ /\([^>]+\)/,+ _children_quantity+ /*regg(choice, '|', seq), _children_quantity*/+ );+ var contentspec = regg("EMPTY", "|", "ANY", "|", Mixed, "|", children);+ var ELEMENTDECL_START = "<!ELEMENT";+ var elementdecl = reg(ELEMENTDECL_START, S, regg(QName, "|", PEReference), S, regg(contentspec, "|", PEReference), S_OPT, ">");+ var NotationType = reg("NOTATION", S, /\(/, S_OPT, Name, regg(S_OPT, /\|/, S_OPT, Name), "*", S_OPT, /\)/);+ var Enumeration = reg(/\(/, S_OPT, Nmtoken, regg(S_OPT, /\|/, S_OPT, Nmtoken), "*", S_OPT, /\)/);+ var EnumeratedType = regg(NotationType, "|", Enumeration);+ var AttType = regg(/CDATA|ID|IDREF|IDREFS|ENTITY|ENTITIES|NMTOKEN|NMTOKENS/, "|", EnumeratedType);+ var DefaultDecl = regg(/#REQUIRED|#IMPLIED/, "|", regg(regg("#FIXED", S), "?", AttValue));+ var AttDef = regg(S, Name, S, AttType, S, DefaultDecl);+ var ATTLIST_DECL_START = "<!ATTLIST";+ var AttlistDecl = reg(ATTLIST_DECL_START, S, Name, AttDef, "*", S_OPT, ">");+ var ABOUT_LEGACY_COMPAT = "about:legacy-compat";+ var ABOUT_LEGACY_COMPAT_SystemLiteral = regg('"' + ABOUT_LEGACY_COMPAT + '"', "|", "'" + ABOUT_LEGACY_COMPAT + "'");+ var SYSTEM = "SYSTEM";+ var PUBLIC = "PUBLIC";+ var ExternalID = regg(regg(SYSTEM, S, SystemLiteral), "|", regg(PUBLIC, S, PubidLiteral, S, SystemLiteral));+ var ExternalID_match = reg(+ "^",+ regg(+ regg(SYSTEM, S, "(?<SystemLiteralOnly>", SystemLiteral, ")"),+ "|",+ regg(PUBLIC, S, "(?<PubidLiteral>", PubidLiteral, ")", S, "(?<SystemLiteral>", SystemLiteral, ")")+ )+ );+ var PubidLiteral_match = reg("^", PubidLiteral, "$");+ var SystemLiteral_match = reg("^", SystemLiteral, "$");+ var NDataDecl = regg(S, "NDATA", S, Name);+ var EntityDef = regg(EntityValue, "|", regg(ExternalID, NDataDecl, "?"));+ var ENTITY_DECL_START = "<!ENTITY";+ var GEDecl = reg(ENTITY_DECL_START, S, Name, S, EntityDef, S_OPT, ">");+ var PEDef = regg(EntityValue, "|", ExternalID);+ var PEDecl = reg(ENTITY_DECL_START, S, "%", S, Name, S, PEDef, S_OPT, ">");+ var EntityDecl = regg(GEDecl, "|", PEDecl);+ var PublicID = reg(PUBLIC, S, PubidLiteral);+ var NotationDecl = reg("<!NOTATION", S, Name, S, regg(ExternalID, "|", PublicID), S_OPT, ">");+ var Eq = reg(S_OPT, "=", S_OPT);+ var VersionNum = /1[.]\d+/;+ var VersionInfo = reg(S, "version", Eq, regg("'", VersionNum, "'", "|", '"', VersionNum, '"'));+ var EncName = /[A-Za-z][-A-Za-z0-9._]*/;+ var EncodingDecl = regg(S, "encoding", Eq, regg('"', EncName, '"', "|", "'", EncName, "'"));+ var SDDecl = regg(S, "standalone", Eq, regg("'", regg("yes", "|", "no"), "'", "|", '"', regg("yes", "|", "no"), '"'));+ var XMLDecl = reg(/^<\?xml/, VersionInfo, EncodingDecl, "?", SDDecl, "?", S_OPT, /\?>/);+ var DOCTYPE_DECL_START = "<!DOCTYPE";+ var CDATA_START = "<![CDATA[";+ var CDATA_END = "]]>";+ var CDStart = /<!\[CDATA\[/;+ var CDEnd = /\]\]>/;+ var CData = reg(Char, "*?", CDEnd);+ var CDSect = reg(CDStart, CData);+ exports.chars = chars;+ exports.chars_without = chars_without;+ exports.detectUnicodeSupport = detectUnicodeSupport;+ exports.reg = reg;+ exports.regg = regg;+ exports.ABOUT_LEGACY_COMPAT = ABOUT_LEGACY_COMPAT;+ exports.ABOUT_LEGACY_COMPAT_SystemLiteral = ABOUT_LEGACY_COMPAT_SystemLiteral;+ exports.AttlistDecl = AttlistDecl;+ exports.CDATA_START = CDATA_START;+ exports.CDATA_END = CDATA_END;+ exports.CDSect = CDSect;+ exports.Char = Char;+ exports.Comment = Comment;+ exports.COMMENT_START = COMMENT_START;+ exports.COMMENT_END = COMMENT_END;+ exports.DOCTYPE_DECL_START = DOCTYPE_DECL_START;+ exports.elementdecl = elementdecl;+ exports.EntityDecl = EntityDecl;+ exports.EntityValue = EntityValue;+ exports.ExternalID = ExternalID;+ exports.ExternalID_match = ExternalID_match;+ exports.Name = Name;+ exports.Name_exact = Name_exact;+ exports.NCName_exact = NCName_exact;+ exports.NotationDecl = NotationDecl;+ exports.Reference = Reference;+ exports.PEReference = PEReference;+ exports.PI = PI;+ exports.PUBLIC = PUBLIC;+ exports.PubidLiteral = PubidLiteral;+ exports.PubidLiteral_match = PubidLiteral_match;+ exports.QName = QName;+ exports.QName_exact = QName_exact;+ exports.QName_group = QName_group;+ exports.S = S;+ exports.SChar_s = SChar_s;+ exports.S_OPT = S_OPT;+ exports.SYSTEM = SYSTEM;+ exports.SystemLiteral = SystemLiteral;+ exports.SystemLiteral_match = SystemLiteral_match;+ exports.InvalidChar = InvalidChar;+ exports.UNICODE_REPLACEMENT_CHARACTER = UNICODE_REPLACEMENT_CHARACTER;+ exports.UNICODE_SUPPORT = UNICODE_SUPPORT;+ exports.XMLDecl = XMLDecl;+ }+});++// node_modules/@xmldom/xmldom/lib/dom.js+var require_dom = __commonJS({+ "node_modules/@xmldom/xmldom/lib/dom.js"(exports) {+ "use strict";+ var conventions = require_conventions();+ var find = conventions.find;+ var hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;+ var hasOwn = conventions.hasOwn;+ var isHTMLMimeType = conventions.isHTMLMimeType;+ var isHTMLRawTextElement = conventions.isHTMLRawTextElement;+ var isHTMLVoidElement = conventions.isHTMLVoidElement;+ var MIME_TYPE = conventions.MIME_TYPE;+ var NAMESPACE = conventions.NAMESPACE;+ var PDC = /* @__PURE__ */ Symbol();+ var errors = require_errors();+ var DOMException = errors.DOMException;+ var DOMExceptionName = errors.DOMExceptionName;+ var g = require_grammar();+ function checkSymbol(symbol) {+ if (symbol !== PDC) {+ throw new TypeError("Illegal constructor");+ }+ }+ function notEmptyString(input) {+ return input !== "";+ }+ function splitOnASCIIWhitespace(input) {+ return input ? input.split(/[\t\n\f\r ]+/).filter(notEmptyString) : [];+ }+ function orderedSetReducer(current, element) {+ if (!hasOwn(current, element)) {+ current[element] = true;+ }+ return current;+ }+ function toOrderedSet(input) {+ if (!input) return [];+ var list = splitOnASCIIWhitespace(input);+ return Object.keys(list.reduce(orderedSetReducer, {}));+ }+ function arrayIncludes(list) {+ return function(element) {+ return list && list.indexOf(element) !== -1;+ };+ }+ function validateQualifiedName(qualifiedName) {+ if (!g.QName_exact.test(qualifiedName)) {+ throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'invalid character in qualified name "' + qualifiedName + '"');+ }+ }+ function validateAndExtract(namespace, qualifiedName) {+ validateQualifiedName(qualifiedName);+ namespace = namespace || null;+ var prefix = null;+ var localName = qualifiedName;+ if (qualifiedName.indexOf(":") >= 0) {+ var splitResult = qualifiedName.split(":");+ prefix = splitResult[0];+ localName = splitResult[1];+ }+ if (prefix !== null && namespace === null) {+ throw new DOMException(DOMException.NAMESPACE_ERR, "prefix is non-null and namespace is null");+ }+ if (prefix === "xml" && namespace !== conventions.NAMESPACE.XML) {+ throw new DOMException(DOMException.NAMESPACE_ERR, 'prefix is "xml" and namespace is not the XML namespace');+ }+ if ((prefix === "xmlns" || qualifiedName === "xmlns") && namespace !== conventions.NAMESPACE.XMLNS) {+ throw new DOMException(+ DOMException.NAMESPACE_ERR,+ 'either qualifiedName or prefix is "xmlns" and namespace is not the XMLNS namespace'+ );+ }+ if (namespace === conventions.NAMESPACE.XMLNS && prefix !== "xmlns" && qualifiedName !== "xmlns") {+ throw new DOMException(+ DOMException.NAMESPACE_ERR,+ 'namespace is the XMLNS namespace and neither qualifiedName nor prefix is "xmlns"'+ );+ }+ return [namespace, prefix, localName];+ }+ function copy(src, dest) {+ for (var p in src) {+ if (hasOwn(src, p)) {+ dest[p] = src[p];+ }+ }+ }+ function _extends(Class, Super) {+ var pt = Class.prototype;+ if (!(pt instanceof Super)) {+ let t = function() {+ };+ t.prototype = Super.prototype;+ t = new t();+ copy(pt, t);+ Class.prototype = pt = t;+ }+ if (pt.constructor != Class) {+ if (typeof Class != "function") {+ console.error("unknown Class:" + Class);+ }+ pt.constructor = Class;+ }+ }+ var NodeType = {};+ var ELEMENT_NODE = NodeType.ELEMENT_NODE = 1;+ var ATTRIBUTE_NODE = NodeType.ATTRIBUTE_NODE = 2;+ var TEXT_NODE = NodeType.TEXT_NODE = 3;+ var CDATA_SECTION_NODE = NodeType.CDATA_SECTION_NODE = 4;+ var ENTITY_REFERENCE_NODE = NodeType.ENTITY_REFERENCE_NODE = 5;+ var ENTITY_NODE = NodeType.ENTITY_NODE = 6;+ var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;+ var COMMENT_NODE = NodeType.COMMENT_NODE = 8;+ var DOCUMENT_NODE = NodeType.DOCUMENT_NODE = 9;+ var DOCUMENT_TYPE_NODE = NodeType.DOCUMENT_TYPE_NODE = 10;+ var DOCUMENT_FRAGMENT_NODE = NodeType.DOCUMENT_FRAGMENT_NODE = 11;+ var NOTATION_NODE = NodeType.NOTATION_NODE = 12;+ var DocumentPosition = conventions.freeze({+ DOCUMENT_POSITION_DISCONNECTED: 1,+ DOCUMENT_POSITION_PRECEDING: 2,+ DOCUMENT_POSITION_FOLLOWING: 4,+ DOCUMENT_POSITION_CONTAINS: 8,+ DOCUMENT_POSITION_CONTAINED_BY: 16,+ DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32+ });+ function commonAncestor(a, b) {+ if (b.length < a.length) return commonAncestor(b, a);+ var c = null;+ for (var n in a) {+ if (a[n] !== b[n]) return c;+ c = a[n];+ }+ return c;+ }+ function docGUID(doc) {+ if (!doc.guid) doc.guid = Math.random();+ return doc.guid;+ }+ function NodeList() {+ }+ NodeList.prototype = {+ /**+ * The number of nodes in the list. The range of valid child node indices is 0 to length-1+ * inclusive.+ *+ * @type {number}+ */+ length: 0,+ /**+ * Returns the item at `index`. If index is greater than or equal to the number of nodes in+ * the list, this returns null.+ *+ * @param index+ * Unsigned long Index into the collection.+ * @returns {Node | null}+ * The node at position `index` in the NodeList,+ * or null if that is not a valid index.+ */+ item: function(index) {+ return index >= 0 && index < this.length ? this[index] : null;+ },+ /**+ * Returns a string representation of the NodeList.+ *+ * Accepts the same `options` object as `XMLSerializer.prototype.serializeToString`+ * (`requireWellFormed`, `splitCDATASections`, `nodeFilter`). Passing a function is treated as+ * a legacy `nodeFilter` for backward compatibility.+ *+ * @param {Object | function} [options]+ * @param {boolean} [options.requireWellFormed=false]+ * @param {boolean} [options.splitCDATASections=true]+ * @param {function} [options.nodeFilter]+ * @returns {string}+ */+ toString: function(options) {+ var opts;+ if (typeof options === "function") {+ opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: options };+ } else if (!!options) {+ opts = {+ requireWellFormed: !!options.requireWellFormed,+ splitCDATASections: options.splitCDATASections !== false,+ nodeFilter: options.nodeFilter || null+ };+ } else {+ opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: null };+ }+ for (var buf = [], i = 0; i < this.length; i++) {+ serializeToString(this[i], buf, null, opts);+ }+ return buf.join("");+ },+ /**+ * Filters the NodeList based on a predicate.+ *+ * @param {function(Node): boolean} predicate+ * - A predicate function to filter the NodeList.+ * @returns {Node[]}+ * An array of nodes that satisfy the predicate.+ * @private+ */+ filter: function(predicate) {+ return Array.prototype.filter.call(this, predicate);+ },+ /**+ * Returns the first index at which a given node can be found in the NodeList, or -1 if it is+ * not present.+ *+ * @param {Node} item+ * - The Node item to locate in the NodeList.+ * @returns {number}+ * The first index of the node in the NodeList; -1 if not found.+ * @private+ */+ indexOf: function(item) {+ return Array.prototype.indexOf.call(this, item);+ }+ };+ NodeList.prototype[Symbol.iterator] = function() {+ var me = this;+ var index = 0;+ return {+ next: function() {+ if (index < me.length) {+ return {+ value: me[index++],+ done: false+ };+ } else {+ return {+ done: true+ };+ }+ },+ return: function() {+ return {+ done: true+ };+ }+ };+ };+ function LiveNodeList(node, refresh) {+ this._node = node;+ this._refresh = refresh;+ _updateLiveList(this);+ }+ function _updateLiveList(list) {+ var inc = list._node._inc || list._node.ownerDocument._inc;+ if (list._inc !== inc) {+ var ls = list._refresh(list._node);+ __set__(list, "length", ls.length);+ if (!list.$$length || ls.length < list.$$length) {+ for (var i = ls.length; i in list; i++) {+ if (hasOwn(list, i)) {+ delete list[i];+ }+ }+ }+ copy(ls, list);+ list._inc = inc;+ }+ }+ LiveNodeList.prototype.item = function(i) {+ _updateLiveList(this);+ return this[i] || null;+ };+ _extends(LiveNodeList, NodeList);+ function NamedNodeMap() {+ this._nsIndex = /* @__PURE__ */ Object.create(null);+ this._noNsIndex = /* @__PURE__ */ Object.create(null);+ }+ function _findNodeIndex(list, node) {+ var i = 0;+ while (i < list.length) {+ if (list[i] === node) {+ return i;+ }+ i++;+ }+ }+ function _nnmBucket(map, namespaceURI, create) {+ if (!namespaceURI) {+ return map._noNsIndex;+ }+ var bucket = map._nsIndex[namespaceURI];+ if (!bucket && create) {+ bucket = map._nsIndex[namespaceURI] = /* @__PURE__ */ Object.create(null);+ }+ return bucket;+ }+ function _nnmIndexFind(map, namespaceURI, localName) {+ var bucket = _nnmBucket(map, namespaceURI, false);+ var found = bucket && bucket[localName];+ return found ? found : null;+ }+ function _nnmIndexAdd(map, attr) {+ _nnmBucket(map, attr.namespaceURI, true)[attr.localName] = attr;+ }+ function _nnmIndexRemove(map, attr) {+ var bucket = _nnmBucket(map, attr.namespaceURI, false);+ if (bucket) {+ delete bucket[attr.localName];+ }+ }+ function _addNamedNode(el, list, newAttr, oldAttr) {+ if (oldAttr) {+ list[_findNodeIndex(list, oldAttr)] = newAttr;+ } else {+ list[list.length] = newAttr;+ list.length++;+ }+ _nnmIndexAdd(list, newAttr);+ if (el) {+ newAttr.ownerElement = el;+ var doc = el.ownerDocument;+ if (doc) {+ oldAttr && _onRemoveAttribute(doc, el, oldAttr);+ _onAddAttribute(doc, el, newAttr);+ }+ }+ }+ function _removeNamedNode(el, list, attr) {+ var i = _findNodeIndex(list, attr);+ if (i >= 0) {+ var lastIndex = list.length - 1;+ while (i <= lastIndex) {+ list[i] = list[++i];+ }+ list.length = lastIndex;+ _nnmIndexRemove(list, attr);+ if (el) {+ var doc = el.ownerDocument;+ if (doc) {+ _onRemoveAttribute(doc, el, attr);+ }+ attr.ownerElement = null;+ }+ }+ }+ NamedNodeMap.prototype = {+ length: 0,+ item: NodeList.prototype.item,+ /**+ * Get an attribute by name. Note: Name is in lower case in case of HTML namespace and+ * document.+ *+ * @param {string} localName+ * The local name of the attribute.+ * @returns {Attr | null}+ * The attribute with the given local name, or null if no such attribute exists.+ * @see https://dom.spec.whatwg.org/#concept-element-attributes-get-by-name+ */+ getNamedItem: function(localName) {+ if (this._ownerElement && this._ownerElement._isInHTMLDocumentAndNamespace()) {+ localName = localName.toLowerCase();+ }+ var i = 0;+ while (i < this.length) {+ var attr = this[i];+ if (attr.nodeName === localName) {+ return attr;+ }+ i++;+ }+ return null;+ },+ /**+ * Set an attribute.+ *+ * @param {Attr} attr+ * The attribute to set.+ * @returns {Attr | null}+ * The old attribute with the same local name and namespace URI as the new one, or null if no+ * such attribute exists.+ * @throws {DOMException}+ * With code:+ * - {@link INUSE_ATTRIBUTE_ERR} - If the attribute is already an attribute of another+ * element.+ * @see https://dom.spec.whatwg.org/#concept-element-attributes-set+ */+ setNamedItem: function(attr) {+ var el = attr.ownerElement;+ if (el && el !== this._ownerElement) {+ throw new DOMException(DOMException.INUSE_ATTRIBUTE_ERR);+ }+ var oldAttr = _nnmIndexFind(this, attr.namespaceURI, attr.localName);+ if (oldAttr === attr) {+ return attr;+ }+ _addNamedNode(this._ownerElement, this, attr, oldAttr);+ return oldAttr;+ },+ /**+ * Set an attribute, replacing an existing attribute with the same local name and namespace+ * URI if one exists.+ *+ * @param {Attr} attr+ * The attribute to set.+ * @returns {Attr | null}+ * The old attribute with the same local name and namespace URI as the new one, or null if no+ * such attribute exists.+ * @throws {DOMException}+ * Throws a DOMException with the name "InUseAttributeError" if the attribute is already an+ * attribute of another element.+ * @see https://dom.spec.whatwg.org/#concept-element-attributes-set+ */+ setNamedItemNS: function(attr) {+ return this.setNamedItem(attr);+ },+ /**+ * Removes an attribute specified by the local name.+ *+ * @param {string} localName+ * The local name of the attribute to be removed.+ * @returns {Attr}+ * The attribute node that was removed.+ * @throws {DOMException}+ * With code:+ * - {@link DOMException.NOT_FOUND_ERR} if no attribute with the given name is found.+ * @see https://dom.spec.whatwg.org/#dom-namednodemap-removenameditem+ * @see https://dom.spec.whatwg.org/#concept-element-attributes-remove-by-name+ */+ removeNamedItem: function(localName) {+ var attr = this.getNamedItem(localName);+ if (!attr) {+ throw new DOMException(DOMException.NOT_FOUND_ERR, localName);+ }+ _removeNamedNode(this._ownerElement, this, attr);+ return attr;+ },+ /**+ * Removes an attribute specified by the namespace and local name.+ *+ * @param {string | null} namespaceURI+ * The namespace URI of the attribute to be removed.+ * @param {string} localName+ * The local name of the attribute to be removed.+ * @returns {Attr}+ * The attribute node that was removed.+ * @throws {DOMException}+ * With code:+ * - {@link DOMException.NOT_FOUND_ERR} if no attribute with the given namespace URI and local+ * name is found.+ * @see https://dom.spec.whatwg.org/#dom-namednodemap-removenameditemns+ * @see https://dom.spec.whatwg.org/#concept-element-attributes-remove-by-namespace+ */+ removeNamedItemNS: function(namespaceURI, localName) {+ var attr = this.getNamedItemNS(namespaceURI, localName);+ if (!attr) {+ throw new DOMException(DOMException.NOT_FOUND_ERR, namespaceURI ? namespaceURI + " : " + localName : localName);+ }+ _removeNamedNode(this._ownerElement, this, attr);+ return attr;+ },+ /**+ * Get an attribute by namespace and local name.+ *+ * @param {string | null} namespaceURI+ * The namespace URI of the attribute.+ * @param {string} localName+ * The local name of the attribute.+ * @returns {Attr | null}+ * The attribute with the given namespace URI and local name, or null if no such attribute+ * exists.+ * @see https://dom.spec.whatwg.org/#concept-element-attributes-get-by-namespace+ */+ getNamedItemNS: function(namespaceURI, localName) {+ if (!namespaceURI) {+ namespaceURI = null;+ }+ var i = 0;+ while (i < this.length) {+ var node = this[i];+ if (node.localName === localName && node.namespaceURI === namespaceURI) {+ return node;+ }+ i++;+ }+ return null;+ }+ };+ NamedNodeMap.prototype[Symbol.iterator] = function() {+ var me = this;+ var index = 0;+ return {+ next: function() {+ if (index < me.length) {+ return {+ value: me[index++],+ done: false+ };+ } else {+ return {+ done: true+ };+ }+ },+ return: function() {+ return {+ done: true+ };+ }+ };+ };+ function DOMImplementation() {+ }+ DOMImplementation.prototype = {+ /**+ * Test if the DOM implementation implements a specific feature and version, as specified in+ * {@link https://www.w3.org/TR/DOM-Level-3-Core/core.html#DOMFeatures DOM Features}.+ *+ * The DOMImplementation.hasFeature() method returns a Boolean flag indicating if a given+ * feature is supported. The different implementations fairly diverged in what kind of+ * features were reported. The latest version of the spec settled to force this method to+ * always return true, where the functionality was accurate and in use.+ *+ * @deprecated+ * It is deprecated and modern browsers return true in all cases.+ * @function DOMImplementation#hasFeature+ * @param {string} feature+ * The name of the feature to test.+ * @param {string} [version]+ * This is the version number of the feature to test.+ * @returns {boolean}+ * Always returns true.+ * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/hasFeature MDN+ * @see https://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-5CED94D7 DOM Level 1 Core+ * @see https://dom.spec.whatwg.org/#dom-domimplementation-hasfeature DOM Living Standard+ * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-5CED94D7 DOM Level 3 Core+ */+ hasFeature: function(feature, version) {+ return true;+ },+ /**+ * Creates a DOM Document object of the specified type with its document element. Note that+ * based on the {@link DocumentType}+ * given to create the document, the implementation may instantiate specialized+ * {@link Document} objects that support additional features than the "Core", such as "HTML"+ * {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#DOM2HTML DOM Level 2 HTML}.+ * On the other hand, setting the {@link DocumentType} after the document was created makes+ * this very unlikely to happen. Alternatively, specialized {@link Document} creation methods,+ * such as createHTMLDocument+ * {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#DOM2HTML DOM Level 2 HTML},+ * can be used to obtain specific types of {@link Document} objects.+ *+ * __It behaves slightly different from the description in the living standard__:+ * - There is no interface/class `XMLDocument`, it returns a `Document`+ * instance (with it's `type` set to `'xml'`).+ * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.+ *+ * @function DOMImplementation.createDocument+ * @param {string | null} namespaceURI+ * The+ * {@link https://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-namespaceURI namespace URI}+ * of the document element to create or null.+ * @param {string | null} qualifiedName+ * The+ * {@link https://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-qualifiedname qualified name}+ * of the document element to be created or null.+ * @param {DocumentType | null} [doctype=null]+ * The type of document to be created or null. When doctype is not null, its+ * {@link Node#ownerDocument} attribute is set to the document being created. Default is+ * `null`+ * @returns {Document}+ * A new {@link Document} object with its document element. If the NamespaceURI,+ * qualifiedName, and doctype are null, the returned {@link Document} is empty with no+ * document element.+ * @throws {DOMException}+ * With code:+ *+ * - `INVALID_CHARACTER_ERR`: Raised if the specified qualified name is not an XML name+ * according to {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#XML XML 1.0}.+ * - `NAMESPACE_ERR`: Raised if the qualifiedName is malformed, if the qualifiedName has a+ * prefix and the namespaceURI is null, or if the qualifiedName is null and the namespaceURI+ * is different from null, or if the qualifiedName has a prefix that is "xml" and the+ * namespaceURI is different from "{@link http://www.w3.org/XML/1998/namespace}"+ * {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#Namespaces XML Namespaces},+ * or if the DOM implementation does not support the "XML" feature but a non-null namespace+ * URI was provided, since namespaces were defined by XML.+ * - `WRONG_DOCUMENT_ERR`: Raised if doctype has already been used with a different document+ * or was created from a different implementation.+ * - `NOT_SUPPORTED_ERR`: May be raised if the implementation does not support the feature+ * "XML" and the language exposed through the Document does not support XML Namespaces (such+ * as {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#HTML40 HTML 4.01}).+ * @since DOM Level 2.+ * @see {@link #createHTMLDocument}+ * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocument MDN+ * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocument DOM Living Standard+ * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Level-2-Core-DOM-createDocument DOM+ * Level 3 Core+ * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocument DOM+ * Level 2 Core (initial)+ */+ createDocument: function(namespaceURI, qualifiedName, doctype) {+ var contentType = MIME_TYPE.XML_APPLICATION;+ if (namespaceURI === NAMESPACE.HTML) {+ contentType = MIME_TYPE.XML_XHTML_APPLICATION;+ } else if (namespaceURI === NAMESPACE.SVG) {+ contentType = MIME_TYPE.XML_SVG_IMAGE;+ }+ var doc = new Document(PDC, { contentType });+ doc.implementation = this;+ doc.childNodes = new NodeList();+ doc.doctype = doctype || null;+ if (doctype) {+ doc.appendChild(doctype);+ }+ if (qualifiedName) {+ var root = doc.createElementNS(namespaceURI, qualifiedName);+ doc.appendChild(root);+ }+ return doc;+ },+ /**+ * Creates an empty DocumentType node. Entity declarations and notations are not made+ * available. Entity reference expansions and default attribute additions do not occur.+ *+ * **This behavior is slightly different from the one in the specs**:+ * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.+ * - `publicId` and `systemId` contain the raw data including any possible quotes,+ * so they can always be serialized back to the original value+ * - `internalSubset` contains the raw string between `[` and `]` if present,+ * but is not parsed or validated in any form.+ *+ * @function DOMImplementation#createDocumentType+ * @param {string} qualifiedName+ * The {@link https://www.w3.org/TR/DOM-Level-3-Core/glossary.html#dt-qualifiedname qualified+ * name} of the document type to be created.+ * @param {string} [publicId]+ * The external subset public identifier. Stored verbatim including surrounding quotes.+ * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`+ * if the value is non-empty and does not match the XML `PubidLiteral` production+ * (W3C DOM Parsing §3.2.1.3; XML 1.0 production [12]). Creation-time validation is not+ * enforced — deferred to a future breaking release.+ * @param {string} [systemId]+ * The external subset system identifier. Stored verbatim including surrounding quotes.+ * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`+ * if the value is non-empty and does not match the XML `SystemLiteral` production+ * (W3C DOM Parsing §3.2.1.3; XML 1.0 production [11]). Creation-time validation is not+ * enforced — deferred to a future breaking release.+ * @param {string} [internalSubset]+ * The internal subset or an empty string if it is not present. Stored verbatim.+ * When serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`+ * if the value contains `"]>"`. Creation-time validation is not enforced.+ * @returns {DocumentType}+ * A new {@link DocumentType} node with {@link Node#ownerDocument} set to null.+ * @throws {DOMException}+ * With code:+ *+ * - `INVALID_CHARACTER_ERR`: Raised if the specified qualified name is not an XML name+ * according to {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#XML XML 1.0}.+ * - `NAMESPACE_ERR`: Raised if the qualifiedName is malformed.+ * - `NOT_SUPPORTED_ERR`: May be raised if the implementation does not support the feature+ * "XML" and the language exposed through the Document does not support XML Namespaces (such+ * as {@link https://www.w3.org/TR/DOM-Level-3-Core/references.html#HTML40 HTML 4.01}).+ * @since DOM Level 2.+ * @see https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation/createDocumentType+ * MDN+ * @see https://dom.spec.whatwg.org/#dom-domimplementation-createdocumenttype DOM Living+ * Standard+ * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Level-3-Core-DOM-createDocType DOM+ * Level 3 Core+ * @see https://www.w3.org/TR/DOM-Level-2-Core/core.html#Level-2-Core-DOM-createDocType DOM+ * Level 2 Core+ * @see https://github.com/xmldom/xmldom/blob/master/CHANGELOG.md#050+ * @see https://www.w3.org/TR/DOM-Level-2-Core/#core-ID-Core-DocType-internalSubset+ * @prettierignore+ */+ createDocumentType: function(qualifiedName, publicId, systemId, internalSubset) {+ validateQualifiedName(qualifiedName);+ var node = new DocumentType(PDC);+ node.name = qualifiedName;+ node.nodeName = qualifiedName;+ node.publicId = publicId || "";+ node.systemId = systemId || "";+ node.internalSubset = internalSubset || "";+ node.childNodes = new NodeList();+ return node;+ },+ /**+ * Returns an HTML document, that might already have a basic DOM structure.+ *+ * __It behaves slightly different from the description in the living standard__:+ * - If the first argument is `false` no initial nodes are added (steps 3-7 in the specs are+ * omitted)+ * - `encoding`, `mode`, `origin`, `url` fields are currently not declared.+ *+ * @param {string | false} [title]+ * A string containing the title to give the new HTML document.+ * @returns {Document}+ * The HTML document.+ * @since WHATWG Living Standard.+ * @see {@link #createDocument}+ * @see https://dom.spec.whatwg.org/#dom-domimplementation-createhtmldocument+ * @see https://dom.spec.whatwg.org/#html-document+ */+ createHTMLDocument: function(title) {+ var doc = new Document(PDC, { contentType: MIME_TYPE.HTML });+ doc.implementation = this;+ doc.childNodes = new NodeList();+ if (title !== false) {+ doc.doctype = this.createDocumentType("html");+ doc.doctype.ownerDocument = doc;+ doc.appendChild(doc.doctype);+ var htmlNode = doc.createElement("html");+ doc.appendChild(htmlNode);+ var headNode = doc.createElement("head");+ htmlNode.appendChild(headNode);+ if (typeof title === "string") {+ var titleNode = doc.createElement("title");+ titleNode.appendChild(doc.createTextNode(title));+ headNode.appendChild(titleNode);+ }+ htmlNode.appendChild(doc.createElement("body"));+ }+ return doc;+ }+ };+ function Node(symbol) {+ checkSymbol(symbol);+ }+ Node.prototype = {+ /**+ * The first child of this node.+ *+ * @type {Node | null}+ */+ firstChild: null,+ /**+ * The last child of this node.+ *+ * @type {Node | null}+ */+ lastChild: null,+ /**+ * The previous sibling of this node.+ *+ * @type {Node | null}+ */+ previousSibling: null,+ /**+ * The next sibling of this node.+ *+ * @type {Node | null}+ */+ nextSibling: null,+ /**+ * The parent node of this node.+ *+ * @type {Node | null}+ */+ parentNode: null,+ /**+ * The parent element of this node.+ *+ * @type {Element | null}+ */+ get parentElement() {+ return this.parentNode && this.parentNode.nodeType === this.ELEMENT_NODE ? this.parentNode : null;+ },+ /**+ * The child nodes of this node.+ *+ * @type {NodeList}+ */+ childNodes: null,+ /**+ * The document object associated with this node.+ *+ * @type {Document | null}+ */+ ownerDocument: null,+ /**+ * The value of this node.+ *+ * @type {string | null}+ */+ nodeValue: null,+ /**+ * The namespace URI of this node.+ *+ * @type {string | null}+ */+ namespaceURI: null,+ /**+ * The prefix of the namespace for this node.+ *+ * @type {string | null}+ */+ prefix: null,+ /**+ * The local part of the qualified name of this node.+ *+ * @type {string | null}+ */+ localName: null,+ /**+ * The baseURI is currently always `about:blank`,+ * since that's what happens when you create a document from scratch.+ *+ * @type {'about:blank'}+ */+ baseURI: "about:blank",+ /**+ * Is true if this node is part of a document.+ *+ * @type {boolean}+ */+ get isConnected() {+ var rootNode = this.getRootNode();+ return rootNode && rootNode.nodeType === rootNode.DOCUMENT_NODE;+ },+ /**+ * Checks whether `other` is an inclusive descendant of this node.+ *+ * @param {Node | null | undefined} other+ * The node to check.+ * @returns {boolean}+ * True if `other` is an inclusive descendant of this node; false otherwise.+ * @see https://dom.spec.whatwg.org/#dom-node-contains+ */+ contains: function(other) {+ if (!other) return false;+ var parent = other;+ do {+ if (this === parent) return true;+ parent = parent.parentNode;+ } while (parent);+ return false;+ },+ /**+ * @typedef GetRootNodeOptions+ * @property {boolean} [composed=false]+ */+ /**+ * Searches for the root node of this node.+ *+ * **This behavior is slightly different from the in the specs**:+ * - ignores `options.composed`, since `ShadowRoot`s are unsupported, always returns root.+ *+ * @param {GetRootNodeOptions} [options]+ * @returns {Node}+ * Root node.+ * @see https://dom.spec.whatwg.org/#dom-node-getrootnode+ * @see https://dom.spec.whatwg.org/#concept-shadow-including-root+ */+ getRootNode: function(options) {+ var parent = this;+ do {+ if (!parent.parentNode) {+ return parent;+ }+ parent = parent.parentNode;+ } while (parent);+ },+ /**+ * Checks whether the given node is equal to this node.+ *+ * Two nodes are equal when they have the same type, defining characteristics (for the type),+ * and the same childNodes. The comparison is iterative to avoid stack overflows on+ * deeply-nested trees. Attribute nodes of each Element pair are also pushed onto the stack+ * and compared the same way.+ *+ * @param {Node} [otherNode]+ * @returns {boolean}+ * @see https://dom.spec.whatwg.org/#concept-node-equals+ * @see ../docs/walk-dom.md.+ */+ isEqualNode: function(otherNode) {+ if (!otherNode) return false;+ var stack = [{ node: this, other: otherNode }];+ while (stack.length > 0) {+ var pair = stack.pop();+ var node = pair.node;+ var other = pair.other;+ if (node.nodeType !== other.nodeType) return false;+ switch (node.nodeType) {+ case node.DOCUMENT_TYPE_NODE:+ if (node.name !== other.name) return false;+ if (node.publicId !== other.publicId) return false;+ if (node.systemId !== other.systemId) return false;+ break;+ case node.ELEMENT_NODE:+ if (node.namespaceURI !== other.namespaceURI) return false;+ if (node.prefix !== other.prefix) return false;+ if (node.localName !== other.localName) return false;+ if (node.attributes.length !== other.attributes.length) return false;+ for (var i = 0; i < node.attributes.length; i++) {+ var attr = node.attributes.item(i);+ var otherAttr = other.getAttributeNodeNS(attr.namespaceURI, attr.localName);+ if (!otherAttr) return false;+ stack.push({ node: attr, other: otherAttr });+ }+ break;+ case node.ATTRIBUTE_NODE:+ if (node.namespaceURI !== other.namespaceURI) return false;+ if (node.localName !== other.localName) return false;+ if (node.value !== other.value) return false;+ break;+ case node.PROCESSING_INSTRUCTION_NODE:+ if (node.target !== other.target || node.data !== other.data) return false;+ break;+ case node.TEXT_NODE:+ case node.CDATA_SECTION_NODE:+ case node.COMMENT_NODE:+ if (node.data !== other.data) return false;+ break;+ }+ if (node.childNodes.length !== other.childNodes.length) return false;+ for (var i = node.childNodes.length - 1; i >= 0; i--) {+ stack.push({ node: node.childNodes[i], other: other.childNodes[i] });+ }+ }+ return true;+ },+ /**+ * Checks whether or not the given node is this node.+ *+ * @param {Node} [otherNode]+ */+ isSameNode: function(otherNode) {+ return this === otherNode;+ },+ /**+ * Inserts a node before a reference node as a child of this node.+ *+ * @param {Node} newChild+ * The new child node to be inserted.+ * @param {Node | null} refChild+ * The reference node before which newChild will be inserted.+ * @returns {Node}+ * The new child node successfully inserted.+ * @throws {DOMException}+ * Throws a DOMException if inserting the node would result in a DOM tree that is not+ * well-formed, or if `child` is provided but is not a child of `parent`.+ * See {@link _insertBefore} for more details.+ * @since Modified in DOM L2+ */+ insertBefore: function(newChild, refChild) {+ return _insertBefore(this, newChild, refChild);+ },+ /**+ * Replaces an old child node with a new child node within this node.+ *+ * @param {Node} newChild+ * The new node that is to replace the old node.+ * If it already exists in the DOM, it is removed from its original position.+ * @param {Node} oldChild+ * The existing child node to be replaced.+ * @returns {Node}+ * Returns the replaced child node.+ * @throws {DOMException}+ * Throws a DOMException if replacing the node would result in a DOM tree that is not+ * well-formed, or if `oldChild` is not a child of `this`.+ * This can also occur if the pre-replacement validity assertion fails.+ * See {@link _insertBefore}, {@link Node.removeChild}, and+ * {@link assertPreReplacementValidityInDocument} for more details.+ * @see https://dom.spec.whatwg.org/#concept-node-replace+ */+ replaceChild: function(newChild, oldChild) {+ _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);+ if (oldChild) {+ this.removeChild(oldChild);+ }+ },+ /**+ * Removes an existing child node from this node.+ *+ * @param {Node} oldChild+ * The child node to be removed.+ * @returns {Node}+ * Returns the removed child node.+ * @throws {DOMException}+ * Throws a DOMException if `oldChild` is not a child of `this`.+ * See {@link _removeChild} for more details.+ */+ removeChild: function(oldChild) {+ return _removeChild(this, oldChild);+ },+ /**+ * Appends a child node to this node.+ *+ * @param {Node} newChild+ * The child node to be appended to this node.+ * If it already exists in the DOM, it is removed from its original position.+ * @returns {Node}+ * Returns the appended child node.+ * @throws {DOMException}+ * Throws a DOMException if appending the node would result in a DOM tree that is not+ * well-formed, or if `newChild` is not a valid Node.+ * See {@link insertBefore} for more details.+ */+ appendChild: function(newChild) {+ return this.insertBefore(newChild, null);+ },+ /**+ * Determines whether this node has any child nodes.+ *+ * @returns {boolean}+ * Returns true if this node has any child nodes, and false otherwise.+ */+ hasChildNodes: function() {+ return this.firstChild != null;+ },+ /**+ * Creates a copy of the calling node.+ *+ * @param {boolean} deep+ * If true, the contents of the node are recursively copied.+ * If false, only the node itself (and its attributes, if it is an element) are copied.+ * @returns {Node}+ * Returns the newly created copy of the node.+ * @throws {DOMException}+ * May throw a DOMException if operations within {@link Element#setAttributeNode} or+ * {@link Node#appendChild} (which are potentially invoked in this method) do not meet their+ * specific constraints.+ * @see {@link cloneNode}+ */+ cloneNode: function(deep) {+ return cloneNode(this.ownerDocument || this, this, deep);+ },+ /**+ * Puts the specified node and all of its subtree into a "normalized" form. In a normalized+ * subtree, no text nodes in the subtree are empty and there are no adjacent text nodes.+ *+ * Specifically, this method merges any adjacent text nodes (i.e., nodes for which `nodeType`+ * is `TEXT_NODE`) into a single node with the combined data. It also removes any empty text+ * nodes.+ *+ * This method iterativly traverses all child nodes to normalize all descendent nodes within+ * the subtree.+ *+ * @throws {DOMException}+ * May throw a DOMException if operations within removeChild or appendData (which are+ * potentially invoked in this method) do not meet their specific constraints.+ * @since Modified in DOM Level 2+ * @see {@link Node.removeChild}+ * @see {@link CharacterData.appendData}+ * @see ../docs/walk-dom.md.+ */+ normalize: function() {+ walkDOM(this, null, {+ enter: function(node) {+ var child2 = node.firstChild;+ while (child2) {+ var next = child2.nextSibling;+ if (next !== null && next.nodeType === TEXT_NODE && child2.nodeType === TEXT_NODE) {+ var tail = [];+ var sibling = next;+ while (sibling !== null && sibling.nodeType === TEXT_NODE) {+ tail.push(sibling.data);+ sibling = sibling.nextSibling;+ }+ var removed = child2.nextSibling;+ while (removed !== sibling) {+ var following = removed.nextSibling;+ removed.parentNode = null;+ removed.previousSibling = null;+ removed.nextSibling = null;+ removed = following;+ }+ child2.nextSibling = sibling;+ if (sibling !== null) {+ sibling.previousSibling = child2;+ } else {+ node.lastChild = child2;+ }+ child2.appendData(tail.join(""));+ _onUpdateChild(node.ownerDocument, node);+ child2 = sibling;+ } else {+ child2 = next;+ }+ }+ return true;+ }+ });+ },+ /**+ * Checks whether the DOM implementation implements a specific feature and its version.+ *+ * @deprecated+ * Since `DOMImplementation.hasFeature` is deprecated and always returns true.+ * @param {string} feature+ * The package name of the feature to test. This is the same name that can be passed to the+ * method `hasFeature` on `DOMImplementation`.+ * @param {string} version+ * This is the version number of the package name to test.+ * @returns {boolean}+ * Returns true in all cases in the current implementation.+ * @since Introduced in DOM Level 2+ * @see {@link DOMImplementation.hasFeature}+ */+ isSupported: function(feature, version) {+ return this.ownerDocument.implementation.hasFeature(feature, version);+ },+ /**+ * Look up the prefix associated to the given namespace URI, starting from this node.+ * **The default namespace declarations are ignored by this method.**+ * See Namespace Prefix Lookup for details on the algorithm used by this method.+ *+ * **This behavior is different from the in the specs**:+ * - no node type specific handling+ * - uses the internal attribute _nsMap for resolving namespaces that is updated when changing attributes+ *+ * @param {string | null} namespaceURI+ * The namespace URI for which to find the associated prefix.+ * @returns {string | null}+ * The associated prefix, if found; otherwise, null.+ * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespacePrefix+ * @see https://www.w3.org/TR/DOM-Level-3-Core/namespaces-algorithms.html#lookupNamespacePrefixAlgo+ * @see https://dom.spec.whatwg.org/#dom-node-lookupprefix+ * @see https://github.com/xmldom/xmldom/issues/322+ * @prettierignore+ */+ lookupPrefix: function(namespaceURI) {+ var el = this;+ while (el) {+ var map = el._nsMap;+ if (map) {+ for (var n in map) {+ if (hasOwn(map, n) && map[n] === namespaceURI) {+ return n;+ }+ }+ }+ el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;+ }+ return null;+ },+ /**+ * This function is used to look up the namespace URI associated with the given prefix,+ * starting from this node.+ *+ * **This behavior is different from the in the specs**:+ * - no node type specific handling+ * - uses the internal attribute _nsMap for resolving namespaces that is updated when changing attributes+ *+ * @param {string | null} prefix+ * The prefix for which to find the associated namespace URI.+ * @returns {string | null}+ * The associated namespace URI, if found; otherwise, null.+ * @since DOM Level 3+ * @see https://dom.spec.whatwg.org/#dom-node-lookupnamespaceuri+ * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-lookupNamespaceURI+ * @prettierignore+ */+ lookupNamespaceURI: function(prefix) {+ var el = this;+ while (el) {+ var map = el._nsMap;+ if (map) {+ if (hasOwn(map, prefix)) {+ return map[prefix];+ }+ }+ el = el.nodeType == ATTRIBUTE_NODE ? el.ownerDocument : el.parentNode;+ }+ return null;+ },+ /**+ * Determines whether the given namespace URI is the default namespace.+ *+ * The function works by looking up the prefix associated with the given namespace URI. If no+ * prefix is found (i.e., the namespace URI is not registered in the namespace map of this+ * node or any of its ancestors), it returns `true`, implying the namespace URI is considered+ * the default.+ *+ * **This behavior is different from the in the specs**:+ * - no node type specific handling+ * - uses the internal attribute _nsMap for resolving namespaces that is updated when changing attributes+ *+ * @param {string | null} namespaceURI+ * The namespace URI to be checked.+ * @returns {boolean}+ * Returns true if the given namespace URI is the default namespace, false otherwise.+ * @since DOM Level 3+ * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#Node3-isDefaultNamespace+ * @see https://dom.spec.whatwg.org/#dom-node-isdefaultnamespace+ * @prettierignore+ */+ isDefaultNamespace: function(namespaceURI) {+ var prefix = this.lookupPrefix(namespaceURI);+ return prefix == null;+ },+ /**+ * Compares the reference node with a node with regard to their position in the document and+ * according to the document order.+ *+ * @param {Node} other+ * The node to compare the reference node to.+ * @returns {number}+ * Returns how the node is positioned relatively to the reference node according to the+ * bitmask. 0 if reference node and given node are the same.+ * @since DOM Level 3+ * @see https://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#Node3-compare+ * @see https://dom.spec.whatwg.org/#dom-node-comparedocumentposition+ */+ compareDocumentPosition: function(other) {+ if (this === other) return 0;+ var node1 = other;+ var node2 = this;+ var attr1 = null;+ var attr2 = null;+ if (node1 instanceof Attr) {+ attr1 = node1;+ node1 = attr1.ownerElement;+ }+ if (node2 instanceof Attr) {+ attr2 = node2;+ node2 = attr2.ownerElement;+ if (attr1 && node1 && node2 === node1) {+ for (var i = 0, attr; attr = node2.attributes[i]; i++) {+ if (attr === attr1)+ return DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + DocumentPosition.DOCUMENT_POSITION_PRECEDING;+ if (attr === attr2)+ return DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + DocumentPosition.DOCUMENT_POSITION_FOLLOWING;+ }+ }+ }+ if (!node1 || !node2 || node2.ownerDocument !== node1.ownerDocument) {+ return DocumentPosition.DOCUMENT_POSITION_DISCONNECTED + DocumentPosition.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC + (docGUID(node2.ownerDocument) > docGUID(node1.ownerDocument) ? DocumentPosition.DOCUMENT_POSITION_FOLLOWING : DocumentPosition.DOCUMENT_POSITION_PRECEDING);+ }+ if (attr2 && node1 === node2) {+ return DocumentPosition.DOCUMENT_POSITION_CONTAINS + DocumentPosition.DOCUMENT_POSITION_PRECEDING;+ }+ if (attr1 && node1 === node2) {+ return DocumentPosition.DOCUMENT_POSITION_CONTAINED_BY + DocumentPosition.DOCUMENT_POSITION_FOLLOWING;+ }+ var chain1 = [];+ var ancestor1 = node1.parentNode;+ while (ancestor1) {+ if (!attr2 && ancestor1 === node2) {+ return DocumentPosition.DOCUMENT_POSITION_CONTAINED_BY + DocumentPosition.DOCUMENT_POSITION_FOLLOWING;+ }+ chain1.push(ancestor1);+ ancestor1 = ancestor1.parentNode;+ }+ chain1.reverse();+ var chain2 = [];+ var ancestor2 = node2.parentNode;+ while (ancestor2) {+ if (!attr1 && ancestor2 === node1) {+ return DocumentPosition.DOCUMENT_POSITION_CONTAINS + DocumentPosition.DOCUMENT_POSITION_PRECEDING;+ }+ chain2.push(ancestor2);+ ancestor2 = ancestor2.parentNode;+ }+ chain2.reverse();+ var ca = commonAncestor(chain1, chain2);+ for (var n in ca.childNodes) {+ var child2 = ca.childNodes[n];+ if (child2 === node2) return DocumentPosition.DOCUMENT_POSITION_FOLLOWING;+ if (child2 === node1) return DocumentPosition.DOCUMENT_POSITION_PRECEDING;+ if (chain2.indexOf(child2) >= 0) return DocumentPosition.DOCUMENT_POSITION_FOLLOWING;+ if (chain1.indexOf(child2) >= 0) return DocumentPosition.DOCUMENT_POSITION_PRECEDING;+ }+ return 0;+ }+ };+ function _xmlEncoder(c) {+ return c == "<" && "<" || c == ">" && ">" || c == "&" && "&" || c == '"' && """ || "&#" + c.charCodeAt() + ";";+ }+ copy(NodeType, Node);+ copy(NodeType, Node.prototype);+ copy(DocumentPosition, Node);+ copy(DocumentPosition, Node.prototype);+ function _visitNode(node, callback) {+ walkDOM(node, null, {+ enter: function(n) {+ return callback(n) ? walkDOM.STOP : true;+ }+ });+ }+ function walkDOM(node, context, callbacks) {+ var stack = [{ node, context, phase: walkDOM.ENTER }];+ while (stack.length > 0) {+ var frame = stack.pop();+ if (frame.phase === walkDOM.ENTER) {+ var childContext = callbacks.enter(frame.node, frame.context);+ if (childContext === walkDOM.STOP) {+ return walkDOM.STOP;+ }+ stack.push({ node: frame.node, context: childContext, phase: walkDOM.EXIT });+ if (childContext === null || childContext === void 0) {+ continue;+ }+ var child2 = frame.node.lastChild;+ while (child2) {+ stack.push({ node: child2, context: childContext, phase: walkDOM.ENTER });+ child2 = child2.previousSibling;+ }+ } else {+ if (callbacks.exit) {+ callbacks.exit(frame.node, frame.context);+ }+ }+ }+ }+ walkDOM.STOP = /* @__PURE__ */ Symbol("walkDOM.STOP");+ walkDOM.ENTER = 0;+ walkDOM.EXIT = 1;+ function Document(symbol, options) {+ checkSymbol(symbol);+ var opt = options || {};+ this.ownerDocument = this;+ this.contentType = opt.contentType || MIME_TYPE.XML_APPLICATION;+ this.type = isHTMLMimeType(this.contentType) ? "html" : "xml";+ }+ function _onAddAttribute(doc, el, newAttr) {+ doc && doc._inc++;+ var ns = newAttr.namespaceURI;+ if (ns === NAMESPACE.XMLNS) {+ el._nsMap[newAttr.prefix ? newAttr.localName : ""] = newAttr.value;+ }+ }+ function _onRemoveAttribute(doc, el, newAttr, remove) {+ doc && doc._inc++;+ var ns = newAttr.namespaceURI;+ if (ns === NAMESPACE.XMLNS) {+ delete el._nsMap[newAttr.prefix ? newAttr.localName : ""];+ }+ }+ function _onUpdateChild(doc, parent, newChild) {+ if (doc && doc._inc) {+ doc._inc++;+ var childNodes = parent.childNodes;+ if (newChild && !newChild.nextSibling) {+ childNodes[childNodes.length++] = newChild;+ } else {+ var child2 = parent.firstChild;+ var i = 0;+ while (child2) {+ childNodes[i++] = child2;+ child2 = child2.nextSibling;+ }+ childNodes.length = i;+ delete childNodes[childNodes.length];+ }+ }+ }+ function _removeChild(parentNode, child2) {+ if (parentNode !== child2.parentNode) {+ throw new DOMException(DOMException.NOT_FOUND_ERR, "child's parent is not parent");+ }+ var oldPreviousSibling = child2.previousSibling;+ var oldNextSibling = child2.nextSibling;+ if (oldPreviousSibling) {+ oldPreviousSibling.nextSibling = oldNextSibling;+ } else {+ parentNode.firstChild = oldNextSibling;+ }+ if (oldNextSibling) {+ oldNextSibling.previousSibling = oldPreviousSibling;+ } else {+ parentNode.lastChild = oldPreviousSibling;+ }+ _onUpdateChild(parentNode.ownerDocument, parentNode);+ child2.parentNode = null;+ child2.previousSibling = null;+ child2.nextSibling = null;+ return child2;+ }+ function hasValidParentNodeType(node) {+ return node && (node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.ELEMENT_NODE);+ }+ function hasInsertableNodeType(node) {+ return node && (node.nodeType === Node.CDATA_SECTION_NODE || node.nodeType === Node.COMMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE || node.nodeType === Node.DOCUMENT_TYPE_NODE || node.nodeType === Node.ELEMENT_NODE || node.nodeType === Node.PROCESSING_INSTRUCTION_NODE || node.nodeType === Node.TEXT_NODE);+ }+ function isDocTypeNode(node) {+ return node && node.nodeType === Node.DOCUMENT_TYPE_NODE;+ }+ function isElementNode(node) {+ return node && node.nodeType === Node.ELEMENT_NODE;+ }+ function isTextNode(node) {+ return node && node.nodeType === Node.TEXT_NODE;+ }+ function isElementInsertionPossible(doc, child2) {+ var parentChildNodes = doc.childNodes || [];+ if (find(parentChildNodes, isElementNode) || isDocTypeNode(child2)) {+ return false;+ }+ var docTypeNode = find(parentChildNodes, isDocTypeNode);+ return !(child2 && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child2));+ }+ function isElementReplacementPossible(doc, child2) {+ var parentChildNodes = doc.childNodes || [];+ function hasElementChildThatIsNotChild(node) {+ return isElementNode(node) && node !== child2;+ }+ if (find(parentChildNodes, hasElementChildThatIsNotChild)) {+ return false;+ }+ var docTypeNode = find(parentChildNodes, isDocTypeNode);+ return !(child2 && docTypeNode && parentChildNodes.indexOf(docTypeNode) > parentChildNodes.indexOf(child2));+ }+ function assertPreInsertionValidity1to5(parent, node, child2) {+ if (!hasValidParentNodeType(parent)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Unexpected parent node type " + parent.nodeType);+ }+ if (child2 && child2.parentNode !== parent) {+ throw new DOMException(DOMException.NOT_FOUND_ERR, "child not in parent");+ }+ if (+ // 4. If `node` is not a DocumentFragment, DocumentType, Element, or CharacterData node, then throw a "HierarchyRequestError" DOMException.+ !hasInsertableNodeType(node) || // 5. If either `node` is a Text node and `parent` is a document,+ // the sax parser currently adds top level text nodes, this will be fixed in 0.9.0+ // || (node.nodeType === Node.TEXT_NODE && parent.nodeType === Node.DOCUMENT_NODE)+ // or `node` is a doctype and `parent` is not a document, then throw a "HierarchyRequestError" DOMException.+ isDocTypeNode(node) && parent.nodeType !== Node.DOCUMENT_NODE+ ) {+ throw new DOMException(+ DOMException.HIERARCHY_REQUEST_ERR,+ "Unexpected node type " + node.nodeType + " for parent node type " + parent.nodeType+ );+ }+ }+ function assertPreInsertionValidityInDocument(parent, node, child2) {+ var parentChildNodes = parent.childNodes || [];+ var nodeChildNodes = node.childNodes || [];+ if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {+ var nodeChildElements = nodeChildNodes.filter(isElementNode);+ if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");+ }+ if (nodeChildElements.length === 1 && !isElementInsertionPossible(parent, child2)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");+ }+ }+ if (isElementNode(node)) {+ if (!isElementInsertionPossible(parent, child2)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");+ }+ }+ if (isDocTypeNode(node)) {+ if (find(parentChildNodes, isDocTypeNode)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");+ }+ var parentElementChild = find(parentChildNodes, isElementNode);+ if (child2 && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child2)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");+ }+ if (!child2 && parentElementChild) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Doctype can not be appended since element is present");+ }+ }+ }+ function assertPreReplacementValidityInDocument(parent, node, child2) {+ var parentChildNodes = parent.childNodes || [];+ var nodeChildNodes = node.childNodes || [];+ if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {+ var nodeChildElements = nodeChildNodes.filter(isElementNode);+ if (nodeChildElements.length > 1 || find(nodeChildNodes, isTextNode)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "More than one element or text in fragment");+ }+ if (nodeChildElements.length === 1 && !isElementReplacementPossible(parent, child2)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Element in fragment can not be inserted before doctype");+ }+ }+ if (isElementNode(node)) {+ if (!isElementReplacementPossible(parent, child2)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Only one element can be added and only after doctype");+ }+ }+ if (isDocTypeNode(node)) {+ let hasDoctypeChildThatIsNotChild = function(node2) {+ return isDocTypeNode(node2) && node2 !== child2;+ };+ if (find(parentChildNodes, hasDoctypeChildThatIsNotChild)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Only one doctype is allowed");+ }+ var parentElementChild = find(parentChildNodes, isElementNode);+ if (child2 && parentChildNodes.indexOf(parentElementChild) < parentChildNodes.indexOf(child2)) {+ throw new DOMException(DOMException.HIERARCHY_REQUEST_ERR, "Doctype can only be inserted before an element");+ }+ }+ }+ function _insertBefore(parent, node, child2, _inDocumentAssertion) {+ assertPreInsertionValidity1to5(parent, node, child2);+ if (parent.nodeType === Node.DOCUMENT_NODE) {+ (_inDocumentAssertion || assertPreInsertionValidityInDocument)(parent, node, child2);+ }+ var cp = node.parentNode;+ if (cp) {+ cp.removeChild(node);+ }+ if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {+ var newFirst = node.firstChild;+ if (newFirst == null) {+ return node;+ }+ var newLast = node.lastChild;+ } else {+ newFirst = newLast = node;+ }+ var pre = child2 ? child2.previousSibling : parent.lastChild;+ newFirst.previousSibling = pre;+ newLast.nextSibling = child2;+ if (pre) {+ pre.nextSibling = newFirst;+ } else {+ parent.firstChild = newFirst;+ }+ if (child2 == null) {+ parent.lastChild = newLast;+ } else {+ child2.previousSibling = newLast;+ }+ do {+ newFirst.parentNode = parent;+ } while (newFirst !== newLast && (newFirst = newFirst.nextSibling));+ _onUpdateChild(parent.ownerDocument || parent, parent, node);+ if (node.nodeType == DOCUMENT_FRAGMENT_NODE) {+ node.firstChild = node.lastChild = null;+ }+ return node;+ }+ Document.prototype = {+ /**+ * The implementation that created this document.+ *+ * @type DOMImplementation+ * @readonly+ */+ implementation: null,+ nodeName: "#document",+ nodeType: DOCUMENT_NODE,+ /**+ * The DocumentType node of the document.+ *+ * @type DocumentType+ * @readonly+ */+ doctype: null,+ documentElement: null,+ _inc: 1,+ insertBefore: function(newChild, refChild) {+ if (newChild.nodeType === DOCUMENT_FRAGMENT_NODE) {+ var child2 = newChild.firstChild;+ while (child2) {+ var next = child2.nextSibling;+ this.insertBefore(child2, refChild);+ child2 = next;+ }+ return newChild;+ }+ _insertBefore(this, newChild, refChild);+ newChild.ownerDocument = this;+ if (this.documentElement === null && newChild.nodeType === ELEMENT_NODE) {+ this.documentElement = newChild;+ }+ return newChild;+ },+ removeChild: function(oldChild) {+ var removed = _removeChild(this, oldChild);+ if (removed === this.documentElement) {+ this.documentElement = null;+ }+ return removed;+ },+ replaceChild: function(newChild, oldChild) {+ _insertBefore(this, newChild, oldChild, assertPreReplacementValidityInDocument);+ newChild.ownerDocument = this;+ if (oldChild) {+ this.removeChild(oldChild);+ }+ if (isElementNode(newChild)) {+ this.documentElement = newChild;+ }+ },+ /**+ * Imports a node from another document into this document, creating a new copy owned by this+ * document. The source node and its subtree are not modified.+ *+ * @param {Node} importedNode+ * The node to import.+ * @param {boolean} deep+ * If true, the contents of the node are recursively imported.+ * If false, only the node itself (and its attributes, if it is an element) are imported.+ * @returns {Node}+ * Returns the newly created import of the node.+ * @see {@link importNode}+ * @see {@link https://dom.spec.whatwg.org/#dom-document-importnode}+ */+ importNode: function(importedNode, deep) {+ return importNode(this, importedNode, deep);+ },+ // Introduced in DOM Level 2:+ getElementById: function(id) {+ var rtv = null;+ _visitNode(this.documentElement, function(node) {+ if (node.nodeType == ELEMENT_NODE) {+ if (node.getAttribute("id") == id) {+ rtv = node;+ return true;+ }+ }+ });+ return rtv;+ },+ /**+ * Creates a new `Element` that is owned by this `Document`.+ * In HTML Documents `localName` is the lower cased `tagName`,+ * otherwise no transformation is being applied.+ * When `contentType` implies the HTML namespace, it will be set as `namespaceURI`.+ *+ * __This implementation differs from the specification:__ - The provided name is not checked+ * against the `Name` production,+ * so no related error will be thrown.+ * - There is no interface `HTMLElement`, it is always an `Element`.+ * - There is no support for a second argument to indicate using custom elements.+ *+ * @param {string} tagName+ * @returns {Element}+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createElement+ * @see https://dom.spec.whatwg.org/#dom-document-createelement+ * @see https://dom.spec.whatwg.org/#concept-create-element+ */+ createElement: function(tagName) {+ var node = new Element(PDC);+ node.ownerDocument = this;+ if (this.type === "html") {+ tagName = tagName.toLowerCase();+ }+ if (hasDefaultHTMLNamespace(this.contentType)) {+ node.namespaceURI = NAMESPACE.HTML;+ }+ node.nodeName = tagName;+ node.tagName = tagName;+ node.localName = tagName;+ node.childNodes = new NodeList();+ var attrs = node.attributes = new NamedNodeMap();+ attrs._ownerElement = node;+ return node;+ },+ /**+ * @returns {DocumentFragment}+ */+ createDocumentFragment: function() {+ var node = new DocumentFragment(PDC);+ node.ownerDocument = this;+ node.childNodes = new NodeList();+ return node;+ },+ /**+ * @param {string} data+ * @returns {Text}+ */+ createTextNode: function(data) {+ var node = new Text(PDC);+ node.ownerDocument = this;+ node.childNodes = new NodeList();+ node.appendData(data);+ return node;+ },+ /**+ * @param {string} data+ * @returns {Comment}+ * @see https://dom.spec.whatwg.org/#dom-document-createcomment+ * @see https://www.w3.org/TR/xml/#NT-Comment XML 1.0 production [15]+ * @see https://www.w3.org/TR/DOM-Parsing/#dfn-concept-serialize-xml §3.2.1.3+ *+ * Note: no validation is performed at creation time. When the resulting document is+ * serialized with `requireWellFormed: true`, the serializer throws `InvalidStateError`+ * if the comment data contains `--` anywhere, ends with `-`, or contains characters+ * outside the XML Char production (W3C DOM Parsing §3.2.1.3). Without that option the+ * data is emitted verbatim.+ */+ createComment: function(data) {+ var node = new Comment(PDC);+ node.ownerDocument = this;+ node.childNodes = new NodeList();+ node.appendData(data);+ return node;+ },+ /**+ * Returns a new CDATASection node whose data is `data`.+ *+ * __This implementation differs from the specification:__ - calling this method on an HTML+ * document does not throw `NotSupportedError`.+ *+ * @param {string} data+ * @returns {CDATASection}+ * @throws {DOMException}+ * With code `INVALID_CHARACTER_ERR` if `data` contains `"]]>"`.+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createCDATASection+ * @see https://dom.spec.whatwg.org/#dom-document-createcdatasection+ */+ createCDATASection: function(data) {+ if (data.indexOf("]]>") !== -1) {+ throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'data contains "]]>"');+ }+ var node = new CDATASection(PDC);+ node.ownerDocument = this;+ node.childNodes = new NodeList();+ node.appendData(data);+ return node;+ },+ /**+ * Returns a ProcessingInstruction node whose target is target and data is data.+ *+ * __This behavior is slightly different from the in the specs__:+ * - it does not do any input validation on the arguments and doesn't throw+ * "InvalidCharacterError".+ *+ * Note: When the resulting document is serialized with `requireWellFormed: true`, the+ * serializer throws `InvalidStateError` if `.target` is not a valid XML `NCName` (a `Name`+ * with no colon) or is an ASCII case-insensitive match for `"xml"`, or if `.data` contains+ * `?>` or characters outside the XML Char production (W3C DOM Parsing §3.2.1.7). Without that+ * option the target and data are emitted verbatim.+ *+ * @param {string} target+ * @param {string} data+ * @returns {ProcessingInstruction}+ * @see https://developer.mozilla.org/docs/Web/API/Document/createProcessingInstruction+ * @see https://dom.spec.whatwg.org/#dom-document-createprocessinginstruction+ * @see https://www.w3.org/TR/DOM-Parsing/#dfn-concept-serialize-xml §3.2.1.7+ */+ createProcessingInstruction: function(target, data) {+ var node = new ProcessingInstruction(PDC);+ node.ownerDocument = this;+ node.childNodes = new NodeList();+ node.nodeName = node.target = target;+ node.nodeValue = node.data = data;+ return node;+ },+ /**+ * Creates an `Attr` node that is owned by this document.+ * In HTML Documents `localName` is the lower cased `name`,+ * otherwise no transformation is being applied.+ *+ * __This implementation differs from the specification:__ - The provided name is not checked+ * against the `Name` production,+ * so no related error will be thrown.+ *+ * @param {string} name+ * @returns {Attr}+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/createAttribute+ * @see https://dom.spec.whatwg.org/#dom-document-createattribute+ */+ createAttribute: function(name) {+ if (!g.QName_exact.test(name)) {+ throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'invalid character in name "' + name + '"');+ }+ if (this.type === "html") {+ name = name.toLowerCase();+ }+ return this._createAttribute(name);+ },+ _createAttribute: function(name) {+ var node = new Attr(PDC);+ node.ownerDocument = this;+ node.childNodes = new NodeList();+ node.name = name;+ node.nodeName = name;+ node.localName = name;+ node.specified = true;+ return node;+ },+ /**+ * Creates an EntityReference object.+ * The current implementation does not fill the `childNodes` with those of the corresponding+ * `Entity`+ *+ * The `name` is validated against the XML `Name` production at creation time; an invalid name+ * throws `InvalidCharacterError`. When the resulting node is serialized with+ * `requireWellFormed: true`, the serializer re-validates `nodeName` against the XML `Name`+ * production and throws `InvalidStateError` if a later `nodeName` mutation made it invalid;+ * without that option the name is emitted verbatim.+ *+ * __This implementation differs from the specification:__ xmldom does not expand entities —+ * the parser resolves entity references inline and never constructs `EntityReference` nodes,+ * so this method is the only producer.+ *+ * @deprecated+ * In DOM Level 4.+ * @param {string} name+ * The name of the entity to reference. No namespace well-formedness checks are performed.+ * @returns {EntityReference}+ * @throws {DOMException}+ * With code `INVALID_CHARACTER_ERR` when `name` is not a valid XML `Name`.+ * @throws {DOMException}+ * with code `NOT_SUPPORTED_ERR` when the document is of type `html`+ * @see https://www.w3.org/TR/DOM-Level-3-Core/core.html#ID-392B75AE+ */+ createEntityReference: function(name) {+ if (!g.Name_exact.test(name)) {+ throw new DOMException(DOMException.INVALID_CHARACTER_ERR, 'not a valid xml name "' + name + '"');+ }+ if (this.type === "html") {+ throw new DOMException("document is an html document", DOMExceptionName.NotSupportedError);+ }+ var node = new EntityReference(PDC);+ node.ownerDocument = this;+ node.childNodes = new NodeList();+ node.nodeName = name;+ return node;+ },+ // Introduced in DOM Level 2:+ /**+ * @param {string} namespaceURI+ * @param {string} qualifiedName+ * @returns {Element}+ */+ createElementNS: function(namespaceURI, qualifiedName) {+ var validated = validateAndExtract(namespaceURI, qualifiedName);+ var node = new Element(PDC);+ var attrs = node.attributes = new NamedNodeMap();+ node.childNodes = new NodeList();+ node.ownerDocument = this;+ node.nodeName = qualifiedName;+ node.tagName = qualifiedName;+ node.namespaceURI = validated[0];+ node.prefix = validated[1];+ node.localName = validated[2];+ attrs._ownerElement = node;+ return node;+ },+ // Introduced in DOM Level 2:+ /**+ * @param {string} namespaceURI+ * @param {string} qualifiedName+ * @returns {Attr}+ */+ createAttributeNS: function(namespaceURI, qualifiedName) {+ var validated = validateAndExtract(namespaceURI, qualifiedName);+ var node = new Attr(PDC);+ node.ownerDocument = this;+ node.childNodes = new NodeList();+ node.nodeName = qualifiedName;+ node.name = qualifiedName;+ node.specified = true;+ node.namespaceURI = validated[0];+ node.prefix = validated[1];+ node.localName = validated[2];+ return node;+ }+ };+ _extends(Document, Node);+ function Element(symbol) {+ checkSymbol(symbol);+ this._nsMap = /* @__PURE__ */ Object.create(null);+ }+ Element.prototype = {+ nodeType: ELEMENT_NODE,+ /**+ * The attributes of this element.+ *+ * @type {NamedNodeMap | null}+ */+ attributes: null,+ getQualifiedName: function() {+ return this.prefix ? this.prefix + ":" + this.localName : this.localName;+ },+ _isInHTMLDocumentAndNamespace: function() {+ return this.ownerDocument.type === "html" && this.namespaceURI === NAMESPACE.HTML;+ },+ /**+ * Implementaton of Level2 Core function hasAttributes.+ *+ * @returns {boolean}+ * True if attribute list is not empty.+ * @see https://www.w3.org/TR/DOM-Level-2-Core/#core-ID-NodeHasAttrs+ */+ hasAttributes: function() {+ return !!(this.attributes && this.attributes.length);+ },+ hasAttribute: function(name) {+ return !!this.getAttributeNode(name);+ },+ /**+ * Returns element’s first attribute whose qualified name is `name`, and `null`+ * if there is no such attribute.+ *+ * @param {string} name+ * @returns {string | null}+ */+ getAttribute: function(name) {+ var attr = this.getAttributeNode(name);+ return attr ? attr.value : null;+ },+ getAttributeNode: function(name) {+ if (this._isInHTMLDocumentAndNamespace()) {+ name = name.toLowerCase();+ }+ return this.attributes.getNamedItem(name);+ },+ /**+ * Sets the value of element’s first attribute whose qualified name is qualifiedName to value.+ *+ * @param {string} name+ * @param {string} value+ */+ setAttribute: function(name, value) {+ if (this._isInHTMLDocumentAndNamespace()) {+ name = name.toLowerCase();+ }+ var attr = this.getAttributeNode(name);+ if (attr) {+ attr.value = attr.nodeValue = "" + value;+ } else {+ attr = this.ownerDocument._createAttribute(name);+ attr.value = attr.nodeValue = "" + value;+ this.setAttributeNode(attr);+ }+ },+ removeAttribute: function(name) {+ var attr = this.getAttributeNode(name);+ attr && this.removeAttributeNode(attr);+ },+ setAttributeNode: function(newAttr) {+ return this.attributes.setNamedItem(newAttr);+ },+ setAttributeNodeNS: function(newAttr) {+ return this.attributes.setNamedItemNS(newAttr);+ },+ removeAttributeNode: function(oldAttr) {+ return this.attributes.removeNamedItem(oldAttr.nodeName);+ },+ //get real attribute name,and remove it by removeAttributeNode+ removeAttributeNS: function(namespaceURI, localName) {+ var old = this.getAttributeNodeNS(namespaceURI, localName);+ old && this.removeAttributeNode(old);+ },+ hasAttributeNS: function(namespaceURI, localName) {+ return this.getAttributeNodeNS(namespaceURI, localName) != null;+ },+ /**+ * Returns element’s attribute whose namespace is `namespaceURI` and local name is+ * `localName`,+ * or `null` if there is no such attribute.+ *+ * @param {string} namespaceURI+ * @param {string} localName+ * @returns {string | null}+ */+ getAttributeNS: function(namespaceURI, localName) {+ var attr = this.getAttributeNodeNS(namespaceURI, localName);+ return attr ? attr.value : null;+ },+ /**+ * Sets the value of element’s attribute whose namespace is `namespaceURI` and local name is+ * `localName` to value.+ *+ * @param {string} namespaceURI+ * @param {string} qualifiedName+ * @param {string} value+ * @see https://dom.spec.whatwg.org/#dom-element-setattributens+ */+ setAttributeNS: function(namespaceURI, qualifiedName, value) {+ var validated = validateAndExtract(namespaceURI, qualifiedName);+ var localName = validated[2];+ var attr = this.getAttributeNodeNS(namespaceURI, localName);+ if (attr) {+ attr.value = attr.nodeValue = "" + value;+ } else {+ attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);+ attr.value = attr.nodeValue = "" + value;+ this.setAttributeNode(attr);+ }+ },+ getAttributeNodeNS: function(namespaceURI, localName) {+ return this.attributes.getNamedItemNS(namespaceURI, localName);+ },+ /**+ * Returns a LiveNodeList of all child elements which have **all** of the given class name(s).+ *+ * Returns an empty list if `classNames` is an empty string or only contains HTML white space+ * characters.+ *+ * Warning: This returns a live LiveNodeList.+ * Changes in the DOM will reflect in the array as the changes occur.+ * If an element selected by this array no longer qualifies for the selector,+ * it will automatically be removed. Be aware of this for iteration purposes.+ *+ * @param {string} classNames+ * Is a string representing the class name(s) to match; multiple class names are separated by+ * (ASCII-)whitespace.+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByClassName+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/getElementsByClassName+ * @see https://dom.spec.whatwg.org/#concept-getelementsbyclassname+ */+ getElementsByClassName: function(classNames) {+ var classNamesSet = toOrderedSet(classNames);+ return new LiveNodeList(this, function(base) {+ var ls = [];+ if (classNamesSet.length > 0) {+ _visitNode(base, function(node) {+ if (node !== base && node.nodeType === ELEMENT_NODE) {+ var nodeClassNames = node.getAttribute("class");+ if (nodeClassNames) {+ var matches = classNames === nodeClassNames;+ if (!matches) {+ var nodeClassNamesSet = toOrderedSet(nodeClassNames);+ matches = classNamesSet.every(arrayIncludes(nodeClassNamesSet));+ }+ if (matches) {+ ls.push(node);+ }+ }+ }+ });+ }+ return ls;+ });+ },+ /**+ * Returns a LiveNodeList of elements with the given qualifiedName.+ * Searching for all descendants can be done by passing `*` as `qualifiedName`.+ *+ * All descendants of the specified element are searched, but not the element itself.+ * The returned list is live, which means it updates itself with the DOM tree automatically.+ * Therefore, there is no need to call `Element.getElementsByTagName()`+ * with the same element and arguments repeatedly if the DOM changes in between calls.+ *+ * When called on an HTML element in an HTML document,+ * `getElementsByTagName` lower-cases the argument before searching for it.+ * This is undesirable when trying to match camel-cased SVG elements (such as+ * `<linearGradient>`) in an HTML document.+ * Instead, use `Element.getElementsByTagNameNS()`,+ * which preserves the capitalization of the tag name.+ *+ * `Element.getElementsByTagName` is similar to `Document.getElementsByTagName()`,+ * except that it only searches for elements that are descendants of the specified element.+ *+ * @param {string} qualifiedName+ * @returns {LiveNodeList}+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/getElementsByTagName+ * @see https://dom.spec.whatwg.org/#concept-getelementsbytagname+ */+ getElementsByTagName: function(qualifiedName) {+ var isHTMLDocument = (this.nodeType === DOCUMENT_NODE ? this : this.ownerDocument).type === "html";+ var lowerQualifiedName = qualifiedName.toLowerCase();+ return new LiveNodeList(this, function(base) {+ var ls = [];+ _visitNode(base, function(node) {+ if (node === base || node.nodeType !== ELEMENT_NODE) {+ return;+ }+ if (qualifiedName === "*") {+ ls.push(node);+ } else {+ var nodeQualifiedName = node.getQualifiedName();+ var matchingQName = isHTMLDocument && node.namespaceURI === NAMESPACE.HTML ? lowerQualifiedName : qualifiedName;+ if (nodeQualifiedName === matchingQName) {+ ls.push(node);+ }+ }+ });+ return ls;+ });+ },+ getElementsByTagNameNS: function(namespaceURI, localName) {+ return new LiveNodeList(this, function(base) {+ var ls = [];+ _visitNode(base, function(node) {+ if (node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === "*" || node.namespaceURI === namespaceURI) && (localName === "*" || node.localName == localName)) {+ ls.push(node);+ }+ });+ return ls;+ });+ }+ };+ Document.prototype.getElementsByClassName = Element.prototype.getElementsByClassName;+ Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;+ Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;+ _extends(Element, Node);+ function Attr(symbol) {+ checkSymbol(symbol);+ this.namespaceURI = null;+ this.prefix = null;+ this.ownerElement = null;+ }+ Attr.prototype.nodeType = ATTRIBUTE_NODE;+ _extends(Attr, Node);+ function CharacterData(symbol) {+ checkSymbol(symbol);+ }+ CharacterData.prototype = {+ data: "",+ substringData: function(offset, count) {+ return this.data.substring(offset, offset + count);+ },+ appendData: function(text) {+ text = this.data + text;+ this.nodeValue = this.data = text;+ this.length = text.length;+ },+ insertData: function(offset, text) {+ this.replaceData(offset, 0, text);+ },+ deleteData: function(offset, count) {+ this.replaceData(offset, count, "");+ },+ replaceData: function(offset, count, text) {+ var start = this.data.substring(0, offset);+ var end = this.data.substring(offset + count);+ text = start + text + end;+ this.nodeValue = this.data = text;+ this.length = text.length;+ }+ };+ _extends(CharacterData, Node);+ function Text(symbol) {+ checkSymbol(symbol);+ }+ Text.prototype = {+ nodeName: "#text",+ nodeType: TEXT_NODE,+ splitText: function(offset) {+ var text = this.data;+ var newText = text.substring(offset);+ text = text.substring(0, offset);+ this.data = this.nodeValue = text;+ this.length = text.length;+ var newNode = this.ownerDocument.createTextNode(newText);+ if (this.parentNode) {+ this.parentNode.insertBefore(newNode, this.nextSibling);+ }+ return newNode;+ }+ };+ _extends(Text, CharacterData);+ function Comment(symbol) {+ checkSymbol(symbol);+ }+ Comment.prototype = {+ nodeName: "#comment",+ nodeType: COMMENT_NODE+ };+ _extends(Comment, CharacterData);+ function CDATASection(symbol) {+ checkSymbol(symbol);+ }+ CDATASection.prototype = {+ nodeName: "#cdata-section",+ nodeType: CDATA_SECTION_NODE+ };+ _extends(CDATASection, Text);+ function DocumentType(symbol) {+ checkSymbol(symbol);+ }+ DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;+ _extends(DocumentType, Node);+ function Notation(symbol) {+ checkSymbol(symbol);+ }+ Notation.prototype.nodeType = NOTATION_NODE;+ _extends(Notation, Node);+ function Entity(symbol) {+ checkSymbol(symbol);+ }+ Entity.prototype.nodeType = ENTITY_NODE;+ _extends(Entity, Node);+ function EntityReference(symbol) {+ checkSymbol(symbol);+ }+ EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;+ _extends(EntityReference, Node);+ function DocumentFragment(symbol) {+ checkSymbol(symbol);+ }+ DocumentFragment.prototype.nodeName = "#document-fragment";+ DocumentFragment.prototype.nodeType = DOCUMENT_FRAGMENT_NODE;+ _extends(DocumentFragment, Node);+ function ProcessingInstruction(symbol) {+ checkSymbol(symbol);+ }+ ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;+ _extends(ProcessingInstruction, CharacterData);+ function XMLSerializer2() {+ }+ XMLSerializer2.prototype.serializeToString = function(node, options) {+ return nodeSerializeToString.call(node, options);+ };+ Node.prototype.toString = nodeSerializeToString;+ function nodeSerializeToString(options) {+ var opts;+ if (typeof options === "function") {+ opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: options };+ } else if (options != null) {+ opts = {+ requireWellFormed: !!options.requireWellFormed,+ splitCDATASections: options.splitCDATASections !== false,+ nodeFilter: options.nodeFilter || null+ };+ } else {+ opts = { requireWellFormed: false, splitCDATASections: true, nodeFilter: null };+ }+ var buf = [];+ var refNode = this.nodeType === DOCUMENT_NODE && this.documentElement || this;+ var prefix = refNode.prefix;+ var uri = refNode.namespaceURI;+ if (uri && prefix == null) {+ var prefix = refNode.lookupPrefix(uri);+ if (prefix == null) {+ var visibleNamespaces = [+ { namespace: uri, prefix: null }+ //{namespace:uri,prefix:''}+ ];+ }+ }+ serializeToString(this, buf, visibleNamespaces, opts);+ return buf.join("");+ }+ function needNamespaceDefine(node, isHTML, visibleNamespaces) {+ var prefix = node.prefix || "";+ var uri = node.namespaceURI;+ if (!uri) {+ return false;+ }+ if (prefix === "xml" && uri === NAMESPACE.XML || uri === NAMESPACE.XMLNS) {+ return false;+ }+ var i = visibleNamespaces.length;+ while (i--) {+ var ns = visibleNamespaces[i];+ if (ns.prefix === prefix) {+ return ns.namespace !== uri;+ }+ }+ return true;+ }+ function addSerializedAttribute(buf, qualifiedName, value, requireWellFormed) {+ if (requireWellFormed && !g.QName_exact.test(qualifiedName)) {+ throw new DOMException(+ 'The attribute name "' + qualifiedName + '" is not a valid XML QName',+ DOMExceptionName.InvalidStateError+ );+ }+ buf.push(" ", qualifiedName, '="', value.replace(/[<>&"\t\n\r]/g, _xmlEncoder), '"');+ }+ function serializeToString(node, buf, visibleNamespaces, opts) {+ if (!visibleNamespaces) {+ visibleNamespaces = [];+ }+ var nodeFilter = opts.nodeFilter;+ var requireWellFormed = opts.requireWellFormed;+ var splitCDATASections = opts.splitCDATASections;+ var doc = node.nodeType === DOCUMENT_NODE ? node : node.ownerDocument;+ var isHTML = doc.type === "html";+ walkDOM(+ node,+ { ns: visibleNamespaces },+ {+ enter: function(n, ctx) {+ var namespaces = ctx.ns;+ if (nodeFilter) {+ n = nodeFilter(n);+ if (n) {+ if (typeof n == "string") {+ buf.push(n);+ return null;+ }+ } else {+ return null;+ }+ }+ switch (n.nodeType) {+ case ELEMENT_NODE:+ var attrs = n.attributes;+ var len = attrs.length;+ var nodeName = n.tagName;+ var prefixedNodeName = nodeName;+ if (!isHTML && !n.prefix && n.namespaceURI) {+ var defaultNS;+ for (var ai = 0; ai < attrs.length; ai++) {+ if (attrs.item(ai).name === "xmlns") {+ defaultNS = attrs.item(ai).value;+ break;+ }+ }+ if (!defaultNS) {+ for (var nsi = namespaces.length - 1; nsi >= 0; nsi--) {+ var nsEntry = namespaces[nsi];+ if (nsEntry.prefix === "" && nsEntry.namespace === n.namespaceURI) {+ defaultNS = nsEntry.namespace;+ break;+ }+ }+ }+ if (defaultNS !== n.namespaceURI) {+ for (var nsi = namespaces.length - 1; nsi >= 0; nsi--) {+ var nsEntry = namespaces[nsi];+ if (nsEntry.namespace === n.namespaceURI) {+ if (nsEntry.prefix) {+ prefixedNodeName = nsEntry.prefix + ":" + nodeName;+ }+ break;+ }+ }+ }+ }+ if (requireWellFormed && !g.QName_exact.test(prefixedNodeName)) {+ throw new DOMException(+ 'The element name "' + prefixedNodeName + '" is not a valid XML QName',+ DOMExceptionName.InvalidStateError+ );+ }+ buf.push("<", prefixedNodeName);+ var childNamespaces = namespaces.slice();+ for (var i = 0; i < len; i++) {+ var attr = attrs.item(i);+ if (attr.prefix == "xmlns") {+ childNamespaces.push({+ prefix: attr.localName,+ namespace: attr.value+ });+ } else if (attr.nodeName == "xmlns") {+ childNamespaces.push({ prefix: "", namespace: attr.value });+ }+ }+ for (var i = 0; i < len; i++) {+ var attr = attrs.item(i);+ if (needNamespaceDefine(attr, isHTML, childNamespaces)) {+ var attrPrefix = attr.prefix || "";+ var uri = attr.namespaceURI;+ addSerializedAttribute(buf, attrPrefix ? "xmlns:" + attrPrefix : "xmlns", uri, requireWellFormed);+ childNamespaces.push({ prefix: attrPrefix, namespace: uri });+ }+ var filteredAttr = nodeFilter ? nodeFilter(attr) : attr;+ if (filteredAttr) {+ if (typeof filteredAttr === "string") {+ buf.push(filteredAttr);+ } else {+ addSerializedAttribute(buf, filteredAttr.name, filteredAttr.value, requireWellFormed);+ }+ }+ }+ if (nodeName === prefixedNodeName && needNamespaceDefine(n, isHTML, childNamespaces)) {+ var nodePrefix = n.prefix || "";+ var uri = n.namespaceURI;+ addSerializedAttribute(buf, nodePrefix ? "xmlns:" + nodePrefix : "xmlns", uri, requireWellFormed);+ childNamespaces.push({ prefix: nodePrefix, namespace: uri });+ }+ var canCloseTag = !n.firstChild;+ if (canCloseTag && (isHTML || n.namespaceURI === NAMESPACE.HTML)) {+ canCloseTag = isHTMLVoidElement(nodeName);+ }+ if (canCloseTag) {+ buf.push("/>");+ return null;+ }+ buf.push(">");+ if (isHTML && isHTMLRawTextElement(nodeName)) {+ var child2 = n.firstChild;+ while (child2) {+ if (child2.data) {+ buf.push(child2.data);+ } else {+ serializeToString(child2, buf, childNamespaces.slice(), opts);+ }+ child2 = child2.nextSibling;+ }+ buf.push("</", prefixedNodeName, ">");+ return null;+ }+ return { ns: childNamespaces, tag: prefixedNodeName };+ case DOCUMENT_NODE:+ case DOCUMENT_FRAGMENT_NODE:+ if (requireWellFormed && n.nodeType === DOCUMENT_NODE && n.documentElement == null) {+ throw new DOMException("The Document has no documentElement", DOMExceptionName.InvalidStateError);+ }+ return { ns: namespaces };+ case ATTRIBUTE_NODE:+ addSerializedAttribute(buf, n.name, n.value, requireWellFormed);+ return null;+ case TEXT_NODE:+ if (requireWellFormed && g.InvalidChar.test(n.data)) {+ throw new DOMException(+ "The Text node data contains characters outside the XML Char production",+ DOMExceptionName.InvalidStateError+ );+ }+ buf.push(n.data.replace(/[<&>]/g, _xmlEncoder));+ return null;+ case CDATA_SECTION_NODE:+ if (requireWellFormed && n.data.indexOf("]]>") !== -1) {+ throw new DOMException('The CDATASection data contains "]]>"', DOMExceptionName.InvalidStateError);+ }+ if (splitCDATASections) {+ buf.push(g.CDATA_START, n.data.replace(/]]>/g, "]]]]><![CDATA[>"), g.CDATA_END);+ } else {+ buf.push(g.CDATA_START, n.data, g.CDATA_END);+ }+ return null;+ case COMMENT_NODE:+ if (requireWellFormed) {+ if (g.InvalidChar.test(n.data)) {+ throw new DOMException(+ "The comment node data contains characters outside the XML Char production",+ DOMExceptionName.InvalidStateError+ );+ }+ if (n.data.indexOf("--") !== -1 || n.data[n.data.length - 1] === "-") {+ throw new DOMException(+ 'The comment node data contains "--" or ends with "-"',+ DOMExceptionName.InvalidStateError+ );+ }+ }+ buf.push(g.COMMENT_START, n.data, g.COMMENT_END);+ return null;+ case DOCUMENT_TYPE_NODE:+ var pubid = n.publicId;+ var sysid = n.systemId;+ if (requireWellFormed) {+ if (!g.Name_exact.test(n.name)) {+ throw new DOMException(+ 'The doctype name "' + n.name + '" is not a valid XML Name',+ DOMExceptionName.InvalidStateError+ );+ }+ if (pubid && !g.PubidLiteral_match.test(pubid)) {+ throw new DOMException("DocumentType publicId is not a valid PubidLiteral", DOMExceptionName.InvalidStateError);+ }+ if (sysid && sysid !== "." && !g.SystemLiteral_match.test(sysid)) {+ throw new DOMException("DocumentType systemId is not a valid SystemLiteral", DOMExceptionName.InvalidStateError);+ }+ if (n.internalSubset && n.internalSubset.indexOf("]>") !== -1) {+ throw new DOMException('DocumentType internalSubset contains "]>"', DOMExceptionName.InvalidStateError);+ }+ }+ buf.push(g.DOCTYPE_DECL_START, " ", n.name);+ if (pubid) {+ buf.push(" ", g.PUBLIC, " ", pubid);+ if (sysid && sysid !== ".") {+ buf.push(" ", sysid);+ }+ } else if (sysid && sysid !== ".") {+ buf.push(" ", g.SYSTEM, " ", sysid);+ }+ if (n.internalSubset) {+ buf.push(" [", n.internalSubset, "]");+ }+ buf.push(">");+ return null;+ case PROCESSING_INSTRUCTION_NODE:+ if (requireWellFormed) {+ if (!g.NCName_exact.test(n.target) || n.target.toLowerCase() === "xml") {+ throw new DOMException(+ 'The processing instruction target "' + n.target + '" is not a valid XML NCName or is reserved',+ DOMExceptionName.InvalidStateError+ );+ }+ if (g.InvalidChar.test(n.data)) {+ throw new DOMException(+ "The ProcessingInstruction data contains characters outside the XML Char production",+ DOMExceptionName.InvalidStateError+ );+ }+ if (n.data.indexOf("?>") !== -1) {+ throw new DOMException('The ProcessingInstruction data contains "?>"', DOMExceptionName.InvalidStateError);+ }+ }+ buf.push("<?", n.target, " ", n.data, "?>");+ return null;+ case ENTITY_REFERENCE_NODE:+ if (requireWellFormed && !g.Name_exact.test(n.nodeName)) {+ throw new DOMException(+ 'The entity reference name "' + n.nodeName + '" is not a valid XML Name',+ DOMExceptionName.InvalidStateError+ );+ }+ buf.push("&", n.nodeName, ";");+ return null;+ //case ENTITY_NODE:+ //case NOTATION_NODE:+ default:+ buf.push("??", n.nodeName);+ return null;+ }+ },+ exit: function(n, childCtx) {+ if (childCtx && childCtx.tag) {+ buf.push("</", childCtx.tag, ">");+ }+ }+ }+ );+ }+ function importNode(doc, node, deep) {+ var destRoot;+ walkDOM(node, null, {+ enter: function(srcNode, destParent) {+ var destNode = srcNode.cloneNode(false);+ destNode.ownerDocument = doc;+ destNode.parentNode = null;+ if (destParent === null) {+ destRoot = destNode;+ } else {+ destParent.appendChild(destNode);+ }+ var shouldDeep = srcNode.nodeType === ATTRIBUTE_NODE || deep;+ return shouldDeep ? destNode : null;+ }+ });+ return destRoot;+ }+ function cloneNode(doc, node, deep) {+ var destRoot;+ walkDOM(node, null, {+ enter: function(srcNode, destParent) {+ var destNode = new srcNode.constructor(PDC);+ for (var n in srcNode) {+ if (hasOwn(srcNode, n)) {+ var v = srcNode[n];+ if (typeof v != "object") {+ if (v != destNode[n]) {+ destNode[n] = v;+ }+ }+ }+ }+ if (srcNode.childNodes) {+ destNode.childNodes = new NodeList();+ }+ destNode.ownerDocument = doc;+ var shouldDeep = deep;+ switch (destNode.nodeType) {+ case ELEMENT_NODE:+ var attrs = srcNode.attributes;+ var attrs2 = destNode.attributes = new NamedNodeMap();+ var len = attrs.length;+ attrs2._ownerElement = destNode;+ for (var i = 0; i < len; i++) {+ destNode.setAttributeNode(cloneNode(doc, attrs.item(i), true));+ }+ break;+ case ATTRIBUTE_NODE:+ shouldDeep = true;+ }+ if (destParent !== null) {+ destParent.appendChild(destNode);+ } else {+ destRoot = destNode;+ }+ return shouldDeep ? destNode : null;+ }+ });+ return destRoot;+ }+ function __set__(object, key, value) {+ object[key] = value;+ }+ function childrenRefresh(node) {+ var ls = [];+ var child2 = node.firstChild;+ while (child2) {+ if (child2.nodeType === ELEMENT_NODE) {+ ls.push(child2);+ }+ child2 = child2.nextSibling;+ }+ return ls;+ }+ try {+ if (Object.defineProperty) {+ Object.defineProperty(LiveNodeList.prototype, "length", {+ get: function() {+ _updateLiveList(this);+ return this.$$length;+ }+ });+ Object.defineProperty(Node.prototype, "textContent", {+ get: function() {+ if (this.nodeType === ELEMENT_NODE || this.nodeType === DOCUMENT_FRAGMENT_NODE) {+ var buf = [];+ walkDOM(this, null, {+ enter: function(n) {+ if (n.nodeType === ELEMENT_NODE || n.nodeType === DOCUMENT_FRAGMENT_NODE) {+ return true;+ }+ if (n.nodeType === PROCESSING_INSTRUCTION_NODE || n.nodeType === COMMENT_NODE) {+ return null;+ }+ buf.push(n.nodeValue);+ }+ });+ return buf.join("");+ }+ return this.nodeValue;+ },+ set: function(data) {+ switch (this.nodeType) {+ case ELEMENT_NODE:+ case DOCUMENT_FRAGMENT_NODE:+ while (this.firstChild) {+ this.removeChild(this.firstChild);+ }+ if (data || String(data)) {+ this.appendChild(this.ownerDocument.createTextNode(data));+ }+ break;+ default:+ this.data = data;+ this.value = data;+ this.nodeValue = data;+ }+ }+ });+ Object.defineProperty(CharacterData.prototype, "data", {+ get: function() {+ return this._data != null ? this._data : "";+ },+ set: function(v) {+ this._data = v;+ this.length = typeof v === "string" ? v.length : 0;+ }+ });+ Object.defineProperty(CharacterData.prototype, "nodeValue", {+ get: function() {+ return this.data;+ },+ set: function(v) {+ this.data = v;+ },+ enumerable: true,+ configurable: true+ });+ Object.defineProperty(Element.prototype, "children", {+ get: function() {+ return new LiveNodeList(this, childrenRefresh);+ }+ });+ Object.defineProperty(Document.prototype, "children", {+ get: function() {+ return new LiveNodeList(this, childrenRefresh);+ }+ });+ Object.defineProperty(DocumentFragment.prototype, "children", {+ get: function() {+ return new LiveNodeList(this, childrenRefresh);+ }+ });+ __set__ = function(object, key, value) {+ object["$$" + key] = value;+ };+ }+ } catch (e) {+ }+ exports._updateLiveList = _updateLiveList;+ exports.Attr = Attr;+ exports.CDATASection = CDATASection;+ exports.CharacterData = CharacterData;+ exports.Comment = Comment;+ exports.Document = Document;+ exports.DocumentFragment = DocumentFragment;+ exports.DocumentType = DocumentType;+ exports.DOMImplementation = DOMImplementation;+ exports.Element = Element;+ exports.Entity = Entity;+ exports.EntityReference = EntityReference;+ exports.LiveNodeList = LiveNodeList;+ exports.NamedNodeMap = NamedNodeMap;+ exports.Node = Node;+ exports.NodeList = NodeList;+ exports.Notation = Notation;+ exports.Text = Text;+ exports.ProcessingInstruction = ProcessingInstruction;+ exports.walkDOM = walkDOM;+ exports.XMLSerializer = XMLSerializer2;+ }+});++// node_modules/@xmldom/xmldom/lib/entities.js+var require_entities = __commonJS({+ "node_modules/@xmldom/xmldom/lib/entities.js"(exports) {+ "use strict";+ var freeze = require_conventions().freeze;+ exports.XML_ENTITIES = freeze({+ amp: "&",+ apos: "'",+ gt: ">",+ lt: "<",+ quot: '"'+ });+ exports.HTML_ENTITIES = freeze({+ Aacute: "Á",+ aacute: "á",+ Abreve: "Ă",+ abreve: "ă",+ ac: "∾",+ acd: "∿",+ acE: "∾̳",+ Acirc: "Â",+ acirc: "â",+ acute: "´",+ Acy: "А",+ acy: "а",+ AElig: "Æ",+ aelig: "æ",+ af: "",+ Afr: "𝔄",+ afr: "𝔞",+ Agrave: "À",+ agrave: "à",+ alefsym: "ℵ",+ aleph: "ℵ",+ Alpha: "Α",+ alpha: "α",+ Amacr: "Ā",+ amacr: "ā",+ amalg: "⨿",+ AMP: "&",+ amp: "&",+ And: "⩓",+ and: "∧",+ andand: "⩕",+ andd: "⩜",+ andslope: "⩘",+ andv: "⩚",+ ang: "∠",+ ange: "⦤",+ angle: "∠",+ angmsd: "∡",+ angmsdaa: "⦨",+ angmsdab: "⦩",+ angmsdac: "⦪",+ angmsdad: "⦫",+ angmsdae: "⦬",+ angmsdaf: "⦭",+ angmsdag: "⦮",+ angmsdah: "⦯",+ angrt: "∟",+ angrtvb: "⊾",+ angrtvbd: "⦝",+ angsph: "∢",+ angst: "Å",+ angzarr: "⍼",+ Aogon: "Ą",+ aogon: "ą",+ Aopf: "𝔸",+ aopf: "𝕒",+ ap: "≈",+ apacir: "⩯",+ apE: "⩰",+ ape: "≊",+ apid: "≋",+ apos: "'",+ ApplyFunction: "",+ approx: "≈",+ approxeq: "≊",+ Aring: "Å",+ aring: "å",+ Ascr: "𝒜",+ ascr: "𝒶",+ Assign: "≔",+ ast: "*",+ asymp: "≈",+ asympeq: "≍",+ Atilde: "Ã",+ atilde: "ã",+ Auml: "Ä",+ auml: "ä",+ awconint: "∳",+ awint: "⨑",+ backcong: "≌",+ backepsilon: "϶",+ backprime: "‵",+ backsim: "∽",+ backsimeq: "⋍",+ Backslash: "∖",+ Barv: "⫧",+ barvee: "⊽",+ Barwed: "⌆",+ barwed: "⌅",+ barwedge: "⌅",+ bbrk: "⎵",+ bbrktbrk: "⎶",+ bcong: "≌",+ Bcy: "Б",+ bcy: "б",+ bdquo: "„",+ becaus: "∵",+ Because: "∵",+ because: "∵",+ bemptyv: "⦰",+ bepsi: "϶",+ bernou: "ℬ",+ Bernoullis: "ℬ",+ Beta: "Β",+ beta: "β",+ beth: "ℶ",+ between: "≬",+ Bfr: "𝔅",+ bfr: "𝔟",+ bigcap: "⋂",+ bigcirc: "◯",+ bigcup: "⋃",+ bigodot: "⨀",+ bigoplus: "⨁",+ bigotimes: "⨂",+ bigsqcup: "⨆",+ bigstar: "★",+ bigtriangledown: "▽",+ bigtriangleup: "△",+ biguplus: "⨄",+ bigvee: "⋁",+ bigwedge: "⋀",+ bkarow: "⤍",+ blacklozenge: "⧫",+ blacksquare: "▪",+ blacktriangle: "▴",+ blacktriangledown: "▾",+ blacktriangleleft: "◂",+ blacktriangleright: "▸",+ blank: "␣",+ blk12: "▒",+ blk14: "░",+ blk34: "▓",+ block: "█",+ bne: "=⃥",+ bnequiv: "≡⃥",+ bNot: "⫭",+ bnot: "⌐",+ Bopf: "𝔹",+ bopf: "𝕓",+ bot: "⊥",+ bottom: "⊥",+ bowtie: "⋈",+ boxbox: "⧉",+ boxDL: "╗",+ boxDl: "╖",+ boxdL: "╕",+ boxdl: "┐",+ boxDR: "╔",+ boxDr: "╓",+ boxdR: "╒",+ boxdr: "┌",+ boxH: "═",+ boxh: "─",+ boxHD: "╦",+ boxHd: "╤",+ boxhD: "╥",+ boxhd: "┬",+ boxHU: "╩",+ boxHu: "╧",+ boxhU: "╨",+ boxhu: "┴",+ boxminus: "⊟",+ boxplus: "⊞",+ boxtimes: "⊠",+ boxUL: "╝",+ boxUl: "╜",+ boxuL: "╛",+ boxul: "┘",+ boxUR: "╚",+ boxUr: "╙",+ boxuR: "╘",+ boxur: "└",+ boxV: "║",+ boxv: "│",+ boxVH: "╬",+ boxVh: "╫",+ boxvH: "╪",+ boxvh: "┼",+ boxVL: "╣",+ boxVl: "╢",+ boxvL: "╡",+ boxvl: "┤",+ boxVR: "╠",+ boxVr: "╟",+ boxvR: "╞",+ boxvr: "├",+ bprime: "‵",+ Breve: "˘",+ breve: "˘",+ brvbar: "¦",+ Bscr: "ℬ",+ bscr: "𝒷",+ bsemi: "⁏",+ bsim: "∽",+ bsime: "⋍",+ bsol: "\\",+ bsolb: "⧅",+ bsolhsub: "⟈",+ bull: "•",+ bullet: "•",+ bump: "≎",+ bumpE: "⪮",+ bumpe: "≏",+ Bumpeq: "≎",+ bumpeq: "≏",+ Cacute: "Ć",+ cacute: "ć",+ Cap: "⋒",+ cap: "∩",+ capand: "⩄",+ capbrcup: "⩉",+ capcap: "⩋",+ capcup: "⩇",+ capdot: "⩀",+ CapitalDifferentialD: "ⅅ",+ caps: "∩︀",+ caret: "⁁",+ caron: "ˇ",+ Cayleys: "ℭ",+ ccaps: "⩍",+ Ccaron: "Č",+ ccaron: "č",+ Ccedil: "Ç",+ ccedil: "ç",+ Ccirc: "Ĉ",+ ccirc: "ĉ",+ Cconint: "∰",+ ccups: "⩌",+ ccupssm: "⩐",+ Cdot: "Ċ",+ cdot: "ċ",+ cedil: "¸",+ Cedilla: "¸",+ cemptyv: "⦲",+ cent: "¢",+ CenterDot: "·",+ centerdot: "·",+ Cfr: "ℭ",+ cfr: "𝔠",+ CHcy: "Ч",+ chcy: "ч",+ check: "✓",+ checkmark: "✓",+ Chi: "Χ",+ chi: "χ",+ cir: "○",+ circ: "ˆ",+ circeq: "≗",+ circlearrowleft: "↺",+ circlearrowright: "↻",+ circledast: "⊛",+ circledcirc: "⊚",+ circleddash: "⊝",+ CircleDot: "⊙",+ circledR: "®",+ circledS: "Ⓢ",+ CircleMinus: "⊖",+ CirclePlus: "⊕",+ CircleTimes: "⊗",+ cirE: "⧃",+ cire: "≗",+ cirfnint: "⨐",+ cirmid: "⫯",+ cirscir: "⧂",+ ClockwiseContourIntegral: "∲",+ CloseCurlyDoubleQuote: "”",+ CloseCurlyQuote: "’",+ clubs: "♣",+ clubsuit: "♣",+ Colon: "∷",+ colon: ":",+ Colone: "⩴",+ colone: "≔",+ coloneq: "≔",+ comma: ",",+ commat: "@",+ comp: "∁",+ compfn: "∘",+ complement: "∁",+ complexes: "ℂ",+ cong: "≅",+ congdot: "⩭",+ Congruent: "≡",+ Conint: "∯",+ conint: "∮",+ ContourIntegral: "∮",+ Copf: "ℂ",+ copf: "𝕔",+ coprod: "∐",+ Coproduct: "∐",+ COPY: "©",+ copy: "©",+ copysr: "℗",+ CounterClockwiseContourIntegral: "∳",+ crarr: "↵",+ Cross: "⨯",+ cross: "✗",+ Cscr: "𝒞",+ cscr: "𝒸",+ csub: "⫏",+ csube: "⫑",+ csup: "⫐",+ csupe: "⫒",+ ctdot: "⋯",+ cudarrl: "⤸",+ cudarrr: "⤵",+ cuepr: "⋞",+ cuesc: "⋟",+ cularr: "↶",+ cularrp: "⤽",+ Cup: "⋓",+ cup: "∪",+ cupbrcap: "⩈",+ CupCap: "≍",+ cupcap: "⩆",+ cupcup: "⩊",+ cupdot: "⊍",+ cupor: "⩅",+ cups: "∪︀",+ curarr: "↷",+ curarrm: "⤼",+ curlyeqprec: "⋞",+ curlyeqsucc: "⋟",+ curlyvee: "⋎",+ curlywedge: "⋏",+ curren: "¤",+ curvearrowleft: "↶",+ curvearrowright: "↷",+ cuvee: "⋎",+ cuwed: "⋏",+ cwconint: "∲",+ cwint: "∱",+ cylcty: "⌭",+ Dagger: "‡",+ dagger: "†",+ daleth: "ℸ",+ Darr: "↡",+ dArr: "⇓",+ darr: "↓",+ dash: "‐",+ Dashv: "⫤",+ dashv: "⊣",+ dbkarow: "⤏",+ dblac: "˝",+ Dcaron: "Ď",+ dcaron: "ď",+ Dcy: "Д",+ dcy: "д",+ DD: "ⅅ",+ dd: "ⅆ",+ ddagger: "‡",+ ddarr: "⇊",+ DDotrahd: "⤑",+ ddotseq: "⩷",+ deg: "°",+ Del: "∇",+ Delta: "Δ",+ delta: "δ",+ demptyv: "⦱",+ dfisht: "⥿",+ Dfr: "𝔇",+ dfr: "𝔡",+ dHar: "⥥",+ dharl: "⇃",+ dharr: "⇂",+ DiacriticalAcute: "´",+ DiacriticalDot: "˙",+ DiacriticalDoubleAcute: "˝",+ DiacriticalGrave: "`",+ DiacriticalTilde: "˜",+ diam: "⋄",+ Diamond: "⋄",+ diamond: "⋄",+ diamondsuit: "♦",+ diams: "♦",+ die: "¨",+ DifferentialD: "ⅆ",+ digamma: "ϝ",+ disin: "⋲",+ div: "÷",+ divide: "÷",+ divideontimes: "⋇",+ divonx: "⋇",+ DJcy: "Ђ",+ djcy: "ђ",+ dlcorn: "⌞",+ dlcrop: "⌍",+ dollar: "$",+ Dopf: "𝔻",+ dopf: "𝕕",+ Dot: "¨",+ dot: "˙",+ DotDot: "⃜",+ doteq: "≐",+ doteqdot: "≑",+ DotEqual: "≐",+ dotminus: "∸",+ dotplus: "∔",+ dotsquare: "⊡",+ doublebarwedge: "⌆",+ DoubleContourIntegral: "∯",+ DoubleDot: "¨",+ DoubleDownArrow: "⇓",+ DoubleLeftArrow: "⇐",+ DoubleLeftRightArrow: "⇔",+ DoubleLeftTee: "⫤",+ DoubleLongLeftArrow: "⟸",+ DoubleLongLeftRightArrow: "⟺",+ DoubleLongRightArrow: "⟹",+ DoubleRightArrow: "⇒",+ DoubleRightTee: "⊨",+ DoubleUpArrow: "⇑",+ DoubleUpDownArrow: "⇕",+ DoubleVerticalBar: "∥",+ DownArrow: "↓",+ Downarrow: "⇓",+ downarrow: "↓",+ DownArrowBar: "⤓",+ DownArrowUpArrow: "⇵",+ DownBreve: "̑",+ downdownarrows: "⇊",+ downharpoonleft: "⇃",+ downharpoonright: "⇂",+ DownLeftRightVector: "⥐",+ DownLeftTeeVector: "⥞",+ DownLeftVector: "↽",+ DownLeftVectorBar: "⥖",+ DownRightTeeVector: "⥟",+ DownRightVector: "⇁",+ DownRightVectorBar: "⥗",+ DownTee: "⊤",+ DownTeeArrow: "↧",+ drbkarow: "⤐",+ drcorn: "⌟",+ drcrop: "⌌",+ Dscr: "𝒟",+ dscr: "𝒹",+ DScy: "Ѕ",+ dscy: "ѕ",+ dsol: "⧶",+ Dstrok: "Đ",+ dstrok: "đ",+ dtdot: "⋱",+ dtri: "▿",+ dtrif: "▾",+ duarr: "⇵",+ duhar: "⥯",+ dwangle: "⦦",+ DZcy: "Џ",+ dzcy: "џ",+ dzigrarr: "⟿",+ Eacute: "É",+ eacute: "é",+ easter: "⩮",+ Ecaron: "Ě",+ ecaron: "ě",+ ecir: "≖",+ Ecirc: "Ê",+ ecirc: "ê",+ ecolon: "≕",+ Ecy: "Э",+ ecy: "э",+ eDDot: "⩷",+ Edot: "Ė",+ eDot: "≑",+ edot: "ė",+ ee: "ⅇ",+ efDot: "≒",+ Efr: "𝔈",+ efr: "𝔢",+ eg: "⪚",+ Egrave: "È",+ egrave: "è",+ egs: "⪖",+ egsdot: "⪘",+ el: "⪙",+ Element: "∈",+ elinters: "⏧",+ ell: "ℓ",+ els: "⪕",+ elsdot: "⪗",+ Emacr: "Ē",+ emacr: "ē",+ empty: "∅",+ emptyset: "∅",+ EmptySmallSquare: "◻",+ emptyv: "∅",+ EmptyVerySmallSquare: "▫",+ emsp: " ",+ emsp13: " ",+ emsp14: " ",+ ENG: "Ŋ",+ eng: "ŋ",+ ensp: " ",+ Eogon: "Ę",+ eogon: "ę",+ Eopf: "𝔼",+ eopf: "𝕖",+ epar: "⋕",+ eparsl: "⧣",+ eplus: "⩱",+ epsi: "ε",+ Epsilon: "Ε",+ epsilon: "ε",+ epsiv: "ϵ",+ eqcirc: "≖",+ eqcolon: "≕",+ eqsim: "≂",+ eqslantgtr: "⪖",+ eqslantless: "⪕",+ Equal: "⩵",+ equals: "=",+ EqualTilde: "≂",+ equest: "≟",+ Equilibrium: "⇌",+ equiv: "≡",+ equivDD: "⩸",+ eqvparsl: "⧥",+ erarr: "⥱",+ erDot: "≓",+ Escr: "ℰ",+ escr: "ℯ",+ esdot: "≐",+ Esim: "⩳",+ esim: "≂",+ Eta: "Η",+ eta: "η",+ ETH: "Ð",+ eth: "ð",+ Euml: "Ë",+ euml: "ë",+ euro: "€",+ excl: "!",+ exist: "∃",+ Exists: "∃",+ expectation: "ℰ",+ ExponentialE: "ⅇ",+ exponentiale: "ⅇ",+ fallingdotseq: "≒",+ Fcy: "Ф",+ fcy: "ф",+ female: "♀",+ ffilig: "ffi",+ fflig: "ff",+ ffllig: "ffl",+ Ffr: "𝔉",+ ffr: "𝔣",+ filig: "fi",+ FilledSmallSquare: "◼",+ FilledVerySmallSquare: "▪",+ fjlig: "fj",+ flat: "♭",+ fllig: "fl",+ fltns: "▱",+ fnof: "ƒ",+ Fopf: "𝔽",+ fopf: "𝕗",+ ForAll: "∀",+ forall: "∀",+ fork: "⋔",+ forkv: "⫙",+ Fouriertrf: "ℱ",+ fpartint: "⨍",+ frac12: "½",+ frac13: "⅓",+ frac14: "¼",+ frac15: "⅕",+ frac16: "⅙",+ frac18: "⅛",+ frac23: "⅔",+ frac25: "⅖",+ frac34: "¾",+ frac35: "⅗",+ frac38: "⅜",+ frac45: "⅘",+ frac56: "⅚",+ frac58: "⅝",+ frac78: "⅞",+ frasl: "⁄",+ frown: "⌢",+ Fscr: "ℱ",+ fscr: "𝒻",+ gacute: "ǵ",+ Gamma: "Γ",+ gamma: "γ",+ Gammad: "Ϝ",+ gammad: "ϝ",+ gap: "⪆",+ Gbreve: "Ğ",+ gbreve: "ğ",+ Gcedil: "Ģ",+ Gcirc: "Ĝ",+ gcirc: "ĝ",+ Gcy: "Г",+ gcy: "г",+ Gdot: "Ġ",+ gdot: "ġ",+ gE: "≧",+ ge: "≥",+ gEl: "⪌",+ gel: "⋛",+ geq: "≥",+ geqq: "≧",+ geqslant: "⩾",+ ges: "⩾",+ gescc: "⪩",+ gesdot: "⪀",+ gesdoto: "⪂",+ gesdotol: "⪄",+ gesl: "⋛︀",+ gesles: "⪔",+ Gfr: "𝔊",+ gfr: "𝔤",+ Gg: "⋙",+ gg: "≫",+ ggg: "⋙",+ gimel: "ℷ",+ GJcy: "Ѓ",+ gjcy: "ѓ",+ gl: "≷",+ gla: "⪥",+ glE: "⪒",+ glj: "⪤",+ gnap: "⪊",+ gnapprox: "⪊",+ gnE: "≩",+ gne: "⪈",+ gneq: "⪈",+ gneqq: "≩",+ gnsim: "⋧",+ Gopf: "𝔾",+ gopf: "𝕘",+ grave: "`",+ GreaterEqual: "≥",+ GreaterEqualLess: "⋛",+ GreaterFullEqual: "≧",+ GreaterGreater: "⪢",+ GreaterLess: "≷",+ GreaterSlantEqual: "⩾",+ GreaterTilde: "≳",+ Gscr: "𝒢",+ gscr: "ℊ",+ gsim: "≳",+ gsime: "⪎",+ gsiml: "⪐",+ Gt: "≫",+ GT: ">",+ gt: ">",+ gtcc: "⪧",+ gtcir: "⩺",+ gtdot: "⋗",+ gtlPar: "⦕",+ gtquest: "⩼",+ gtrapprox: "⪆",+ gtrarr: "⥸",+ gtrdot: "⋗",+ gtreqless: "⋛",+ gtreqqless: "⪌",+ gtrless: "≷",+ gtrsim: "≳",+ gvertneqq: "≩︀",+ gvnE: "≩︀",+ Hacek: "ˇ",+ hairsp: " ",+ half: "½",+ hamilt: "ℋ",+ HARDcy: "Ъ",+ hardcy: "ъ",+ hArr: "⇔",+ harr: "↔",+ harrcir: "⥈",+ harrw: "↭",+ Hat: "^",+ hbar: "ℏ",+ Hcirc: "Ĥ",+ hcirc: "ĥ",+ hearts: "♥",+ heartsuit: "♥",+ hellip: "…",+ hercon: "⊹",+ Hfr: "ℌ",+ hfr: "𝔥",+ HilbertSpace: "ℋ",+ hksearow: "⤥",+ hkswarow: "⤦",+ hoarr: "⇿",+ homtht: "∻",+ hookleftarrow: "↩",+ hookrightarrow: "↪",+ Hopf: "ℍ",+ hopf: "𝕙",+ horbar: "―",+ HorizontalLine: "─",+ Hscr: "ℋ",+ hscr: "𝒽",+ hslash: "ℏ",+ Hstrok: "Ħ",+ hstrok: "ħ",+ HumpDownHump: "≎",+ HumpEqual: "≏",+ hybull: "⁃",+ hyphen: "‐",+ Iacute: "Í",+ iacute: "í",+ ic: "",+ Icirc: "Î",+ icirc: "î",+ Icy: "И",+ icy: "и",+ Idot: "İ",+ IEcy: "Е",+ iecy: "е",+ iexcl: "¡",+ iff: "⇔",+ Ifr: "ℑ",+ ifr: "𝔦",+ Igrave: "Ì",+ igrave: "ì",+ ii: "ⅈ",+ iiiint: "⨌",+ iiint: "∭",+ iinfin: "⧜",+ iiota: "℩",+ IJlig: "IJ",+ ijlig: "ij",+ Im: "ℑ",+ Imacr: "Ī",+ imacr: "ī",+ image: "ℑ",+ ImaginaryI: "ⅈ",+ imagline: "ℐ",+ imagpart: "ℑ",+ imath: "ı",+ imof: "⊷",+ imped: "Ƶ",+ Implies: "⇒",+ in: "∈",+ incare: "℅",+ infin: "∞",+ infintie: "⧝",+ inodot: "ı",+ Int: "∬",+ int: "∫",+ intcal: "⊺",+ integers: "ℤ",+ Integral: "∫",+ intercal: "⊺",+ Intersection: "⋂",+ intlarhk: "⨗",+ intprod: "⨼",+ InvisibleComma: "",+ InvisibleTimes: "",+ IOcy: "Ё",+ iocy: "ё",+ Iogon: "Į",+ iogon: "į",+ Iopf: "𝕀",+ iopf: "𝕚",+ Iota: "Ι",+ iota: "ι",+ iprod: "⨼",+ iquest: "¿",+ Iscr: "ℐ",+ iscr: "𝒾",+ isin: "∈",+ isindot: "⋵",+ isinE: "⋹",+ isins: "⋴",+ isinsv: "⋳",+ isinv: "∈",+ it: "",+ Itilde: "Ĩ",+ itilde: "ĩ",+ Iukcy: "І",+ iukcy: "і",+ Iuml: "Ï",+ iuml: "ï",+ Jcirc: "Ĵ",+ jcirc: "ĵ",+ Jcy: "Й",+ jcy: "й",+ Jfr: "𝔍",+ jfr: "𝔧",+ jmath: "ȷ",+ Jopf: "𝕁",+ jopf: "𝕛",+ Jscr: "𝒥",+ jscr: "𝒿",+ Jsercy: "Ј",+ jsercy: "ј",+ Jukcy: "Є",+ jukcy: "є",+ Kappa: "Κ",+ kappa: "κ",+ kappav: "ϰ",+ Kcedil: "Ķ",+ kcedil: "ķ",+ Kcy: "К",+ kcy: "к",+ Kfr: "𝔎",+ kfr: "𝔨",+ kgreen: "ĸ",+ KHcy: "Х",+ khcy: "х",+ KJcy: "Ќ",+ kjcy: "ќ",+ Kopf: "𝕂",+ kopf: "𝕜",+ Kscr: "𝒦",+ kscr: "𝓀",+ lAarr: "⇚",+ Lacute: "Ĺ",+ lacute: "ĺ",+ laemptyv: "⦴",+ lagran: "ℒ",+ Lambda: "Λ",+ lambda: "λ",+ Lang: "⟪",+ lang: "⟨",+ langd: "⦑",+ langle: "⟨",+ lap: "⪅",+ Laplacetrf: "ℒ",+ laquo: "«",+ Larr: "↞",+ lArr: "⇐",+ larr: "←",+ larrb: "⇤",+ larrbfs: "⤟",+ larrfs: "⤝",+ larrhk: "↩",+ larrlp: "↫",+ larrpl: "⤹",+ larrsim: "⥳",+ larrtl: "↢",+ lat: "⪫",+ lAtail: "⤛",+ latail: "⤙",+ late: "⪭",+ lates: "⪭︀",+ lBarr: "⤎",+ lbarr: "⤌",+ lbbrk: "❲",+ lbrace: "{",+ lbrack: "[",+ lbrke: "⦋",+ lbrksld: "⦏",+ lbrkslu: "⦍",+ Lcaron: "Ľ",+ lcaron: "ľ",+ Lcedil: "Ļ",+ lcedil: "ļ",+ lceil: "⌈",+ lcub: "{",+ Lcy: "Л",+ lcy: "л",+ ldca: "⤶",+ ldquo: "“",+ ldquor: "„",+ ldrdhar: "⥧",+ ldrushar: "⥋",+ ldsh: "↲",+ lE: "≦",+ le: "≤",+ LeftAngleBracket: "⟨",+ LeftArrow: "←",+ Leftarrow: "⇐",+ leftarrow: "←",+ LeftArrowBar: "⇤",+ LeftArrowRightArrow: "⇆",+ leftarrowtail: "↢",+ LeftCeiling: "⌈",+ LeftDoubleBracket: "⟦",+ LeftDownTeeVector: "⥡",+ LeftDownVector: "⇃",+ LeftDownVectorBar: "⥙",+ LeftFloor: "⌊",+ leftharpoondown: "↽",+ leftharpoonup: "↼",+ leftleftarrows: "⇇",+ LeftRightArrow: "↔",+ Leftrightarrow: "⇔",+ leftrightarrow: "↔",+ leftrightarrows: "⇆",+ leftrightharpoons: "⇋",+ leftrightsquigarrow: "↭",+ LeftRightVector: "⥎",+ LeftTee: "⊣",+ LeftTeeArrow: "↤",+ LeftTeeVector: "⥚",+ leftthreetimes: "⋋",+ LeftTriangle: "⊲",+ LeftTriangleBar: "⧏",+ LeftTriangleEqual: "⊴",+ LeftUpDownVector: "⥑",+ LeftUpTeeVector: "⥠",+ LeftUpVector: "↿",+ LeftUpVectorBar: "⥘",+ LeftVector: "↼",+ LeftVectorBar: "⥒",+ lEg: "⪋",+ leg: "⋚",+ leq: "≤",+ leqq: "≦",+ leqslant: "⩽",+ les: "⩽",+ lescc: "⪨",+ lesdot: "⩿",+ lesdoto: "⪁",+ lesdotor: "⪃",+ lesg: "⋚︀",+ lesges: "⪓",+ lessapprox: "⪅",+ lessdot: "⋖",+ lesseqgtr: "⋚",+ lesseqqgtr: "⪋",+ LessEqualGreater: "⋚",+ LessFullEqual: "≦",+ LessGreater: "≶",+ lessgtr: "≶",+ LessLess: "⪡",+ lesssim: "≲",+ LessSlantEqual: "⩽",+ LessTilde: "≲",+ lfisht: "⥼",+ lfloor: "⌊",+ Lfr: "𝔏",+ lfr: "𝔩",+ lg: "≶",+ lgE: "⪑",+ lHar: "⥢",+ lhard: "↽",+ lharu: "↼",+ lharul: "⥪",+ lhblk: "▄",+ LJcy: "Љ",+ ljcy: "љ",+ Ll: "⋘",+ ll: "≪",+ llarr: "⇇",+ llcorner: "⌞",+ Lleftarrow: "⇚",+ llhard: "⥫",+ lltri: "◺",+ Lmidot: "Ŀ",+ lmidot: "ŀ",+ lmoust: "⎰",+ lmoustache: "⎰",+ lnap: "⪉",+ lnapprox: "⪉",+ lnE: "≨",+ lne: "⪇",+ lneq: "⪇",+ lneqq: "≨",+ lnsim: "⋦",+ loang: "⟬",+ loarr: "⇽",+ lobrk: "⟦",+ LongLeftArrow: "⟵",+ Longleftarrow: "⟸",+ longleftarrow: "⟵",+ LongLeftRightArrow: "⟷",+ Longleftrightarrow: "⟺",+ longleftrightarrow: "⟷",+ longmapsto: "⟼",+ LongRightArrow: "⟶",+ Longrightarrow: "⟹",+ longrightarrow: "⟶",+ looparrowleft: "↫",+ looparrowright: "↬",+ lopar: "⦅",+ Lopf: "𝕃",+ lopf: "𝕝",+ loplus: "⨭",+ lotimes: "⨴",+ lowast: "∗",+ lowbar: "_",+ LowerLeftArrow: "↙",+ LowerRightArrow: "↘",+ loz: "◊",+ lozenge: "◊",+ lozf: "⧫",+ lpar: "(",+ lparlt: "⦓",+ lrarr: "⇆",+ lrcorner: "⌟",+ lrhar: "⇋",+ lrhard: "⥭",+ lrm: "",+ lrtri: "⊿",+ lsaquo: "‹",+ Lscr: "ℒ",+ lscr: "𝓁",+ Lsh: "↰",+ lsh: "↰",+ lsim: "≲",+ lsime: "⪍",+ lsimg: "⪏",+ lsqb: "[",+ lsquo: "‘",+ lsquor: "‚",+ Lstrok: "Ł",+ lstrok: "ł",+ Lt: "≪",+ LT: "<",+ lt: "<",+ ltcc: "⪦",+ ltcir: "⩹",+ ltdot: "⋖",+ lthree: "⋋",+ ltimes: "⋉",+ ltlarr: "⥶",+ ltquest: "⩻",+ ltri: "◃",+ ltrie: "⊴",+ ltrif: "◂",+ ltrPar: "⦖",+ lurdshar: "⥊",+ luruhar: "⥦",+ lvertneqq: "≨︀",+ lvnE: "≨︀",+ macr: "¯",+ male: "♂",+ malt: "✠",+ maltese: "✠",+ Map: "⤅",+ map: "↦",+ mapsto: "↦",+ mapstodown: "↧",+ mapstoleft: "↤",+ mapstoup: "↥",+ marker: "▮",+ mcomma: "⨩",+ Mcy: "М",+ mcy: "м",+ mdash: "—",+ mDDot: "∺",+ measuredangle: "∡",+ MediumSpace: " ",+ Mellintrf: "ℳ",+ Mfr: "𝔐",+ mfr: "𝔪",+ mho: "℧",+ micro: "µ",+ mid: "∣",+ midast: "*",+ midcir: "⫰",+ middot: "·",+ minus: "−",+ minusb: "⊟",+ minusd: "∸",+ minusdu: "⨪",+ MinusPlus: "∓",+ mlcp: "⫛",+ mldr: "…",+ mnplus: "∓",+ models: "⊧",+ Mopf: "𝕄",+ mopf: "𝕞",+ mp: "∓",+ Mscr: "ℳ",+ mscr: "𝓂",+ mstpos: "∾",+ Mu: "Μ",+ mu: "μ",+ multimap: "⊸",+ mumap: "⊸",+ nabla: "∇",+ Nacute: "Ń",+ nacute: "ń",+ nang: "∠⃒",+ nap: "≉",+ napE: "⩰̸",+ napid: "≋̸",+ napos: "ʼn",+ napprox: "≉",+ natur: "♮",+ natural: "♮",+ naturals: "ℕ",+ nbsp: " ",+ nbump: "≎̸",+ nbumpe: "≏̸",+ ncap: "⩃",+ Ncaron: "Ň",+ ncaron: "ň",+ Ncedil: "Ņ",+ ncedil: "ņ",+ ncong: "≇",+ ncongdot: "⩭̸",+ ncup: "⩂",+ Ncy: "Н",+ ncy: "н",+ ndash: "–",+ ne: "≠",+ nearhk: "⤤",+ neArr: "⇗",+ nearr: "↗",+ nearrow: "↗",+ nedot: "≐̸",+ NegativeMediumSpace: "",+ NegativeThickSpace: "",+ NegativeThinSpace: "",+ NegativeVeryThinSpace: "",+ nequiv: "≢",+ nesear: "⤨",+ nesim: "≂̸",+ NestedGreaterGreater: "≫",+ NestedLessLess: "≪",+ NewLine: "\n",+ nexist: "∄",+ nexists: "∄",+ Nfr: "𝔑",+ nfr: "𝔫",+ ngE: "≧̸",+ nge: "≱",+ ngeq: "≱",+ ngeqq: "≧̸",+ ngeqslant: "⩾̸",+ nges: "⩾̸",+ nGg: "⋙̸",+ ngsim: "≵",+ nGt: "≫⃒",+ ngt: "≯",+ ngtr: "≯",+ nGtv: "≫̸",+ nhArr: "⇎",+ nharr: "↮",+ nhpar: "⫲",+ ni: "∋",+ nis: "⋼",+ nisd: "⋺",+ niv: "∋",+ NJcy: "Њ",+ njcy: "њ",+ nlArr: "⇍",+ nlarr: "↚",+ nldr: "‥",+ nlE: "≦̸",+ nle: "≰",+ nLeftarrow: "⇍",+ nleftarrow: "↚",+ nLeftrightarrow: "⇎",+ nleftrightarrow: "↮",+ nleq: "≰",+ nleqq: "≦̸",+ nleqslant: "⩽̸",+ nles: "⩽̸",+ nless: "≮",+ nLl: "⋘̸",+ nlsim: "≴",+ nLt: "≪⃒",+ nlt: "≮",+ nltri: "⋪",+ nltrie: "⋬",+ nLtv: "≪̸",+ nmid: "∤",+ NoBreak: "",+ NonBreakingSpace: " ",+ Nopf: "ℕ",+ nopf: "𝕟",+ Not: "⫬",+ not: "¬",+ NotCongruent: "≢",+ NotCupCap: "≭",+ NotDoubleVerticalBar: "∦",+ NotElement: "∉",+ NotEqual: "≠",+ NotEqualTilde: "≂̸",+ NotExists: "∄",+ NotGreater: "≯",+ NotGreaterEqual: "≱",+ NotGreaterFullEqual: "≧̸",+ NotGreaterGreater: "≫̸",+ NotGreaterLess: "≹",+ NotGreaterSlantEqual: "⩾̸",+ NotGreaterTilde: "≵",+ NotHumpDownHump: "≎̸",+ NotHumpEqual: "≏̸",+ notin: "∉",+ notindot: "⋵̸",+ notinE: "⋹̸",+ notinva: "∉",+ notinvb: "⋷",+ notinvc: "⋶",+ NotLeftTriangle: "⋪",+ NotLeftTriangleBar: "⧏̸",+ NotLeftTriangleEqual: "⋬",+ NotLess: "≮",+ NotLessEqual: "≰",+ NotLessGreater: "≸",+ NotLessLess: "≪̸",+ NotLessSlantEqual: "⩽̸",+ NotLessTilde: "≴",+ NotNestedGreaterGreater: "⪢̸",+ NotNestedLessLess: "⪡̸",+ notni: "∌",+ notniva: "∌",+ notnivb: "⋾",+ notnivc: "⋽",+ NotPrecedes: "⊀",+ NotPrecedesEqual: "⪯̸",+ NotPrecedesSlantEqual: "⋠",+ NotReverseElement: "∌",+ NotRightTriangle: "⋫",+ NotRightTriangleBar: "⧐̸",+ NotRightTriangleEqual: "⋭",+ NotSquareSubset: "⊏̸",+ NotSquareSubsetEqual: "⋢",+ NotSquareSuperset: "⊐̸",+ NotSquareSupersetEqual: "⋣",+ NotSubset: "⊂⃒",+ NotSubsetEqual: "⊈",+ NotSucceeds: "⊁",+ NotSucceedsEqual: "⪰̸",+ NotSucceedsSlantEqual: "⋡",+ NotSucceedsTilde: "≿̸",+ NotSuperset: "⊃⃒",+ NotSupersetEqual: "⊉",+ NotTilde: "≁",+ NotTildeEqual: "≄",+ NotTildeFullEqual: "≇",+ NotTildeTilde: "≉",+ NotVerticalBar: "∤",+ npar: "∦",+ nparallel: "∦",+ nparsl: "⫽⃥",+ npart: "∂̸",+ npolint: "⨔",+ npr: "⊀",+ nprcue: "⋠",+ npre: "⪯̸",+ nprec: "⊀",+ npreceq: "⪯̸",+ nrArr: "⇏",+ nrarr: "↛",+ nrarrc: "⤳̸",+ nrarrw: "↝̸",+ nRightarrow: "⇏",+ nrightarrow: "↛",+ nrtri: "⋫",+ nrtrie: "⋭",+ nsc: "⊁",+ nsccue: "⋡",+ nsce: "⪰̸",+ Nscr: "𝒩",+ nscr: "𝓃",+ nshortmid: "∤",+ nshortparallel: "∦",+ nsim: "≁",+ nsime: "≄",+ nsimeq: "≄",+ nsmid: "∤",+ nspar: "∦",+ nsqsube: "⋢",+ nsqsupe: "⋣",+ nsub: "⊄",+ nsubE: "⫅̸",+ nsube: "⊈",+ nsubset: "⊂⃒",+ nsubseteq: "⊈",+ nsubseteqq: "⫅̸",+ nsucc: "⊁",+ nsucceq: "⪰̸",+ nsup: "⊅",+ nsupE: "⫆̸",+ nsupe: "⊉",+ nsupset: "⊃⃒",+ nsupseteq: "⊉",+ nsupseteqq: "⫆̸",+ ntgl: "≹",+ Ntilde: "Ñ",+ ntilde: "ñ",+ ntlg: "≸",+ ntriangleleft: "⋪",+ ntrianglelefteq: "⋬",+ ntriangleright: "⋫",+ ntrianglerighteq: "⋭",+ Nu: "Ν",+ nu: "ν",+ num: "#",+ numero: "№",+ numsp: " ",+ nvap: "≍⃒",+ nVDash: "⊯",+ nVdash: "⊮",+ nvDash: "⊭",+ nvdash: "⊬",+ nvge: "≥⃒",+ nvgt: ">⃒",+ nvHarr: "⤄",+ nvinfin: "⧞",+ nvlArr: "⤂",+ nvle: "≤⃒",+ nvlt: "<⃒",+ nvltrie: "⊴⃒",+ nvrArr: "⤃",+ nvrtrie: "⊵⃒",+ nvsim: "∼⃒",+ nwarhk: "⤣",+ nwArr: "⇖",+ nwarr: "↖",+ nwarrow: "↖",+ nwnear: "⤧",+ Oacute: "Ó",+ oacute: "ó",+ oast: "⊛",+ ocir: "⊚",+ Ocirc: "Ô",+ ocirc: "ô",+ Ocy: "О",+ ocy: "о",+ odash: "⊝",+ Odblac: "Ő",+ odblac: "ő",+ odiv: "⨸",+ odot: "⊙",+ odsold: "⦼",+ OElig: "Œ",+ oelig: "œ",+ ofcir: "⦿",+ Ofr: "𝔒",+ ofr: "𝔬",+ ogon: "˛",+ Ograve: "Ò",+ ograve: "ò",+ ogt: "⧁",+ ohbar: "⦵",+ ohm: "Ω",+ oint: "∮",+ olarr: "↺",+ olcir: "⦾",+ olcross: "⦻",+ oline: "‾",+ olt: "⧀",+ Omacr: "Ō",+ omacr: "ō",+ Omega: "Ω",+ omega: "ω",+ Omicron: "Ο",+ omicron: "ο",+ omid: "⦶",+ ominus: "⊖",+ Oopf: "𝕆",+ oopf: "𝕠",+ opar: "⦷",+ OpenCurlyDoubleQuote: "“",+ OpenCurlyQuote: "‘",+ operp: "⦹",+ oplus: "⊕",+ Or: "⩔",+ or: "∨",+ orarr: "↻",+ ord: "⩝",+ order: "ℴ",+ orderof: "ℴ",+ ordf: "ª",+ ordm: "º",+ origof: "⊶",+ oror: "⩖",+ orslope: "⩗",+ orv: "⩛",+ oS: "Ⓢ",+ Oscr: "𝒪",+ oscr: "ℴ",+ Oslash: "Ø",+ oslash: "ø",+ osol: "⊘",+ Otilde: "Õ",+ otilde: "õ",+ Otimes: "⨷",+ otimes: "⊗",+ otimesas: "⨶",+ Ouml: "Ö",+ ouml: "ö",+ ovbar: "⌽",+ OverBar: "‾",+ OverBrace: "⏞",+ OverBracket: "⎴",+ OverParenthesis: "⏜",+ par: "∥",+ para: "¶",+ parallel: "∥",+ parsim: "⫳",+ parsl: "⫽",+ part: "∂",+ PartialD: "∂",+ Pcy: "П",+ pcy: "п",+ percnt: "%",+ period: ".",+ permil: "‰",+ perp: "⊥",+ pertenk: "‱",+ Pfr: "𝔓",+ pfr: "𝔭",+ Phi: "Φ",+ phi: "φ",+ phiv: "ϕ",+ phmmat: "ℳ",+ phone: "☎",+ Pi: "Π",+ pi: "π",+ pitchfork: "⋔",+ piv: "ϖ",+ planck: "ℏ",+ planckh: "ℎ",+ plankv: "ℏ",+ plus: "+",+ plusacir: "⨣",+ plusb: "⊞",+ pluscir: "⨢",+ plusdo: "∔",+ plusdu: "⨥",+ pluse: "⩲",+ PlusMinus: "±",+ plusmn: "±",+ plussim: "⨦",+ plustwo: "⨧",+ pm: "±",+ Poincareplane: "ℌ",+ pointint: "⨕",+ Popf: "ℙ",+ popf: "𝕡",+ pound: "£",+ Pr: "⪻",+ pr: "≺",+ prap: "⪷",+ prcue: "≼",+ prE: "⪳",+ pre: "⪯",+ prec: "≺",+ precapprox: "⪷",+ preccurlyeq: "≼",+ Precedes: "≺",+ PrecedesEqual: "⪯",+ PrecedesSlantEqual: "≼",+ PrecedesTilde: "≾",+ preceq: "⪯",+ precnapprox: "⪹",+ precneqq: "⪵",+ precnsim: "⋨",+ precsim: "≾",+ Prime: "″",+ prime: "′",+ primes: "ℙ",+ prnap: "⪹",+ prnE: "⪵",+ prnsim: "⋨",+ prod: "∏",+ Product: "∏",+ profalar: "⌮",+ profline: "⌒",+ profsurf: "⌓",+ prop: "∝",+ Proportion: "∷",+ Proportional: "∝",+ propto: "∝",+ prsim: "≾",+ prurel: "⊰",+ Pscr: "𝒫",+ pscr: "𝓅",+ Psi: "Ψ",+ psi: "ψ",+ puncsp: " ",+ Qfr: "𝔔",+ qfr: "𝔮",+ qint: "⨌",+ Qopf: "ℚ",+ qopf: "𝕢",+ qprime: "⁗",+ Qscr: "𝒬",+ qscr: "𝓆",+ quaternions: "ℍ",+ quatint: "⨖",+ quest: "?",+ questeq: "≟",+ QUOT: '"',+ quot: '"',+ rAarr: "⇛",+ race: "∽̱",+ Racute: "Ŕ",+ racute: "ŕ",+ radic: "√",+ raemptyv: "⦳",+ Rang: "⟫",+ rang: "⟩",+ rangd: "⦒",+ range: "⦥",+ rangle: "⟩",+ raquo: "»",+ Rarr: "↠",+ rArr: "⇒",+ rarr: "→",+ rarrap: "⥵",+ rarrb: "⇥",+ rarrbfs: "⤠",+ rarrc: "⤳",+ rarrfs: "⤞",+ rarrhk: "↪",+ rarrlp: "↬",+ rarrpl: "⥅",+ rarrsim: "⥴",+ Rarrtl: "⤖",+ rarrtl: "↣",+ rarrw: "↝",+ rAtail: "⤜",+ ratail: "⤚",+ ratio: "∶",+ rationals: "ℚ",+ RBarr: "⤐",+ rBarr: "⤏",+ rbarr: "⤍",+ rbbrk: "❳",+ rbrace: "}",+ rbrack: "]",+ rbrke: "⦌",+ rbrksld: "⦎",+ rbrkslu: "⦐",+ Rcaron: "Ř",+ rcaron: "ř",+ Rcedil: "Ŗ",+ rcedil: "ŗ",+ rceil: "⌉",+ rcub: "}",+ Rcy: "Р",+ rcy: "р",+ rdca: "⤷",+ rdldhar: "⥩",+ rdquo: "”",+ rdquor: "”",+ rdsh: "↳",+ Re: "ℜ",+ real: "ℜ",+ realine: "ℛ",+ realpart: "ℜ",+ reals: "ℝ",+ rect: "▭",+ REG: "®",+ reg: "®",+ ReverseElement: "∋",+ ReverseEquilibrium: "⇋",+ ReverseUpEquilibrium: "⥯",+ rfisht: "⥽",+ rfloor: "⌋",+ Rfr: "ℜ",+ rfr: "𝔯",+ rHar: "⥤",+ rhard: "⇁",+ rharu: "⇀",+ rharul: "⥬",+ Rho: "Ρ",+ rho: "ρ",+ rhov: "ϱ",+ RightAngleBracket: "⟩",+ RightArrow: "→",+ Rightarrow: "⇒",+ rightarrow: "→",+ RightArrowBar: "⇥",+ RightArrowLeftArrow: "⇄",+ rightarrowtail: "↣",+ RightCeiling: "⌉",+ RightDoubleBracket: "⟧",+ RightDownTeeVector: "⥝",+ RightDownVector: "⇂",+ RightDownVectorBar: "⥕",+ RightFloor: "⌋",+ rightharpoondown: "⇁",+ rightharpoonup: "⇀",+ rightleftarrows: "⇄",+ rightleftharpoons: "⇌",+ rightrightarrows: "⇉",+ rightsquigarrow: "↝",+ RightTee: "⊢",+ RightTeeArrow: "↦",+ RightTeeVector: "⥛",+ rightthreetimes: "⋌",+ RightTriangle: "⊳",+ RightTriangleBar: "⧐",+ RightTriangleEqual: "⊵",+ RightUpDownVector: "⥏",+ RightUpTeeVector: "⥜",+ RightUpVector: "↾",+ RightUpVectorBar: "⥔",+ RightVector: "⇀",+ RightVectorBar: "⥓",+ ring: "˚",+ risingdotseq: "≓",+ rlarr: "⇄",+ rlhar: "⇌",+ rlm: "",+ rmoust: "⎱",+ rmoustache: "⎱",+ rnmid: "⫮",+ roang: "⟭",+ roarr: "⇾",+ robrk: "⟧",+ ropar: "⦆",+ Ropf: "ℝ",+ ropf: "𝕣",+ roplus: "⨮",+ rotimes: "⨵",+ RoundImplies: "⥰",+ rpar: ")",+ rpargt: "⦔",+ rppolint: "⨒",+ rrarr: "⇉",+ Rrightarrow: "⇛",+ rsaquo: "›",+ Rscr: "ℛ",+ rscr: "𝓇",+ Rsh: "↱",+ rsh: "↱",+ rsqb: "]",+ rsquo: "’",+ rsquor: "’",+ rthree: "⋌",+ rtimes: "⋊",+ rtri: "▹",+ rtrie: "⊵",+ rtrif: "▸",+ rtriltri: "⧎",+ RuleDelayed: "⧴",+ ruluhar: "⥨",+ rx: "℞",+ Sacute: "Ś",+ sacute: "ś",+ sbquo: "‚",+ Sc: "⪼",+ sc: "≻",+ scap: "⪸",+ Scaron: "Š",+ scaron: "š",+ sccue: "≽",+ scE: "⪴",+ sce: "⪰",+ Scedil: "Ş",+ scedil: "ş",+ Scirc: "Ŝ",+ scirc: "ŝ",+ scnap: "⪺",+ scnE: "⪶",+ scnsim: "⋩",+ scpolint: "⨓",+ scsim: "≿",+ Scy: "С",+ scy: "с",+ sdot: "⋅",+ sdotb: "⊡",+ sdote: "⩦",+ searhk: "⤥",+ seArr: "⇘",+ searr: "↘",+ searrow: "↘",+ sect: "§",+ semi: ";",+ seswar: "⤩",+ setminus: "∖",+ setmn: "∖",+ sext: "✶",+ Sfr: "𝔖",+ sfr: "𝔰",+ sfrown: "⌢",+ sharp: "♯",+ SHCHcy: "Щ",+ shchcy: "щ",+ SHcy: "Ш",+ shcy: "ш",+ ShortDownArrow: "↓",+ ShortLeftArrow: "←",+ shortmid: "∣",+ shortparallel: "∥",+ ShortRightArrow: "→",+ ShortUpArrow: "↑",+ shy: "",+ Sigma: "Σ",+ sigma: "σ",+ sigmaf: "ς",+ sigmav: "ς",+ sim: "∼",+ simdot: "⩪",+ sime: "≃",+ simeq: "≃",+ simg: "⪞",+ simgE: "⪠",+ siml: "⪝",+ simlE: "⪟",+ simne: "≆",+ simplus: "⨤",+ simrarr: "⥲",+ slarr: "←",+ SmallCircle: "∘",+ smallsetminus: "∖",+ smashp: "⨳",+ smeparsl: "⧤",+ smid: "∣",+ smile: "⌣",+ smt: "⪪",+ smte: "⪬",+ smtes: "⪬︀",+ SOFTcy: "Ь",+ softcy: "ь",+ sol: "/",+ solb: "⧄",+ solbar: "⌿",+ Sopf: "𝕊",+ sopf: "𝕤",+ spades: "♠",+ spadesuit: "♠",+ spar: "∥",+ sqcap: "⊓",+ sqcaps: "⊓︀",+ sqcup: "⊔",+ sqcups: "⊔︀",+ Sqrt: "√",+ sqsub: "⊏",+ sqsube: "⊑",+ sqsubset: "⊏",+ sqsubseteq: "⊑",+ sqsup: "⊐",+ sqsupe: "⊒",+ sqsupset: "⊐",+ sqsupseteq: "⊒",+ squ: "□",+ Square: "□",+ square: "□",+ SquareIntersection: "⊓",+ SquareSubset: "⊏",+ SquareSubsetEqual: "⊑",+ SquareSuperset: "⊐",+ SquareSupersetEqual: "⊒",+ SquareUnion: "⊔",+ squarf: "▪",+ squf: "▪",+ srarr: "→",+ Sscr: "𝒮",+ sscr: "𝓈",+ ssetmn: "∖",+ ssmile: "⌣",+ sstarf: "⋆",+ Star: "⋆",+ star: "☆",+ starf: "★",+ straightepsilon: "ϵ",+ straightphi: "ϕ",+ strns: "¯",+ Sub: "⋐",+ sub: "⊂",+ subdot: "⪽",+ subE: "⫅",+ sube: "⊆",+ subedot: "⫃",+ submult: "⫁",+ subnE: "⫋",+ subne: "⊊",+ subplus: "⪿",+ subrarr: "⥹",+ Subset: "⋐",+ subset: "⊂",+ subseteq: "⊆",+ subseteqq: "⫅",+ SubsetEqual: "⊆",+ subsetneq: "⊊",+ subsetneqq: "⫋",+ subsim: "⫇",+ subsub: "⫕",+ subsup: "⫓",+ succ: "≻",+ succapprox: "⪸",+ succcurlyeq: "≽",+ Succeeds: "≻",+ SucceedsEqual: "⪰",+ SucceedsSlantEqual: "≽",+ SucceedsTilde: "≿",+ succeq: "⪰",+ succnapprox: "⪺",+ succneqq: "⪶",+ succnsim: "⋩",+ succsim: "≿",+ SuchThat: "∋",+ Sum: "∑",+ sum: "∑",+ sung: "♪",+ Sup: "⋑",+ sup: "⊃",+ sup1: "¹",+ sup2: "²",+ sup3: "³",+ supdot: "⪾",+ supdsub: "⫘",+ supE: "⫆",+ supe: "⊇",+ supedot: "⫄",+ Superset: "⊃",+ SupersetEqual: "⊇",+ suphsol: "⟉",+ suphsub: "⫗",+ suplarr: "⥻",+ supmult: "⫂",+ supnE: "⫌",+ supne: "⊋",+ supplus: "⫀",+ Supset: "⋑",+ supset: "⊃",+ supseteq: "⊇",+ supseteqq: "⫆",+ supsetneq: "⊋",+ supsetneqq: "⫌",+ supsim: "⫈",+ supsub: "⫔",+ supsup: "⫖",+ swarhk: "⤦",+ swArr: "⇙",+ swarr: "↙",+ swarrow: "↙",+ swnwar: "⤪",+ szlig: "ß",+ Tab: " ",+ target: "⌖",+ Tau: "Τ",+ tau: "τ",+ tbrk: "⎴",+ Tcaron: "Ť",+ tcaron: "ť",+ Tcedil: "Ţ",+ tcedil: "ţ",+ Tcy: "Т",+ tcy: "т",+ tdot: "⃛",+ telrec: "⌕",+ Tfr: "𝔗",+ tfr: "𝔱",+ there4: "∴",+ Therefore: "∴",+ therefore: "∴",+ Theta: "Θ",+ theta: "θ",+ thetasym: "ϑ",+ thetav: "ϑ",+ thickapprox: "≈",+ thicksim: "∼",+ ThickSpace: " ",+ thinsp: " ",+ ThinSpace: " ",+ thkap: "≈",+ thksim: "∼",+ THORN: "Þ",+ thorn: "þ",+ Tilde: "∼",+ tilde: "˜",+ TildeEqual: "≃",+ TildeFullEqual: "≅",+ TildeTilde: "≈",+ times: "×",+ timesb: "⊠",+ timesbar: "⨱",+ timesd: "⨰",+ tint: "∭",+ toea: "⤨",+ top: "⊤",+ topbot: "⌶",+ topcir: "⫱",+ Topf: "𝕋",+ topf: "𝕥",+ topfork: "⫚",+ tosa: "⤩",+ tprime: "‴",+ TRADE: "™",+ trade: "™",+ triangle: "▵",+ triangledown: "▿",+ triangleleft: "◃",+ trianglelefteq: "⊴",+ triangleq: "≜",+ triangleright: "▹",+ trianglerighteq: "⊵",+ tridot: "◬",+ trie: "≜",+ triminus: "⨺",+ TripleDot: "⃛",+ triplus: "⨹",+ trisb: "⧍",+ tritime: "⨻",+ trpezium: "⏢",+ Tscr: "𝒯",+ tscr: "𝓉",+ TScy: "Ц",+ tscy: "ц",+ TSHcy: "Ћ",+ tshcy: "ћ",+ Tstrok: "Ŧ",+ tstrok: "ŧ",+ twixt: "≬",+ twoheadleftarrow: "↞",+ twoheadrightarrow: "↠",+ Uacute: "Ú",+ uacute: "ú",+ Uarr: "↟",+ uArr: "⇑",+ uarr: "↑",+ Uarrocir: "⥉",+ Ubrcy: "Ў",+ ubrcy: "ў",+ Ubreve: "Ŭ",+ ubreve: "ŭ",+ Ucirc: "Û",+ ucirc: "û",+ Ucy: "У",+ ucy: "у",+ udarr: "⇅",+ Udblac: "Ű",+ udblac: "ű",+ udhar: "⥮",+ ufisht: "⥾",+ Ufr: "𝔘",+ ufr: "𝔲",+ Ugrave: "Ù",+ ugrave: "ù",+ uHar: "⥣",+ uharl: "↿",+ uharr: "↾",+ uhblk: "▀",+ ulcorn: "⌜",+ ulcorner: "⌜",+ ulcrop: "⌏",+ ultri: "◸",+ Umacr: "Ū",+ umacr: "ū",+ uml: "¨",+ UnderBar: "_",+ UnderBrace: "⏟",+ UnderBracket: "⎵",+ UnderParenthesis: "⏝",+ Union: "⋃",+ UnionPlus: "⊎",+ Uogon: "Ų",+ uogon: "ų",+ Uopf: "𝕌",+ uopf: "𝕦",+ UpArrow: "↑",+ Uparrow: "⇑",+ uparrow: "↑",+ UpArrowBar: "⤒",+ UpArrowDownArrow: "⇅",+ UpDownArrow: "↕",+ Updownarrow: "⇕",+ updownarrow: "↕",+ UpEquilibrium: "⥮",+ upharpoonleft: "↿",+ upharpoonright: "↾",+ uplus: "⊎",+ UpperLeftArrow: "↖",+ UpperRightArrow: "↗",+ Upsi: "ϒ",+ upsi: "υ",+ upsih: "ϒ",+ Upsilon: "Υ",+ upsilon: "υ",+ UpTee: "⊥",+ UpTeeArrow: "↥",+ upuparrows: "⇈",+ urcorn: "⌝",+ urcorner: "⌝",+ urcrop: "⌎",+ Uring: "Ů",+ uring: "ů",+ urtri: "◹",+ Uscr: "𝒰",+ uscr: "𝓊",+ utdot: "⋰",+ Utilde: "Ũ",+ utilde: "ũ",+ utri: "▵",+ utrif: "▴",+ uuarr: "⇈",+ Uuml: "Ü",+ uuml: "ü",+ uwangle: "⦧",+ vangrt: "⦜",+ varepsilon: "ϵ",+ varkappa: "ϰ",+ varnothing: "∅",+ varphi: "ϕ",+ varpi: "ϖ",+ varpropto: "∝",+ vArr: "⇕",+ varr: "↕",+ varrho: "ϱ",+ varsigma: "ς",+ varsubsetneq: "⊊︀",+ varsubsetneqq: "⫋︀",+ varsupsetneq: "⊋︀",+ varsupsetneqq: "⫌︀",+ vartheta: "ϑ",+ vartriangleleft: "⊲",+ vartriangleright: "⊳",+ Vbar: "⫫",+ vBar: "⫨",+ vBarv: "⫩",+ Vcy: "В",+ vcy: "в",+ VDash: "⊫",+ Vdash: "⊩",+ vDash: "⊨",+ vdash: "⊢",+ Vdashl: "⫦",+ Vee: "⋁",+ vee: "∨",+ veebar: "⊻",+ veeeq: "≚",+ vellip: "⋮",+ Verbar: "‖",+ verbar: "|",+ Vert: "‖",+ vert: "|",+ VerticalBar: "∣",+ VerticalLine: "|",+ VerticalSeparator: "❘",+ VerticalTilde: "≀",+ VeryThinSpace: " ",+ Vfr: "𝔙",+ vfr: "𝔳",+ vltri: "⊲",+ vnsub: "⊂⃒",+ vnsup: "⊃⃒",+ Vopf: "𝕍",+ vopf: "𝕧",+ vprop: "∝",+ vrtri: "⊳",+ Vscr: "𝒱",+ vscr: "𝓋",+ vsubnE: "⫋︀",+ vsubne: "⊊︀",+ vsupnE: "⫌︀",+ vsupne: "⊋︀",+ Vvdash: "⊪",+ vzigzag: "⦚",+ Wcirc: "Ŵ",+ wcirc: "ŵ",+ wedbar: "⩟",+ Wedge: "⋀",+ wedge: "∧",+ wedgeq: "≙",+ weierp: "℘",+ Wfr: "𝔚",+ wfr: "𝔴",+ Wopf: "𝕎",+ wopf: "𝕨",+ wp: "℘",+ wr: "≀",+ wreath: "≀",+ Wscr: "𝒲",+ wscr: "𝓌",+ xcap: "⋂",+ xcirc: "◯",+ xcup: "⋃",+ xdtri: "▽",+ Xfr: "𝔛",+ xfr: "𝔵",+ xhArr: "⟺",+ xharr: "⟷",+ Xi: "Ξ",+ xi: "ξ",+ xlArr: "⟸",+ xlarr: "⟵",+ xmap: "⟼",+ xnis: "⋻",+ xodot: "⨀",+ Xopf: "𝕏",+ xopf: "𝕩",+ xoplus: "⨁",+ xotime: "⨂",+ xrArr: "⟹",+ xrarr: "⟶",+ Xscr: "𝒳",+ xscr: "𝓍",+ xsqcup: "⨆",+ xuplus: "⨄",+ xutri: "△",+ xvee: "⋁",+ xwedge: "⋀",+ Yacute: "Ý",+ yacute: "ý",+ YAcy: "Я",+ yacy: "я",+ Ycirc: "Ŷ",+ ycirc: "ŷ",+ Ycy: "Ы",+ ycy: "ы",+ yen: "¥",+ Yfr: "𝔜",+ yfr: "𝔶",+ YIcy: "Ї",+ yicy: "ї",+ Yopf: "𝕐",+ yopf: "𝕪",+ Yscr: "𝒴",+ yscr: "𝓎",+ YUcy: "Ю",+ yucy: "ю",+ Yuml: "Ÿ",+ yuml: "ÿ",+ Zacute: "Ź",+ zacute: "ź",+ Zcaron: "Ž",+ zcaron: "ž",+ Zcy: "З",+ zcy: "з",+ Zdot: "Ż",+ zdot: "ż",+ zeetrf: "ℨ",+ ZeroWidthSpace: "",+ Zeta: "Ζ",+ zeta: "ζ",+ Zfr: "ℨ",+ zfr: "𝔷",+ ZHcy: "Ж",+ zhcy: "ж",+ zigrarr: "⇝",+ Zopf: "ℤ",+ zopf: "𝕫",+ Zscr: "𝒵",+ zscr: "𝓏",+ zwj: "",+ zwnj: ""+ });+ exports.entityMap = exports.HTML_ENTITIES;+ }+});++// node_modules/@xmldom/xmldom/lib/sax.js+var require_sax = __commonJS({+ "node_modules/@xmldom/xmldom/lib/sax.js"(exports) {+ "use strict";+ var conventions = require_conventions();+ var g = require_grammar();+ var errors = require_errors();+ var isHTMLEscapableRawTextElement = conventions.isHTMLEscapableRawTextElement;+ var isHTMLMimeType = conventions.isHTMLMimeType;+ var isHTMLRawTextElement = conventions.isHTMLRawTextElement;+ var hasOwn = conventions.hasOwn;+ var NAMESPACE = conventions.NAMESPACE;+ var ParseError = errors.ParseError;+ var DOMException = errors.DOMException;+ var S_TAG = 0;+ var S_ATTR = 1;+ var S_ATTR_SPACE = 2;+ var S_EQ = 3;+ var S_ATTR_NOQUOT_VALUE = 4;+ var S_ATTR_END = 5;+ var S_TAG_SPACE = 6;+ var S_TAG_CLOSE = 7;+ function XMLReader() {+ }+ XMLReader.prototype = {+ parse: function(source, defaultNSMap, entityMap) {+ var domBuilder = this.domBuilder;+ domBuilder.startDocument();+ _copy(defaultNSMap, defaultNSMap = /* @__PURE__ */ Object.create(null));+ parse(source, defaultNSMap, entityMap, domBuilder, this.errorHandler);+ domBuilder.endDocument();+ }+ };+ var ENTITY_REG = /&#?\w+;?/g;+ function parse(source, defaultNSMapCopy, entityMap, domBuilder, errorHandler) {+ var isHTML = isHTMLMimeType(domBuilder.mimeType);+ if (source.indexOf(g.UNICODE_REPLACEMENT_CHARACTER) >= 0) {+ errorHandler.warning("Unicode replacement character detected, source encoding issues?");+ }+ function fixedFromCharCode(code) {+ if (code > 65535) {+ code -= 65536;+ var surrogate1 = 55296 + (code >> 10), surrogate2 = 56320 + (code & 1023);+ return String.fromCharCode(surrogate1, surrogate2);+ } else {+ return String.fromCharCode(code);+ }+ }+ function entityReplacer(a2) {+ var complete = a2[a2.length - 1] === ";" ? a2 : a2 + ";";+ if (!isHTML && complete !== a2) {+ errorHandler.error("EntityRef: expecting ;");+ return a2;+ }+ var match = g.Reference.exec(complete);+ if (!match || match[0].length !== complete.length) {+ errorHandler.error("entity not matching Reference production: " + a2);+ return a2;+ }+ var k = complete.slice(1, -1);+ if (hasOwn(entityMap, k)) {+ return entityMap[k];+ } else if (k.charAt(0) === "#") {+ return fixedFromCharCode(parseInt(k.substring(1).replace("x", "0x")));+ } else {+ errorHandler.error("entity not found:" + a2);+ return a2;+ }+ }+ function appendText(end2) {+ if (end2 > start) {+ var xt = source.substring(start, end2).replace(ENTITY_REG, entityReplacer);+ locator && position(start);+ domBuilder.characters(xt, 0, end2 - start);+ start = end2;+ }+ }+ var lineStart = 0;+ var lineEnd = 0;+ var linePattern = /\r\n?|\n|$/g;+ var locator = domBuilder.locator;+ function position(p, m) {+ while (p >= lineEnd && (m = linePattern.exec(source))) {+ lineStart = lineEnd;+ lineEnd = m.index + m[0].length;+ locator.lineNumber++;+ }+ locator.columnNumber = p - lineStart + 1;+ }+ var parseStack = [{ currentNSMap: defaultNSMapCopy }];+ var unclosedTags = [];+ var start = 0;+ while (true) {+ try {+ var tagStart = source.indexOf("<", start);+ if (tagStart < 0) {+ if (!isHTML && unclosedTags.length > 0) {+ return errorHandler.fatalError("unclosed xml tag(s): " + unclosedTags.join(", "));+ }+ if (!source.substring(start).match(/^\s*$/)) {+ var doc = domBuilder.doc;+ var text = doc.createTextNode(source.substring(start));+ if (doc.documentElement) {+ return errorHandler.error("Extra content at the end of the document");+ }+ doc.appendChild(text);+ domBuilder.currentElement = text;+ }+ return;+ }+ if (tagStart > start) {+ var fromSource = source.substring(start, tagStart);+ if (!isHTML && unclosedTags.length === 0) {+ fromSource = fromSource.replace(new RegExp(g.S_OPT.source, "g"), "");+ fromSource && errorHandler.error("Unexpected content outside root element: '" + fromSource + "'");+ }+ appendText(tagStart);+ }+ switch (source.charAt(tagStart + 1)) {+ case "/":+ var end = source.indexOf(">", tagStart + 2);+ var tagNameRaw = source.substring(tagStart + 2, end > 0 ? end : void 0);+ if (!tagNameRaw) {+ return errorHandler.fatalError("end tag name missing");+ }+ var endTagNameStrict = g.reg("^", g.QName_group, g.S_OPT, "$");+ var tagNameMatch = end > 0 && endTagNameStrict.exec(tagNameRaw);+ if (!tagNameMatch) {+ var leadingTagNameMatch = end > 0 && g.reg("^", g.QName_group).exec(tagNameRaw);+ if (isHTML && leadingTagNameMatch) {+ errorHandler.warning('end tag name contains invalid trailing characters: "' + tagNameRaw + '"');+ tagNameMatch = leadingTagNameMatch;+ } else if (+ // Backward compatibility, remove this whole `else if` arm in the next breaking release+ // (XML then falls through to the `fatalError` below, for a clean mode split: XML fatal,+ // HTML warning). A valid end-tag name followed by a line break and trailing content was+ // silently accepted while `reg` still used the `m` flag; re-adding `m` here matches exactly+ // those inputs, kept recoverable and reported.+ leadingTagNameMatch && new RegExp(endTagNameStrict.source, endTagNameStrict.flags + "m").test(tagNameRaw)+ ) {+ errorHandler.error('end tag name is followed by a line break and trailing content: "' + tagNameRaw + '"');+ tagNameMatch = leadingTagNameMatch;+ } else {+ return errorHandler.fatalError('end tag name contains invalid characters: "' + tagNameRaw + '"');+ }+ }+ if (!domBuilder.currentElement && !domBuilder.doc.documentElement) {+ return;+ }+ var currentTagName = unclosedTags[unclosedTags.length - 1] || domBuilder.currentElement.tagName || domBuilder.doc.documentElement.tagName || "";+ if (currentTagName !== tagNameMatch[1]) {+ var tagNameLower = tagNameMatch[1].toLowerCase();+ if (!isHTML || currentTagName.toLowerCase() !== tagNameLower) {+ return errorHandler.fatalError('Opening and ending tag mismatch: "' + currentTagName + '" != "' + tagNameRaw + '"');+ }+ }+ var config = parseStack.pop();+ unclosedTags.pop();+ var localNSMap = config.localNSMap;+ domBuilder.endElement(config.uri, config.localName, currentTagName);+ if (localNSMap) {+ for (var prefix in localNSMap) {+ if (hasOwn(localNSMap, prefix)) {+ domBuilder.endPrefixMapping(prefix);+ }+ }+ }+ end++;+ break;+ // end element+ case "?":+ locator && position(tagStart);+ end = parseProcessingInstruction(source, tagStart, domBuilder, errorHandler);+ break;+ case "!":+ locator && position(tagStart);+ end = parseDoctypeCommentOrCData(source, tagStart, domBuilder, errorHandler, isHTML);+ break;+ default:+ locator && position(tagStart);+ var el = new ElementAttributes();+ var currentNSMap = parseStack[parseStack.length - 1].currentNSMap;+ var end = parseElementStartPart(source, tagStart, el, currentNSMap, entityReplacer, errorHandler, isHTML);+ var len = el.length;+ if (!el.closed) {+ if (isHTML && conventions.isHTMLVoidElement(el.tagName)) {+ el.closed = true;+ } else {+ unclosedTags.push(el.tagName);+ }+ }+ if (locator && len) {+ var locator2 = copyLocator(locator, {});+ for (var i = 0; i < len; i++) {+ var a = el[i];+ position(a.offset);+ a.locator = copyLocator(locator, {});+ }+ domBuilder.locator = locator2;+ if (appendElement(el, domBuilder, currentNSMap)) {+ parseStack.push(el);+ }+ domBuilder.locator = locator;+ } else {+ if (appendElement(el, domBuilder, currentNSMap)) {+ parseStack.push(el);+ }+ }+ if (isHTML && !el.closed) {+ end = parseHtmlSpecialContent(source, end, el.tagName, entityReplacer, domBuilder);+ } else {+ end++;+ }+ }+ } catch (e) {+ if (e instanceof ParseError) {+ throw e;+ } else if (e instanceof DOMException) {+ return errorHandler.fatalError("Error constructing the DOM: " + e.name + ": " + e.message, e);+ }+ errorHandler.error("element parse error: " + e);+ end = -1;+ }+ if (end > start) {+ start = end;+ } else {+ appendText(Math.max(tagStart, start) + 1);+ }+ }+ }+ function copyLocator(f, t) {+ t.lineNumber = f.lineNumber;+ t.columnNumber = f.columnNumber;+ return t;+ }+ function parseElementStartPart(source, start, el, currentNSMap, entityReplacer, errorHandler, isHTML) {+ function addAttribute(qname2, value2, startIndex) {+ if (hasOwn(el.attributeNames, qname2)) {+ return errorHandler.fatalError("Attribute " + qname2 + " redefined");+ }+ if (!isHTML && value2.indexOf("<") >= 0) {+ return errorHandler.fatalError("Unescaped '<' not allowed in attributes values");+ }+ el.addValue(+ qname2,+ // @see https://www.w3.org/TR/xml/#AVNormalize+ // since the xmldom sax parser does not "interpret" DTD the following is not implemented:+ // - recursive replacement of (DTD) entity references+ // - trimming and collapsing multiple spaces into a single one for attributes that are not of type CDATA+ value2.replace(/[\t\n\r]/g, " ").replace(ENTITY_REG, entityReplacer),+ startIndex+ );+ }+ var attrName;+ var value;+ var p = ++start;+ var s = S_TAG;+ while (true) {+ var c = source.charAt(p);+ if (s === S_TAG && c === "<") {+ throw new Error("unexpected < in tag name: " + source.slice(start, p));+ }+ switch (c) {+ case "=":+ if (s === S_ATTR) {+ attrName = source.slice(start, p);+ s = S_EQ;+ } else if (s === S_ATTR_SPACE) {+ s = S_EQ;+ } else {+ throw new Error("attribute equal must after attrName");+ }+ break;+ case "'":+ case '"':+ if (s === S_EQ || s === S_ATTR) {+ if (s === S_ATTR) {+ errorHandler.warning('attribute value must after "="');+ attrName = source.slice(start, p);+ }+ start = p + 1;+ p = source.indexOf(c, start);+ if (p > 0) {+ value = source.slice(start, p);+ addAttribute(attrName, value, start - 1);+ s = S_ATTR_END;+ } else {+ throw new Error("attribute value no end '" + c + "' match");+ }+ } else if (s == S_ATTR_NOQUOT_VALUE) {+ value = source.slice(start, p);+ addAttribute(attrName, value, start);+ errorHandler.warning('attribute "' + attrName + '" missed start quot(' + c + ")!!");+ start = p + 1;+ s = S_ATTR_END;+ } else {+ throw new Error('attribute value must after "="');+ }+ break;+ case "/":+ switch (s) {+ case S_TAG:+ el.setTagName(source.slice(start, p));+ case S_ATTR_END:+ case S_TAG_SPACE:+ case S_TAG_CLOSE:+ s = S_TAG_CLOSE;+ el.closed = true;+ case S_ATTR_NOQUOT_VALUE:+ case S_ATTR:+ break;+ case S_ATTR_SPACE:+ el.closed = true;+ break;+ //case S_EQ:+ default:+ throw new Error("attribute invalid close char('/')");+ }+ break;+ case "":+ errorHandler.error("unexpected end of input");+ if (s == S_TAG) {+ el.setTagName(source.slice(start, p));+ }+ return p;+ case ">":+ switch (s) {+ case S_TAG:+ el.setTagName(source.slice(start, p));+ case S_ATTR_END:+ case S_TAG_SPACE:+ case S_TAG_CLOSE:+ break;+ //normal+ case S_ATTR_NOQUOT_VALUE:+ //Compatible state+ case S_ATTR:+ value = source.slice(start, p);+ if (value.slice(-1) === "/") {+ el.closed = true;+ value = value.slice(0, -1);+ }+ case S_ATTR_SPACE:+ if (s === S_ATTR_SPACE) {+ value = attrName;+ }+ if (s == S_ATTR_NOQUOT_VALUE) {+ errorHandler.warning('attribute "' + value + '" missed quot(")!');+ addAttribute(attrName, value, start);+ } else {+ if (!isHTML) {+ errorHandler.warning('attribute "' + value + '" missed value!! "' + value + '" instead!!');+ }+ addAttribute(value, value, start);+ }+ break;+ case S_EQ:+ if (!isHTML) {+ return errorHandler.fatalError(`AttValue: ' or " expected`);+ }+ }+ return p;+ /*xml space '\x20' | #x9 | #xD | #xA; */+ case "":+ c = " ";+ default:+ if (c <= " ") {+ switch (s) {+ case S_TAG:+ el.setTagName(source.slice(start, p));+ s = S_TAG_SPACE;+ break;+ case S_ATTR:+ attrName = source.slice(start, p);+ s = S_ATTR_SPACE;+ break;+ case S_ATTR_NOQUOT_VALUE:+ var value = source.slice(start, p);+ errorHandler.warning('attribute "' + value + '" missed quot(")!!');+ addAttribute(attrName, value, start);+ case S_ATTR_END:+ s = S_TAG_SPACE;+ break;+ }+ } else {+ switch (s) {+ //case S_TAG:void();break;+ //case S_ATTR:void();break;+ //case S_ATTR_NOQUOT_VALUE:void();break;+ case S_ATTR_SPACE:+ if (!isHTML) {+ errorHandler.warning('attribute "' + attrName + '" missed value!! "' + attrName + '" instead2!!');+ }+ addAttribute(attrName, attrName, start);+ start = p;+ s = S_ATTR;+ break;+ case S_ATTR_END:+ errorHandler.warning('attribute space is required"' + attrName + '"!!');+ case S_TAG_SPACE:+ s = S_ATTR;+ start = p;+ break;+ case S_EQ:+ s = S_ATTR_NOQUOT_VALUE;+ start = p;+ break;+ case S_TAG_CLOSE:+ throw new Error("elements closed character '/' and '>' must be connected to");+ }+ }+ }+ p++;+ }+ }+ function appendElement(el, domBuilder, currentNSMap) {+ var tagName = el.tagName;+ var localNSMap = null;+ var i = el.length;+ while (i--) {+ var a = el[i];+ var qName = a.qName;+ var value = a.value;+ var nsp = qName.indexOf(":");+ if (nsp > 0) {+ var prefix = a.prefix = qName.slice(0, nsp);+ var localName = qName.slice(nsp + 1);+ var nsPrefix = prefix === "xmlns" && localName;+ } else {+ localName = qName;+ prefix = null;+ nsPrefix = qName === "xmlns" && "";+ }+ a.localName = localName;+ if (nsPrefix !== false) {+ if (localNSMap == null) {+ localNSMap = /* @__PURE__ */ Object.create(null);+ currentNSMap = Object.create(currentNSMap);+ }+ currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;+ a.uri = NAMESPACE.XMLNS;+ domBuilder.startPrefixMapping(nsPrefix, value);+ }+ }+ var i = el.length;+ while (i--) {+ a = el[i];+ if (a.prefix) {+ if (a.prefix === "xml") {+ a.uri = NAMESPACE.XML;+ }+ if (a.prefix !== "xmlns") {+ a.uri = currentNSMap[a.prefix];+ }+ }+ }+ var nsp = tagName.indexOf(":");+ if (nsp > 0) {+ prefix = el.prefix = tagName.slice(0, nsp);+ localName = el.localName = tagName.slice(nsp + 1);+ } else {+ prefix = null;+ localName = el.localName = tagName;+ }+ var ns = el.uri = currentNSMap[prefix || ""];+ domBuilder.startElement(ns, localName, tagName, el);+ if (el.closed) {+ domBuilder.endElement(ns, localName, tagName);+ if (localNSMap) {+ for (prefix in localNSMap) {+ if (hasOwn(localNSMap, prefix)) {+ domBuilder.endPrefixMapping(prefix);+ }+ }+ }+ } else {+ el.currentNSMap = currentNSMap;+ el.localNSMap = localNSMap;+ return true;+ }+ }+ function parseHtmlSpecialContent(source, elStartEnd, tagName, entityReplacer, domBuilder) {+ var isEscapableRaw = isHTMLEscapableRawTextElement(tagName);+ if (isEscapableRaw || isHTMLRawTextElement(tagName)) {+ var closeTag = new RegExp("</" + tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + ">", "ig");+ closeTag.lastIndex = elStartEnd;+ var match = closeTag.exec(source);+ var elEndStart = match ? match.index : -1;+ if (elEndStart < 0) {+ return elStartEnd + 1;+ }+ var text = source.substring(elStartEnd + 1, elEndStart);+ if (isEscapableRaw) {+ text = text.replace(ENTITY_REG, entityReplacer);+ }+ domBuilder.characters(text, 0, text.length);+ return elEndStart;+ }+ return elStartEnd + 1;+ }+ function _copy(source, target) {+ for (var n in source) {+ if (hasOwn(source, n)) {+ target[n] = source[n];+ }+ }+ }+ function parseUtils(source, start) {+ var index = start;+ function char(n) {+ n = n || 0;+ return source.charAt(index + n);+ }+ function skip(n) {+ n = n || 1;+ index += n;+ }+ function skipBlanks() {+ var blanks = 0;+ while (index < source.length) {+ var c = char();+ if (c !== " " && c !== "\n" && c !== " " && c !== "\r") {+ return blanks;+ }+ blanks++;+ skip();+ }+ return -1;+ }+ function substringFromIndex() {+ return source.substring(index);+ }+ function substringStartsWith(text) {+ return source.substring(index, index + text.length) === text;+ }+ function substringStartsWithCaseInsensitive(text) {+ return source.substring(index, index + text.length).toUpperCase() === text.toUpperCase();+ }+ function getMatch(args) {+ var expr = g.reg("^", args);+ var match = expr.exec(substringFromIndex());+ if (match) {+ skip(match[0].length);+ return match[0];+ }+ return null;+ }+ return {+ char,+ getIndex: function() {+ return index;+ },+ getMatch,+ getSource: function() {+ return source;+ },+ skip,+ skipBlanks,+ substringFromIndex,+ substringStartsWith,+ substringStartsWithCaseInsensitive+ };+ }+ function parseDoctypeInternalSubset(p, errorHandler) {+ function parsePI(p2, errorHandler2) {+ var match = g.PI.exec(p2.substringFromIndex());+ if (!match) {+ return errorHandler2.fatalError("processing instruction is not well-formed at position " + p2.getIndex());+ }+ if (match[1].toLowerCase() === "xml") {+ return errorHandler2.fatalError(+ "xml declaration is only allowed at the start of the document, but found at position " + p2.getIndex()+ );+ }+ p2.skip(match[0].length);+ return match[0];+ }+ var source = p.getSource();+ if (p.char() === "[") {+ p.skip(1);+ var intSubsetStart = p.getIndex();+ while (p.getIndex() < source.length) {+ p.skipBlanks();+ if (p.char() === "]") {+ var internalSubset = source.substring(intSubsetStart, p.getIndex());+ p.skip(1);+ return internalSubset;+ }+ var current = null;+ if (p.char() === "<" && p.char(1) === "!") {+ switch (p.char(2)) {+ case "E":+ if (p.char(3) === "L") {+ current = p.getMatch(g.elementdecl);+ } else if (p.char(3) === "N") {+ current = p.getMatch(g.EntityDecl);+ }+ break;+ case "A":+ current = p.getMatch(g.AttlistDecl);+ break;+ case "N":+ current = p.getMatch(g.NotationDecl);+ break;+ case "-":+ current = p.getMatch(g.Comment);+ break;+ }+ } else if (p.char() === "<" && p.char(1) === "?") {+ current = parsePI(p, errorHandler);+ } else if (p.char() === "%") {+ current = p.getMatch(g.PEReference);+ } else {+ return errorHandler.fatalError("Error detected in Markup declaration");+ }+ if (!current) {+ return errorHandler.fatalError("Error in internal subset at position " + p.getIndex());+ }+ }+ return errorHandler.fatalError("doctype internal subset is not well-formed, missing ]");+ }+ }+ function parseDoctypeCommentOrCData(source, start, domBuilder, errorHandler, isHTML) {+ var p = parseUtils(source, start);+ switch (isHTML ? p.char(2).toUpperCase() : p.char(2)) {+ case "-":+ var comment = p.getMatch(g.Comment);+ if (comment) {+ domBuilder.comment(comment, g.COMMENT_START.length, comment.length - g.COMMENT_START.length - g.COMMENT_END.length);+ return p.getIndex();+ } else {+ return errorHandler.fatalError("comment is not well-formed at position " + p.getIndex());+ }+ case "[":+ var cdata = p.getMatch(g.CDSect);+ if (cdata) {+ if (!isHTML && !domBuilder.currentElement) {+ return errorHandler.fatalError("CDATA outside of element");+ }+ domBuilder.startCDATA();+ domBuilder.characters(cdata, g.CDATA_START.length, cdata.length - g.CDATA_START.length - g.CDATA_END.length);+ domBuilder.endCDATA();+ return p.getIndex();+ } else {+ return errorHandler.fatalError("Invalid CDATA starting at position " + start);+ }+ case "D": {+ if (domBuilder.doc && domBuilder.doc.documentElement) {+ return errorHandler.fatalError("Doctype not allowed inside or after documentElement at position " + p.getIndex());+ }+ if (isHTML ? !p.substringStartsWithCaseInsensitive(g.DOCTYPE_DECL_START) : !p.substringStartsWith(g.DOCTYPE_DECL_START)) {+ return errorHandler.fatalError("Expected " + g.DOCTYPE_DECL_START + " at position " + p.getIndex());+ }+ p.skip(g.DOCTYPE_DECL_START.length);+ if (p.skipBlanks() < 1) {+ return errorHandler.fatalError("Expected whitespace after " + g.DOCTYPE_DECL_START + " at position " + p.getIndex());+ }+ var doctype = {+ name: void 0,+ publicId: void 0,+ systemId: void 0,+ internalSubset: void 0+ };+ doctype.name = p.getMatch(g.Name);+ if (!doctype.name)+ return errorHandler.fatalError("doctype name missing or contains unexpected characters at position " + p.getIndex());+ if (isHTML && doctype.name.toLowerCase() !== "html") {+ errorHandler.warning("Unexpected DOCTYPE in HTML document at position " + p.getIndex());+ }+ p.skipBlanks();+ if (p.substringStartsWith(g.PUBLIC) || p.substringStartsWith(g.SYSTEM)) {+ var match = g.ExternalID_match.exec(p.substringFromIndex());+ if (!match) {+ return errorHandler.fatalError("doctype external id is not well-formed at position " + p.getIndex());+ }+ if (match.groups.SystemLiteralOnly !== void 0) {+ doctype.systemId = match.groups.SystemLiteralOnly;+ } else {+ doctype.systemId = match.groups.SystemLiteral;+ doctype.publicId = match.groups.PubidLiteral;+ }+ p.skip(match[0].length);+ } else if (isHTML && p.substringStartsWithCaseInsensitive(g.SYSTEM)) {+ p.skip(g.SYSTEM.length);+ if (p.skipBlanks() < 1) {+ return errorHandler.fatalError("Expected whitespace after " + g.SYSTEM + " at position " + p.getIndex());+ }+ doctype.systemId = p.getMatch(g.ABOUT_LEGACY_COMPAT_SystemLiteral);+ if (!doctype.systemId) {+ return errorHandler.fatalError(+ "Expected " + g.ABOUT_LEGACY_COMPAT + " in single or double quotes after " + g.SYSTEM + " at position " + p.getIndex()+ );+ }+ }+ if (isHTML && doctype.systemId && !g.ABOUT_LEGACY_COMPAT_SystemLiteral.test(doctype.systemId)) {+ errorHandler.warning("Unexpected doctype.systemId in HTML document at position " + p.getIndex());+ }+ if (!isHTML) {+ p.skipBlanks();+ doctype.internalSubset = parseDoctypeInternalSubset(p, errorHandler);+ }+ p.skipBlanks();+ if (p.char() !== ">") {+ return errorHandler.fatalError("doctype not terminated with > at position " + p.getIndex());+ }+ p.skip(1);+ domBuilder.startDTD(doctype.name, doctype.publicId, doctype.systemId, doctype.internalSubset);+ domBuilder.endDTD();+ return p.getIndex();+ }+ default:+ return errorHandler.fatalError('Not well-formed XML starting with "<!" at position ' + start);+ }+ }+ function parseProcessingInstruction(source, start, domBuilder, errorHandler) {+ var match = source.substring(start).match(g.PI);+ if (!match) {+ return errorHandler.fatalError("Invalid processing instruction starting at position " + start);+ }+ if (match[1].toLowerCase() === "xml") {+ if (start > 0) {+ return errorHandler.fatalError(+ "processing instruction at position " + start + " is an xml declaration which is only at the start of the document"+ );+ }+ if (!g.XMLDecl.test(source.substring(start))) {+ return errorHandler.fatalError("xml declaration is not well-formed");+ }+ }+ domBuilder.processingInstruction(match[1], match[2]);+ return start + match[0].length;+ }+ function ElementAttributes() {+ this.attributeNames = /* @__PURE__ */ Object.create(null);+ }+ ElementAttributes.prototype = {+ setTagName: function(tagName) {+ if (!g.QName_exact.test(tagName)) {+ throw new Error("invalid tagName:" + tagName);+ }+ this.tagName = tagName;+ },+ addValue: function(qName, value, offset) {+ if (!g.QName_exact.test(qName)) {+ throw new Error("invalid attribute:" + qName);+ }+ this.attributeNames[qName] = this.length;+ this[this.length++] = { qName, value, offset };+ },+ length: 0,+ getLocalName: function(i) {+ return this[i].localName;+ },+ getLocator: function(i) {+ return this[i].locator;+ },+ getQName: function(i) {+ return this[i].qName;+ },+ getURI: function(i) {+ return this[i].uri;+ },+ getValue: function(i) {+ return this[i].value;+ }+ // ,getIndex:function(uri, localName)){+ // if(localName){+ //+ // }else{+ // var qName = uri+ // }+ // },+ // getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},+ // getType:function(uri,localName){}+ // getType:function(i){},+ };+ exports.XMLReader = XMLReader;+ exports.parseUtils = parseUtils;+ exports.parseDoctypeCommentOrCData = parseDoctypeCommentOrCData;+ }+});++// node_modules/@xmldom/xmldom/lib/dom-parser.js+var require_dom_parser = __commonJS({+ "node_modules/@xmldom/xmldom/lib/dom-parser.js"(exports) {+ "use strict";+ var conventions = require_conventions();+ var dom = require_dom();+ var errors = require_errors();+ var entities = require_entities();+ var sax = require_sax();+ var DOMImplementation = dom.DOMImplementation;+ var hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;+ var isHTMLMimeType = conventions.isHTMLMimeType;+ var isValidMimeType = conventions.isValidMimeType;+ var MIME_TYPE = conventions.MIME_TYPE;+ var NAMESPACE = conventions.NAMESPACE;+ var ParseError = errors.ParseError;+ var XMLReader = sax.XMLReader;+ function normalizeLineEndings(input) {+ return input.replace(/\r[\n\u0085]/g, "\n").replace(/[\r\u0085\u2028\u2029]/g, "\n");+ }+ function DOMParser2(options) {+ options = options || {};+ if (options.locator === void 0) {+ options.locator = true;+ }+ this.assign = options.assign || conventions.assign;+ this.domHandler = options.domHandler || DOMHandler;+ this.onError = options.onError || options.errorHandler;+ if (options.errorHandler && typeof options.errorHandler !== "function") {+ throw new TypeError("errorHandler object is no longer supported, switch to onError!");+ } else if (options.errorHandler) {+ options.errorHandler("warning", "The `errorHandler` option has been deprecated, use `onError` instead!", this);+ }+ this.normalizeLineEndings = options.normalizeLineEndings || normalizeLineEndings;+ this.locator = !!options.locator;+ this.xmlns = this.assign(/* @__PURE__ */ Object.create(null), options.xmlns);+ }+ DOMParser2.prototype.parseFromString = function(source, mimeType) {+ if (!isValidMimeType(mimeType)) {+ throw new TypeError('DOMParser.parseFromString: the provided mimeType "' + mimeType + '" is not valid.');+ }+ var defaultNSMap = this.assign(/* @__PURE__ */ Object.create(null), this.xmlns);+ var entityMap = entities.XML_ENTITIES;+ var defaultNamespace = defaultNSMap[""] || null;+ if (hasDefaultHTMLNamespace(mimeType)) {+ entityMap = entities.HTML_ENTITIES;+ defaultNamespace = NAMESPACE.HTML;+ } else if (mimeType === MIME_TYPE.XML_SVG_IMAGE) {+ defaultNamespace = NAMESPACE.SVG;+ }+ defaultNSMap[""] = defaultNamespace;+ defaultNSMap.xml = defaultNSMap.xml || NAMESPACE.XML;+ var domBuilder = new this.domHandler({+ mimeType,+ defaultNamespace,+ onError: this.onError+ });+ var locator = this.locator ? {} : void 0;+ if (this.locator) {+ domBuilder.setDocumentLocator(locator);+ }+ var sax2 = new XMLReader();+ sax2.errorHandler = domBuilder;+ sax2.domBuilder = domBuilder;+ var isXml = !conventions.isHTMLMimeType(mimeType);+ if (isXml && typeof source !== "string") {+ sax2.errorHandler.fatalError("source is not a string");+ }+ sax2.parse(this.normalizeLineEndings(String(source)), defaultNSMap, entityMap);+ if (!domBuilder.doc.documentElement) {+ sax2.errorHandler.fatalError("missing root element");+ }+ return domBuilder.doc;+ };+ function DOMHandler(options) {+ var opt = options || {};+ this.mimeType = opt.mimeType || MIME_TYPE.XML_APPLICATION;+ this.defaultNamespace = opt.defaultNamespace || null;+ this.cdata = false;+ this.currentElement = void 0;+ this.doc = void 0;+ this.locator = void 0;+ this.onError = opt.onError;+ }+ function position(locator, node) {+ node.lineNumber = locator.lineNumber;+ node.columnNumber = locator.columnNumber;+ }+ DOMHandler.prototype = {+ /**+ * Either creates an XML or an HTML document and stores it under `this.doc`.+ * If it is an XML document, `this.defaultNamespace` is used to create it,+ * and it will not contain any `childNodes`.+ * If it is an HTML document, it will be created without any `childNodes`.+ *+ * @see http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html+ */+ startDocument: function() {+ var impl = new DOMImplementation();+ this.doc = isHTMLMimeType(this.mimeType) ? impl.createHTMLDocument(false) : impl.createDocument(this.defaultNamespace, "");+ },+ startElement: function(namespaceURI, localName, qName, attrs) {+ var doc = this.doc;+ var el = doc.createElementNS(namespaceURI, qName || localName);+ var len = attrs.length;+ appendElement(this, el);+ this.currentElement = el;+ this.locator && position(this.locator, el);+ for (var i = 0; i < len; i++) {+ var namespaceURI = attrs.getURI(i);+ var value = attrs.getValue(i);+ var qName = attrs.getQName(i);+ var attr = doc.createAttributeNS(namespaceURI, qName);+ this.locator && position(attrs.getLocator(i), attr);+ attr.value = attr.nodeValue = value;+ el.setAttributeNode(attr);+ }+ },+ endElement: function(namespaceURI, localName, qName) {+ this.currentElement = this.currentElement.parentNode;+ },+ startPrefixMapping: function(prefix, uri) {+ },+ endPrefixMapping: function(prefix) {+ },+ processingInstruction: function(target, data) {+ var ins = this.doc.createProcessingInstruction(target, data);+ this.locator && position(this.locator, ins);+ appendElement(this, ins);+ },+ ignorableWhitespace: function(ch, start, length) {+ },+ characters: function(chars, start, length) {+ chars = _toString.apply(this, arguments);+ if (chars) {+ if (this.cdata) {+ var charNode = this.doc.createCDATASection(chars);+ } else {+ var charNode = this.doc.createTextNode(chars);+ }+ if (this.currentElement) {+ this.currentElement.appendChild(charNode);+ } else if (/^\s*$/.test(chars)) {+ this.doc.appendChild(charNode);+ }+ this.locator && position(this.locator, charNode);+ }+ },+ skippedEntity: function(name) {+ },+ endDocument: function() {+ this.doc.normalize();+ },+ /**+ * Stores the locator to be able to set the `columnNumber` and `lineNumber`+ * on the created DOM nodes.+ *+ * @param {Locator} locator+ */+ setDocumentLocator: function(locator) {+ if (locator) {+ locator.lineNumber = 0;+ }+ this.locator = locator;+ },+ //LexicalHandler+ comment: function(chars, start, length) {+ chars = _toString.apply(this, arguments);+ var comm = this.doc.createComment(chars);+ this.locator && position(this.locator, comm);+ appendElement(this, comm);+ },+ startCDATA: function() {+ this.cdata = true;+ },+ endCDATA: function() {+ this.cdata = false;+ },+ startDTD: function(name, publicId, systemId, internalSubset) {+ var impl = this.doc.implementation;+ if (impl && impl.createDocumentType) {+ var dt = impl.createDocumentType(name, publicId, systemId, internalSubset);+ this.locator && position(this.locator, dt);+ appendElement(this, dt);+ this.doc.doctype = dt;+ }+ },+ reportError: function(level, message) {+ if (typeof this.onError === "function") {+ try {+ this.onError(level, message, this);+ } catch (e) {+ throw new ParseError("Reporting " + level + ' "' + message + '" caused ' + e, this.locator);+ }+ } else {+ console.error("[xmldom " + level + "] " + message, _locator(this.locator));+ }+ },+ /**+ * @see http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html+ */+ warning: function(message) {+ this.reportError("warning", message);+ },+ error: function(message) {+ this.reportError("error", message);+ },+ /**+ * This function reports a fatal error and throws a ParseError.+ *+ * @param {string} message+ * - The message to be used for reporting and throwing the error.+ * @param {Error} [cause]+ * The error that caused this fatal error, preserved as the thrown `ParseError`'s `cause`.+ * @returns {never}+ * This function always throws an error and never returns a value.+ * @throws {ParseError}+ * Always throws a ParseError with the provided message.+ */+ fatalError: function(message, cause) {+ this.reportError("fatalError", message);+ throw new ParseError(message, this.locator, cause);+ }+ };+ function _locator(l) {+ if (l) {+ return "\n@#[line:" + l.lineNumber + ",col:" + l.columnNumber + "]";+ }+ }+ function _toString(chars, start, length) {+ if (typeof chars == "string") {+ return chars.substr(start, length);+ } else {+ if (chars.length >= start + length || start) {+ return new java.lang.String(chars, start, length) + "";+ }+ return chars;+ }+ }+ "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(+ /\w+/g,+ function(key) {+ DOMHandler.prototype[key] = function() {+ return null;+ };+ }+ );+ function appendElement(handler, node) {+ if (!handler.currentElement) {+ handler.doc.appendChild(node);+ } else {+ handler.currentElement.appendChild(node);+ }+ }+ function onErrorStopParsing(level) {+ if (level === "error") throw "onErrorStopParsing";+ }+ function onWarningStopParsing() {+ throw "onWarningStopParsing";+ }+ exports.__DOMHandler = DOMHandler;+ exports.DOMParser = DOMParser2;+ exports.normalizeLineEndings = normalizeLineEndings;+ exports.onErrorStopParsing = onErrorStopParsing;+ exports.onWarningStopParsing = onWarningStopParsing;+ }+});++// node_modules/@xmldom/xmldom/lib/index.js+var require_lib = __commonJS({+ "node_modules/@xmldom/xmldom/lib/index.js"(exports) {+ "use strict";+ var conventions = require_conventions();+ exports.assign = conventions.assign;+ exports.hasDefaultHTMLNamespace = conventions.hasDefaultHTMLNamespace;+ exports.isHTMLMimeType = conventions.isHTMLMimeType;+ exports.isValidMimeType = conventions.isValidMimeType;+ exports.MIME_TYPE = conventions.MIME_TYPE;+ exports.NAMESPACE = conventions.NAMESPACE;+ var errors = require_errors();+ exports.DOMException = errors.DOMException;+ exports.DOMExceptionName = errors.DOMExceptionName;+ exports.ExceptionCode = errors.ExceptionCode;+ exports.ParseError = errors.ParseError;+ var dom = require_dom();+ exports.Attr = dom.Attr;+ exports.CDATASection = dom.CDATASection;+ exports.CharacterData = dom.CharacterData;+ exports.Comment = dom.Comment;+ exports.Document = dom.Document;+ exports.DocumentFragment = dom.DocumentFragment;+ exports.DocumentType = dom.DocumentType;+ exports.DOMImplementation = dom.DOMImplementation;+ exports.Element = dom.Element;+ exports.Entity = dom.Entity;+ exports.EntityReference = dom.EntityReference;+ exports.LiveNodeList = dom.LiveNodeList;+ exports.NamedNodeMap = dom.NamedNodeMap;+ exports.Node = dom.Node;+ exports.NodeList = dom.NodeList;+ exports.Notation = dom.Notation;+ exports.ProcessingInstruction = dom.ProcessingInstruction;+ exports.Text = dom.Text;+ exports.XMLSerializer = dom.XMLSerializer;+ var domParser = require_dom_parser();+ exports.DOMParser = domParser.DOMParser;+ exports.normalizeLineEndings = domParser.normalizeLineEndings;+ exports.onErrorStopParsing = domParser.onErrorStopParsing;+ exports.onWarningStopParsing = domParser.onWarningStopParsing;+ }+});++// src/office/cli.js+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";+import { join as join2 } from "node:path";+import { parseArgs } from "node:util";++// src/office/package.js+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmdirSync, statSync, unlinkSync, writeFileSync } from "node:fs";+import { dirname, join, posix, resolve, sep } from "node:path";++// src/office/xml.js+var xml_exports = {};+__export(xml_exports, {+ NS: () => NS,+ XmlError: () => XmlError,+ childrenOf: () => childrenOf,+ elementsOf: () => elementsOf,+ firstOf: () => firstOf,+ parseXml: () => parseXml,+ parser: () => parser,+ prettyXml: () => prettyXml,+ qname: () => qname,+ serializeXml: () => serializeXml,+ stripPrettyWhitespace: () => stripPrettyWhitespace,+ textOf: () => textOf+});+var import_xmldom = __toESM(require_lib(), 1);+var NS = {+ w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",+ w14: "http://schemas.microsoft.com/office/word/2010/wordml",+ wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",+ a: "http://schemas.openxmlformats.org/drawingml/2006/main",+ r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",+ p: "http://schemas.openxmlformats.org/presentationml/2006/main",+ c: "http://schemas.openxmlformats.org/drawingml/2006/chart",+ rel: "http://schemas.openxmlformats.org/package/2006/relationships",+ ct: "http://schemas.openxmlformats.org/package/2006/content-types",+ xml: "http://www.w3.org/XML/1998/namespace"+};+var parser = new import_xmldom.DOMParser({ onError: (level, message) => {+ throw new XmlError(message);+} });+var serializer = new import_xmldom.XMLSerializer();+var XmlError = class extends Error {+ constructor(message) {+ super(`XML not well-formed: ${message}`);+ this.code = "xml";+ }+};+function parseXml(text) {+ return parser.parseFromString(String(text), "text/xml");+}+function serializeXml(node) {+ return serializer.serializeToString(node);+}+function qname(ns, local) {+ return `${ns}:${local}`;+}+var TEXT_TAGS = /* @__PURE__ */ new Set(["w:t", "w:delText", "w:instrText", "a:t", "m:t"]);+function preserved(element) {+ for (let node = element; node && node.nodeType === 1; node = node.parentNode) {+ if (node.getAttribute?.("xml:space") === "preserve") return true;+ }+ return false;+}+function prettyXml(doc) {+ const indent = (node, depth) => {+ const children = [...node.childNodes];+ if (children.length === 0 || preserved(node) || children.some((child2) => child2.nodeType === 3 || child2.nodeType === 4)) return;+ const pad = "\n" + " ".repeat(depth);+ for (const child2 of children) {+ if (child2.nodeType === 1) indent(child2, depth + 1);+ node.insertBefore(doc.createTextNode(pad), child2);+ }+ node.appendChild(doc.createTextNode("\n" + " ".repeat(Math.max(0, depth - 1))));+ };+ indent(doc.documentElement, 1);+ return serializeXml(doc);+}+function stripPrettyWhitespace(doc) {+ const drop = [];+ const walk = (node) => {+ if (node.nodeType === 3) {+ if (node.data.trim() === "" && !preserved(node.parentNode) && !TEXT_TAGS.has(node.parentNode?.tagName)) drop.push(node);+ return;+ }+ for (const child2 of [...node.childNodes]) walk(child2);+ };+ walk(doc.documentElement);+ for (const node of drop) node.parentNode.removeChild(node);+}+function childrenOf(node, tag) {+ return [...node?.childNodes ?? []].filter((child2) => child2.nodeType === 1 && (tag === void 0 || child2.tagName === tag));+}+function elementsOf(node, tag) {+ const found = [];+ const walk = (el) => {+ if (el.nodeType !== 1) return;+ if (tag === void 0 || el.tagName === tag) found.push(el);+ for (const child2 of childrenOf(el)) walk(child2);+ };+ walk(node);+ return found;+}+function firstOf(node, tag) {+ if (node.tagName === tag && node.nodeType === 1) return node;+ for (const child2 of childrenOf(node)) {+ const hit = firstOf(child2, tag);+ if (hit) return hit;+ }+ return void 0;+}+function textOf(node, { skipDeleted = true } = {}) {+ let out = "";+ const walk = (el, deleted) => {+ if (el.nodeType === 3 || el.nodeType === 4) {+ if (!deleted) out += el.data;+ return;+ }+ if (el.nodeType !== 1) return;+ const gone = deleted || skipDeleted && (el.tagName === "w:del" || el.tagName === "w:moveFrom");+ for (const child2 of [...el.childNodes]) walk(child2, gone);+ };+ walk(node, false);+ return out;+}++// src/office/zip.js+import { deflateRawSync, inflateRawSync } from "node:zlib";+var EOCD = 101010256;+var CDIR = 33639248;+var LOCAL = 67324752;+function fail(message) {+ const error = new Error(message);+ error.code = "zip";+ throw error;+}+function readZip(buf) {+ let eocd = -1;+ for (let i = buf.length - 22; i >= Math.max(0, buf.length - 22 - 65536); i--) {+ if (buf.readUInt32LE(i) === EOCD) {+ eocd = i;+ break;+ }+ }+ if (eocd < 0) fail("not a ZIP file: no end of central directory");+ const count = buf.readUInt16LE(eocd + 10);+ const cdSize = buf.readUInt32LE(eocd + 12);+ let cdOff = buf.readUInt32LE(eocd + 16);+ if (count === 65535 || cdSize === 4294967295 || cdOff === 4294967295) fail("zip64 archives are not supported");+ const members = [];+ for (let i = 0; i < count; i++) {+ if (buf.readUInt32LE(cdOff) !== CDIR) fail("corrupt central directory");+ const flags = buf.readUInt16LE(cdOff + 8);+ const method = buf.readUInt16LE(cdOff + 10);+ const crc = buf.readUInt32LE(cdOff + 16);+ const csize = buf.readUInt32LE(cdOff + 20);+ const usize = buf.readUInt32LE(cdOff + 24);+ const nameLen = buf.readUInt16LE(cdOff + 28);+ const extraLen = buf.readUInt16LE(cdOff + 30);+ const commentLen = buf.readUInt16LE(cdOff + 32);+ const localOff = buf.readUInt32LE(cdOff + 42);+ if (csize === 4294967295 || usize === 4294967295) fail("zip64 archives are not supported");+ const name = buf.subarray(cdOff + 46, cdOff + 46 + nameLen).toString("utf8");+ const norm = name.replace(/\\/g, "/");+ if (norm.startsWith("/") || /^[A-Za-z]:/.test(norm) || norm.split("/").includes("..")) fail(`zip: unsafe member name ${name}`);+ if (buf.readUInt32LE(localOff) !== LOCAL) fail(`corrupt local header for ${name}`);+ const lNameLen = buf.readUInt16LE(localOff + 26);+ const lExtraLen = buf.readUInt16LE(localOff + 28);+ const raw = buf.subarray(localOff + 30 + lNameLen + lExtraLen, localOff + 30 + lNameLen + lExtraLen + csize);+ let data;+ if (method === 0) data = raw.subarray(0, usize);+ else if (method === 8) {+ try {+ data = inflateRawSync(raw, { maxOutputLength: Math.max(usize, 1) });+ } catch (err) {+ if (err instanceof RangeError || err?.code === "ERR_OUT_OF_RANGE") fail(`${name} inflates past its declared size`);+ fail(`corrupt data for ${name}`);+ }+ } else fail(`unsupported compression method ${method} for ${name}`);+ if (data.length !== usize) fail(`size mismatch for ${name}`);+ members.push({ name, data, raw, method, crc, flags: flags & 2048, extra: buf.subarray(cdOff + 46 + nameLen, cdOff + 46 + nameLen + extraLen) });+ cdOff += 46 + nameLen + extraLen + commentLen;+ }+ return members;+}+function writeZip(members) {+ const ordered = [...members].sort((a, b) => (a.name === "[Content_Types].xml" ? -1 : 0) - (b.name === "[Content_Types].xml" ? -1 : 0));+ const local = [], central = [];+ let offset = 0;+ for (const member of ordered) {+ const nameBuf = Buffer.from(member.name, "utf8");+ let raw, crc, usize, method;+ if (member.raw !== void 0 && member.data === void 0) {+ raw = member.raw;+ crc = member.crc;+ usize = member.usize;+ method = member.method;+ if (method === 0 && usize === void 0) usize = raw.length;+ } else {+ const plain = member.data ?? inflateRawSync(member.raw);+ method = member.method === 0 ? 0 : 8;+ raw = method === 0 ? plain : deflateRawSync(plain, { level: 9 });+ crc = crc32(plain);+ usize = plain.length;+ }+ const head = Buffer.alloc(30);+ head.writeUInt32LE(LOCAL, 0);+ head.writeUInt16LE(20, 4);+ head.writeUInt16LE(member.flags ?? 2048, 6);+ head.writeUInt16LE(method, 8);+ head.writeUInt16LE(0, 10);+ head.writeUInt16LE(0, 12);+ head.writeUInt32LE(crc >>> 0, 14);+ head.writeUInt32LE(raw.length, 18);+ head.writeUInt32LE(usize, 22);+ head.writeUInt16LE(nameBuf.length, 26);+ head.writeUInt16LE(0, 28);+ local.push(head, nameBuf, raw);+ const cent = Buffer.alloc(46);+ cent.writeUInt32LE(CDIR, 0);+ cent.writeUInt16LE(20, 4);+ cent.writeUInt16LE(20, 6);+ cent.writeUInt16LE(member.flags ?? 2048, 8);+ cent.writeUInt16LE(method, 10);+ cent.writeUInt16LE(0, 12);+ cent.writeUInt16LE(0, 14);+ cent.writeUInt32LE(crc >>> 0, 16);+ cent.writeUInt32LE(raw.length, 20);+ cent.writeUInt32LE(usize, 24);+ cent.writeUInt16LE(nameBuf.length, 28);+ cent.writeUInt32LE(0, 38);+ cent.writeUInt32LE(offset, 42);+ central.push(cent, nameBuf);+ offset += 30 + nameBuf.length + raw.length;+ }+ const cd = Buffer.concat(central);+ const end = Buffer.alloc(22);+ end.writeUInt32LE(EOCD, 0);+ end.writeUInt16LE(ordered.length, 8);+ end.writeUInt16LE(ordered.length, 10);+ end.writeUInt32LE(cd.length, 12);+ end.writeUInt32LE(offset, 16);+ return Buffer.concat([...local, cd, end]);+}+var TABLE = (() => {+ const table = new Int32Array(256);+ for (let n = 0; n < 256; n++) {+ let c = n;+ for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;+ table[n] = c;+ }+ return table;+})();+function crc32(buf) {+ let crc = ~0;+ for (const byte of buf) crc = TABLE[(crc ^ byte) & 255] ^ crc >>> 8;+ return ~crc >>> 0;+}++// src/office/package.js+function fail2(message) {+ const error = new Error(message);+ error.code = "package";+ throw error;+}+var absTarget = (base, target) => {+ if (target.startsWith("/")) return target.slice(1);+ return posix.normalize(posix.join(posix.dirname(base), target));+};+var relSig = (map) => [...map.values()].map((r) => `${r.id}${r.type}${r.target}${r.mode}`).join("");+var Package = class _Package {+ constructor() {+ this.parts = /* @__PURE__ */ new Map();+ this.rels = /* @__PURE__ */ new Map();+ this.defaults = /* @__PURE__ */ new Map();+ this.overrides = /* @__PURE__ */ new Map();+ }+ /** @param {string} file - a ZIP package file */+ static open(file) {+ const pkg = new _Package();+ for (const member of readZip(readFileSync(file))) {+ pkg.parts.set(member.name, { raw: member.raw, method: member.method, crc: member.crc, usize: member.data.length });+ pkg.#cache(member.name, member.data);+ }+ pkg.#readModel();+ return pkg;+ }+ /** @param {string} dir - a directory tree as `unpack` writes it */+ static loadDir(dir) {+ const pkg = new _Package();+ const walk = (base, rel) => {+ for (const entry of readdirSync(join(base, rel))) {+ const path = rel === "" ? entry : `${rel}/${entry}`;+ if (statSync(join(base, path)).isDirectory()) walk(base, path);+ else {+ const data = readFileSync(join(base, path));+ pkg.parts.set(path, { data });+ pkg.#cache(path, data);+ }+ }+ };+ walk(dir, "");+ pkg.#readModel();+ return pkg;+ }+ #cache(name, data) {+ (this.dataCache ??= /* @__PURE__ */ new Map()).set(name, data);+ }+ #readModel() {+ const ct = this.get("[Content_Types].xml");+ if (ct === void 0) fail2("[Content_Types].xml missing");+ const doc = parseXml(ct);+ for (const el of childrenOf(doc.documentElement)) {+ if (el.tagName === "Default") this.defaults.set(el.getAttribute("Extension"), el.getAttribute("ContentType"));+ else if (el.tagName === "Override") this.overrides.set(el.getAttribute("PartName").replace(/^\//, ""), el.getAttribute("ContentType"));+ }+ for (const name of this.parts.keys()) {+ if (!name.endsWith(".rels")) continue;+ const owner = name === "_rels/.rels" ? "" : posix.dirname(posix.dirname(name)) + "/" + posix.basename(name, ".rels");+ const map = /* @__PURE__ */ new Map();+ try {+ for (const rel of childrenOf(parseXml(this.get(name)).documentElement, "Relationship")) {+ map.set(rel.getAttribute("Id"), {+ id: rel.getAttribute("Id"),+ type: rel.getAttribute("Type"),+ target: rel.getAttribute("Target"),+ mode: rel.getAttribute("TargetMode") ?? "Internal"+ });+ }+ } catch {+ }+ this.rels.set(owner, map);+ }+ this.relSigs = new Map([...this.rels].map(([owner, map]) => [owner, relSig(map)]));+ this.ctSig = JSON.stringify([...this.defaults].sort().concat([...this.overrides].filter(([n]) => this.parts.has(n)).sort()));+ }+ /** @returns {Buffer|undefined} part bytes */+ get(name) {+ return this.dataCache?.get(name) ?? this.parts.get(name)?.data;+ }+ /** @returns {Document} parsed XML part */+ xml(name) {+ return parseXml(this.get(name));+ }+ /** Store XML text (or bytes) as a part, replacing its entry. */+ put(name, content) {+ const data = Buffer.isBuffer(content) ? content : Buffer.from(content, "utf8");+ this.parts.set(name, { data });+ this.#cache(name, data);+ }+ putXml(name, doc) {+ this.put(name, serializeXml(doc));+ }+ remove(name) {+ this.parts.delete(name);+ this.dataCache?.delete(name);+ }+ /** @returns {string|undefined} content type for a part, from Override or Default */+ contentType(name) {+ return this.overrides.get(name) ?? this.defaults.get(name.slice(name.lastIndexOf(".") + 1));+ }+ /** Add or update an Override for a part. */+ override(name, type) {+ this.overrides.set(name, type);+ }+ /** The .rels owner name for a part ('word/document.xml' → itself, '' → package root). */+ relsOf(owner) {+ return this.rels.get(owner) ?? /* @__PURE__ */ new Map();+ }+ /** Absolute part name a relationship target resolves to. */+ targetOf(owner, target) {+ return absTarget(owner === "" ? "x" : owner, target);+ }+ /** @returns {{ id: string, type: string, target: string, mode: string }[]} relationships of a part (or package root) */+ relList(owner) {+ return [...this.relsOf(owner).values()];+ }+ /** @returns {string} the .rels part name for an owner part ('' for the package root). */+ relsName(owner) {+ return owner === "" ? "_rels/.rels" : `${posix.dirname(owner)}/_rels/${posix.basename(owner)}.rels`;+ }+ /** Write .rels and [Content_Types].xml back into parts from the model — a+ * .rels part changes only when its owner part is gone or its map's signature+ * differs from the load baseline, so malformed or empty-but-valid .rels keep+ * their bytes instead of being dropped. */+ flush() {+ for (const name of [...this.parts.keys()]) {+ if (!name.endsWith(".rels")) continue;+ const owner = this.#relsOwner(name);+ if (owner !== "" && !this.parts.has(owner)) this.parts.delete(name);+ }+ for (const [owner, map] of this.rels) {+ if (owner !== "" && !this.parts.has(owner)) {+ this.rels.delete(owner);+ continue;+ }+ const name = this.relsName(owner);+ const sig = relSig(map);+ const base = (this.relSigs ??= /* @__PURE__ */ new Map()).get(owner);+ if (map.size === 0) {+ if (base !== void 0 && base !== sig) this.parts.delete(name);+ continue;+ }+ if (sig === base && this.parts.has(name)) continue;+ const doc = parseXml('<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"/>');+ for (const rel of map.values()) {+ const el = doc.createElement("Relationship");+ el.setAttribute("Id", rel.id);+ el.setAttribute("Type", rel.type);+ el.setAttribute("Target", rel.target);+ if (rel.mode !== "Internal") el.setAttribute("TargetMode", rel.mode);+ doc.documentElement.appendChild(el);+ }+ this.putXml(name, doc);+ this.relSigs.set(owner, sig);+ }+ const ctSig = JSON.stringify([...this.defaults].sort().concat([...this.overrides].filter(([n]) => this.parts.has(n)).sort()));+ if (ctSig !== this.ctSig || !this.parts.has("[Content_Types].xml")) {+ const ct = parseXml('<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"/>');+ for (const [ext2, type] of this.defaults) {+ const el = ct.createElement("Default");+ el.setAttribute("Extension", ext2);+ el.setAttribute("ContentType", type);+ ct.documentElement.appendChild(el);+ }+ for (const [name, type] of this.overrides) {+ if (!this.parts.has(name)) continue;+ const el = ct.createElement("Override");+ el.setAttribute("PartName", `/${name}`);+ el.setAttribute("ContentType", type);+ ct.documentElement.appendChild(el);+ }+ this.putXml("[Content_Types].xml", ct);+ this.ctSig = ctSig;+ }+ this.parts.delete("");+ }+ #relsOwner(name) {+ return name === "_rels/.rels" ? "" : posix.dirname(posix.dirname(name)) + "/" + posix.basename(name, ".rels");+ }+ /** @returns {Buffer} the package as a ZIP */+ save() {+ this.flush();+ return writeZip([...this.parts.entries()].map(([name, part]) => ({ name, ...part })));+ }+ /** Write an `unpack` directory tree. An existing non-empty dir must hold an+ * earlier unpack ([Content_Types].xml at its root); files the package no+ * longer has are removed. The model is flushed first so .rels and content+ * types written to disk match the in-memory state. */+ unpack(dir) {+ this.flush();+ if (existsSync(dir) && readdirSync(dir).length > 0 && !existsSync(join(dir, "[Content_Types].xml"))) {+ fail2(`unpack: ${dir} exists and is not an earlier unpack`);+ }+ mkdirSync(dir, { recursive: true });+ const root = resolve(dir);+ const rootReal = realpathSync(dir);+ const keep = /* @__PURE__ */ new Set();+ for (const [name] of this.parts) {+ const file = join(dir, name);+ if (!resolve(file).startsWith(root + sep) && resolve(file) !== root) fail2(`unpack: unsafe member name ${name}`);+ keep.add(file);+ mkdirSync(dirname(file), { recursive: true });+ const parentReal = realpathSync(dirname(file));+ if (parentReal !== rootReal && !parentReal.startsWith(rootReal + sep)) fail2(`unpack: ${name} resolves outside ${dir}`);+ if (lstatSync(file, { throwIfNoEntry: false })?.isSymbolicLink()) fail2(`unpack: ${name} is a link`);+ const data = this.get(name);+ if (name.endsWith(".xml") || name.endsWith(".rels")) {+ try {+ writeFileSync(file, prettyForUnpack(data));+ continue;+ } catch {+ }+ }+ writeFileSync(file, data);+ }+ const sweep = (rel) => {+ for (const entry of readdirSync(join(dir, rel))) {+ const path = rel === "" ? entry : `${rel}/${entry}`;+ const full = join(dir, path);+ const st = lstatSync(full);+ if (st.isSymbolicLink()) fail2(`unpack: link inside ${dir}`);+ if (st.isDirectory()) {+ sweep(path);+ if (readdirSync(full).length === 0) rmdirSync(full);+ } else if (!keep.has(full)) unlinkSync(full);+ }+ };+ sweep("");+ }+};+function prettyForUnpack(data) {+ const { prettyXml: prettyXml2 } = xml_exports;+ return prettyXml2(parseXml(data));+}++// src/office/check.js+import { posix as posix2 } from "node:path";+var KNOWN_OVERRIDES = {+ "word/document.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",+ "word/styles.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",+ "word/numbering.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml",+ "word/settings.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml",+ "word/comments.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml",+ "word/footnotes.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",+ "word/endnotes.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml",+ "word/fontTable.xml": "application/vnd.openxmlformats-officedocument.wordprocessingml.fontTable+xml",+ "xl/workbook.xml": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml",+ "xl/sharedStrings.xml": "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml",+ "xl/styles.xml": "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml",+ "ppt/presentation.xml": "application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml",+ "docProps/core.xml": "application/vnd.openxmlformats-package.core-properties+xml",+ "docProps/app.xml": "application/vnd.openxmlformats-officedocument.extended-properties+xml"+};+var patternType = (name) => {+ if (KNOWN_OVERRIDES[name]) return KNOWN_OVERRIDES[name];+ const base = "application/vnd.openxmlformats-officedocument.";+ if (/^word\/header\d+\.xml$/.test(name)) return base + "wordprocessingml.header+xml";+ if (/^word\/footer\d+\.xml$/.test(name)) return base + "wordprocessingml.footer+xml";+ if (/^ppt\/slides\/slide\d+\.xml$/.test(name)) return base + "presentationml.slide+xml";+ if (/^ppt\/slideLayouts\/slideLayout\d+\.xml$/.test(name)) return base + "presentationml.slideLayout+xml";+ if (/^ppt\/slideMasters\/slideMaster\d+\.xml$/.test(name)) return base + "presentationml.slideMaster+xml";+ if (/^ppt\/notesSlides\/notesSlide\d+\.xml$/.test(name)) return base + "presentationml.notesSlide+xml";+ if (/^ppt\/notesMasters\/notesMaster\d+\.xml$/.test(name)) return base + "presentationml.notesMaster+xml";+ if (/^ppt\/theme\/theme\d+\.xml$/.test(name)) return base + "theme+xml";+ if (/^xl\/worksheets\/sheet\d+\.xml$/.test(name)) return base + "spreadsheetml.worksheet+xml";+ if (/^xl\/theme\/theme\d+\.xml$/.test(name)) return base + "theme+xml";+ return void 0;+};+var finding = (rule, part, message) => ({ rule, part, key: `${rule}|${part}|${message}`, message });+function checkPackage(pkg, original) {+ const found = runRules(pkg);+ if (!original) return found;+ const before = new Set(runRules(original).map((f) => f.key));+ return found.filter((f) => !before.has(f.key));+}+function runRules(pkg) {+ const out = [];+ const xmlDocs = /* @__PURE__ */ new Map();+ for (const name of pkg.parts.keys()) {+ if (!name.endsWith(".xml") && !name.endsWith(".rels")) continue;+ try {+ xmlDocs.set(name, parseXml(pkg.get(name)));+ } catch (error) {+ out.push(finding("malformed-xml", name, error.message.slice(0, 200)));+ }+ }+ for (const name of pkg.parts.keys()) {+ if (pkg.contentType(name) === void 0 && !name.endsWith("/")) {+ out.push(finding("no-content-type", name, `${name} has no Default or Override`));+ }+ }+ for (const part of pkg.overrides.keys()) {+ if (!pkg.parts.has(part)) out.push(finding("override-absent-part", part, `Override names absent part /${part}`));+ }+ for (const name of [...pkg.parts.keys()].filter((n) => n.endsWith(".rels"))) {+ const doc = xmlDocs.get(name);+ if (!doc) continue;+ const owner = name === "_rels/.rels" ? "" : posix2.dirname(posix2.dirname(name)) + "/" + posix2.basename(name, ".rels");+ const seen = /* @__PURE__ */ new Set();+ for (const rel of childrenOf(doc.documentElement, "Relationship")) {+ const id = rel.getAttribute("Id");+ if (seen.has(id)) out.push(finding("duplicate-rel-id", name, `relationship id ${id} used twice`));+ seen.add(id);+ if ((rel.getAttribute("TargetMode") ?? "Internal") !== "External") {+ const target = pkg.targetOf(owner, rel.getAttribute("Target"));+ if (!pkg.parts.has(target)) out.push(finding("dangling-rel", name, `${id} → ${target} is absent`));+ }+ }+ }+ for (const [name, doc] of xmlDocs) {+ if (name.endsWith(".rels")) continue;+ const rels = pkg.relsOf(name);+ for (const el of elementsOf(doc.documentElement)) {+ for (const attr of ["r:id", "r:embed", "r:link", "r:dm", "r:lo", "r:qs", "r:cs"]) {+ const value = el.getAttribute?.(attr);+ if (value && !rels.has(value)) out.push(finding("unknown-rel-ref", name, `${el.tagName} ${attr}="${value}" has no relationship`));+ }+ }+ }+ contentTypeRules(pkg, out);+ const isPptx = pkg.parts.has("ppt/presentation.xml"), isDocx = pkg.parts.has("word/document.xml");+ if (isPptx) pptxRules(pkg, xmlDocs, out);+ if (isDocx) docxRules(pkg, xmlDocs, out);+ return out;+}+var CT_BASE = "application/vnd.openxmlformats-officedocument.";+var pkgKind = (pkg) => pkg.parts.has("word/document.xml") ? "docx" : pkg.parts.has("ppt/presentation.xml") ? "pptx" : pkg.parts.has("xl/workbook.xml") ? "xlsx" : void 0;+var MAIN_CT = { docx: CT_BASE + "wordprocessingml.document.main+xml", pptx: CT_BASE + "presentationml.presentation.main+xml", xlsx: CT_BASE + "spreadsheetml.sheet.main+xml" };+var REL_TYPE_CT = {+ officeDocument: MAIN_CT,+ document: MAIN_CT,+ styles: { docx: CT_BASE + "wordprocessingml.styles+xml", xlsx: CT_BASE + "spreadsheetml.styles+xml" },+ numbering: CT_BASE + "wordprocessingml.numbering+xml",+ settings: CT_BASE + "wordprocessingml.settings+xml",+ comments: CT_BASE + "wordprocessingml.comments+xml",+ footnotes: CT_BASE + "wordprocessingml.footnotes+xml",+ endnotes: CT_BASE + "wordprocessingml.endnotes+xml",+ header: CT_BASE + "wordprocessingml.header+xml",+ footer: CT_BASE + "wordprocessingml.footer+xml",+ fontTable: CT_BASE + "wordprocessingml.fontTable+xml",+ theme: CT_BASE + "theme+xml",+ slide: CT_BASE + "presentationml.slide+xml",+ slideLayout: CT_BASE + "presentationml.slideLayout+xml",+ slideMaster: CT_BASE + "presentationml.slideMaster+xml",+ notesSlide: CT_BASE + "presentationml.notesSlide+xml",+ notesMaster: CT_BASE + "presentationml.notesMaster+xml",+ chart: CT_BASE + "drawingml.chart+xml",+ worksheet: CT_BASE + "spreadsheetml.worksheet+xml",+ sharedStrings: CT_BASE + "spreadsheetml.sharedStrings+xml",+ coreProperties: "application/vnd.openxmlformats-package.core-properties+xml",+ "core-properties": "application/vnd.openxmlformats-package.core-properties+xml",+ extendedProperties: CT_BASE + "extended-properties+xml",+ "extended-properties": CT_BASE + "extended-properties+xml"+};+function expectedContentType(pkg, relType) {+ const suffix = relType.split("/").pop();+ const rule = REL_TYPE_CT[suffix];+ if (rule === void 0) return void 0;+ if (typeof rule === "string") return rule;+ const kind = pkgKind(pkg);+ return kind ? rule[kind] : void 0;+}+function contentTypeRules(pkg, out) {+ for (const [owner, map] of pkg.rels) {+ for (const rel of map.values()) {+ if (rel.mode === "External") continue;+ const expected = expectedContentType(pkg, rel.type);+ if (expected === void 0) continue;+ const target = pkg.targetOf(owner, rel.target);+ if (!pkg.parts.has(target)) continue;+ const actual = pkg.contentType(target);+ if (actual !== expected) {+ out.push(finding("wrong-content-type", target, `${target} is ${actual ?? "untyped"}, expected ${expected} for ${rel.type.split("/").pop()}`));+ }+ }+ }+}+function uniqueIds(elements, attr, part, rule, out) {+ const seen = /* @__PURE__ */ new Set();+ for (const el of elements) {+ const id = el.getAttribute(attr);+ if (id !== null && seen.has(id)) out.push(finding(rule, part, `${el.tagName} @${attr}=${id} duplicated`));+ seen.add(id);+ }+}+function pptxRules(pkg, xmlDocs, out) {+ for (const [name, doc] of xmlDocs) {+ if (/^ppt\/slides\/slide\d+\.xml$/.test(name)) {+ uniqueIds(elementsOf(doc.documentElement, "p:cNvPr"), "id", name, "duplicate-shape-id", out);+ }+ if (name === "ppt/presentation.xml") {+ const lst = firstOf(doc.documentElement, "p:sldIdLst");+ const ids = [];+ for (const sld of childrenOf(lst ?? doc.documentElement, "p:sldId")) {+ const num = Number(sld.getAttribute("id"));+ ids.push(sld.getAttribute("id"));+ if (!Number.isInteger(num) || num < 256) out.push(finding("invalid-slide-id", name, `p:sldId id ${sld.getAttribute("id")} must be an integer ≥ 256`));+ const rid = sld.getAttribute("r:id");+ const rel = pkg.relsOf(name).get(rid);+ if (!rel) {+ out.push(finding("unknown-rel-ref", name, `p:sldId r:id="${rid}" has no relationship`));+ continue;+ }+ const target = pkg.targetOf(name, rel.target);+ if (!/^ppt\/slides\/slide\d+\.xml$/.test(target)) out.push(finding("sldid-not-slide", name, `p:sldId ${rid} → ${target}, not a slide part`));+ }+ const seen = /* @__PURE__ */ new Set();+ for (const id of ids) {+ if (seen.has(id)) out.push(finding("duplicate-slide-id", name, `p:sldId id ${id} used twice`));+ seen.add(id);+ }+ }+ }+}+function docxRules(pkg, xmlDocs, out) {+ const main2 = "word/document.xml";+ for (const [name, doc] of xmlDocs) {+ if (name !== main2 && !/^word\/(header|footer)\d+\.xml$|^word\/(footnotes|endnotes|comments)\.xml$/.test(name)) continue;+ uniqueIds(elementsOf(doc.documentElement, "wp:docPr"), "id", name, "duplicate-docpr-id", out);+ const paraIds = elementsOf(doc.documentElement, "w:p").map((p) => p.getAttribute("w14:paraId")).filter(Boolean);+ uniqueIds(paraIds.map((id) => ({ getAttribute: () => id, tagName: "w:p" })), null, name, "duplicate-paraid", out);+ for (const p of elementsOf(doc.documentElement, "w:p")) {+ const id = p.getAttribute("w14:paraId");+ if (id && parseInt(id, 16) >= 2147483648) out.push(finding("invalid-paraid", name, `w14:paraId ${id} ≥ 0x80000000`));+ }+ for (const tag of ["w:t", "w:delText", "w:instrText"]) {+ for (const el of elementsOf(doc.documentElement, tag)) {+ const text = el.textContent;+ if (text !== text.trim() && el.getAttribute("xml:space") !== "preserve") {+ out.push(finding("missing-xml-space", name, `${tag} "${text.slice(0, 30).trim()}…" needs xml:space="preserve"`));+ }+ }+ }+ if (name === main2) {+ const comments = xmlDocs.get("word/comments.xml");+ const ids = new Set(comments ? elementsOf(comments.documentElement, "w:comment").map((c) => c.getAttribute("w:id")) : []);+ const refs = elementsOf(doc.documentElement, "w:commentReference").concat(elementsOf(doc.documentElement, "w:commentRangeStart"), elementsOf(doc.documentElement, "w:commentRangeEnd"));+ for (const ref of refs) {+ const id = ref.getAttribute("w:id");+ if (!ids.has(id)) out.push(finding("dangling-comment", name, `${ref.tagName} w:id="${id}" has no w:comment`));+ }+ }+ }+}+function fixPackage(pkg) {+ const fixed = [];+ for (const name of pkg.parts.keys()) {+ if (!name.endsWith(".xml") && !name.endsWith(".rels")) continue;+ let doc, dirty = false;+ try {+ doc = parseXml(pkg.get(name));+ } catch {+ continue;+ }+ for (const tag of ["w:t", "w:delText", "w:instrText"]) {+ for (const el of elementsOf(doc.documentElement, tag)) {+ const text = el.textContent;+ if (text !== text.trim() && el.getAttribute("xml:space") !== "preserve") {+ el.setAttribute("xml:space", "preserve");+ dirty = true;+ }+ }+ }+ for (const tag of ["p:cNvPr", "wp:docPr"]) {+ const seen = /* @__PURE__ */ new Set();+ for (const el of elementsOf(doc.documentElement, tag)) {+ let id = el.getAttribute("id");+ if (id === null || seen.has(id)) {+ let next = 2;+ while (seen.has(String(next)) || hasIdAnywhere(doc, tag, String(next))) next++;+ el.setAttribute("id", String(next));+ dirty = true;+ }+ seen.add(el.getAttribute("id"));+ }+ }+ if (dirty) {+ pkg.putXml(name, doc);+ fixed.push(name);+ }+ }+ const paraIds = /* @__PURE__ */ new Set();+ for (const name of pkg.parts.keys()) {+ if (!/^word\//.test(name) || !name.endsWith(".xml")) continue;+ try {+ for (const p of elementsOf(parseXml(pkg.get(name)).documentElement, "w:p")) paraIds.add(p.getAttribute("w14:paraId"));+ } catch {+ }+ }+ for (const name of pkg.parts.keys()) {+ if (!/^word\//.test(name) || !name.endsWith(".xml")) continue;+ let doc;+ try {+ doc = parseXml(pkg.get(name));+ } catch {+ continue;+ }+ const seen = /* @__PURE__ */ new Set();+ let dirty = false;+ for (const p of elementsOf(doc.documentElement, "w:p")) {+ const id = p.getAttribute("w14:paraId");+ if (!id) continue;+ if (seen.has(id) || parseInt(id, 16) >= 2147483648) {+ let next = 1;+ while (paraIds.has(next.toString(16).padStart(8, "0")) || paraIds.has(next.toString(16))) next++;+ const fresh = next.toString(16).padStart(8, "0");+ p.setAttribute("w14:paraId", fresh);+ paraIds.add(fresh);+ dirty = true;+ }+ seen.add(p.getAttribute("w14:paraId"));+ }+ if (dirty) {+ pkg.putXml(name, doc);+ fixed.push(name);+ }+ }+ for (const [owner, map] of pkg.rels) {+ for (const rel of map.values()) {+ if (rel.mode === "External") continue;+ const expected = expectedContentType(pkg, rel.type);+ if (expected === void 0) continue;+ const target = pkg.targetOf(owner, rel.target);+ if (pkg.parts.has(target) && pkg.contentType(target) !== expected) {+ pkg.override(target, expected);+ fixed.push(target);+ }+ }+ }+ for (const part of [...pkg.overrides.keys()]) {+ if (!pkg.parts.has(part)) {+ pkg.overrides.delete(part);+ fixed.push(`-${part}`);+ }+ }+ for (const name of pkg.parts.keys()) {+ if (pkg.contentType(name) !== void 0 || name.endsWith("/")) continue;+ const type = patternType(name);+ if (type) {+ pkg.override(name, type);+ fixed.push(`+${name}`);+ }+ }+ for (const [owner, map] of pkg.rels) {+ for (const [id, rel] of [...map]) {+ if (rel.mode !== "External" && !pkg.parts.has(pkg.targetOf(owner, rel.target))) {+ map.delete(id);+ fixed.push(`${owner || "/"}#${id}`);+ }+ }+ }+ pkg.flush();+ return { fixed, remaining: checkPackage(pkg) };+}+function hasIdAnywhere(doc, tag, id) {+ for (const other of ["p:cNvPr", "wp:docPr"]) {+ if (elementsOf(doc.documentElement, other).some((el) => el.getAttribute("id") === id)) return true;+ }+ return false;+}++// src/office/docx.js+var parts = (pkg) => [...pkg.parts.keys()].filter((name) => name === "word/document.xml" || /^word\/(header|footer)\d+\.xml$/.test(name) || /^word\/(footnotes|endnotes|comments)\.xml$/.test(name));+function blockText(el, changes = false) {+ let out = "";+ const walk = (node, inside) => {+ if (node.nodeType === 3 || node.nodeType === 4) {+ if (!inside.del) out += node.data;+ return;+ }+ if (node.nodeType !== 1) return;+ const tag = node.tagName;+ if (!changes) {+ for (const child2 of [...node.childNodes]) {+ if (tag === "w:del" || tag === "w:moveFrom") continue;+ walk(child2, inside);+ }+ return;+ }+ let mark = inside;+ let pre = "", post = "";+ const author = node.getAttribute?.("w:author") ?? "";+ if (tag === "w:ins") {+ pre = `{+`;+ post = ` (${author})+}`;+ mark = { ...inside, del: false };+ } else if (tag === "w:del") {+ pre = `{-`;+ post = ` (${author})-}`;+ mark = { ...inside, del: false };+ } else if (tag === "w:moveFrom") {+ pre = `{<`;+ post = ` (${author})<}`;+ mark = { ...inside, del: false };+ } else if (tag === "w:moveTo") {+ pre = `{>`;+ post = ` (${author})>}`;+ mark = { ...inside, del: false };+ } else if (tag === "w:rPrChange" || tag === "w:pPrChange") {+ out += "{~fmt~}";+ return;+ } else if (tag === "w:moveFromRangeStart") {+ out += `{<move ${node.getAttribute("w:name") ?? ""}>`;+ return;+ } else if (tag === "w:moveToRangeStart") {+ out += `{>move ${node.getAttribute("w:name") ?? ""}>`;+ return;+ } else if (tag === "w:moveFromRangeEnd" || tag === "w:moveToRangeEnd") {+ out += "{end}";+ return;+ }+ out += pre;+ for (const child2 of [...node.childNodes]) walk(child2, mark);+ out += post;+ };+ walk(el, { del: false });+ return out;+}+function paraStyle(p) {+ return firstOf(firstOf(p, "w:pPr") ?? p, "w:pStyle")?.getAttribute("w:val");+}+function deletedParaMark(p) {+ const pPr = firstOf(p, "w:pPr");+ return pPr !== void 0 && firstOf(firstOf(pPr, "w:rPr") ?? pPr, "w:del") !== void 0;+}+function docxRead(pkg, { changes = false } = {}) {+ const doc = pkg.xml("word/document.xml");+ const body = firstOf(doc.documentElement, "w:body");+ const blocks = [];+ let pi = 0, ti = 0;+ const commentIds = commentsIndex(pkg, doc);+ for (const el of childrenOf(body)) {+ if (el.tagName === "w:p") {+ pi++;+ const id = `p${pi}`;+ const entry = { id, type: "paragraph", style: paraStyle(el), text: blockText(el, changes) };+ const anchored = commentIds.get(el);+ if (anchored) entry.comments = anchored;+ if (deletedParaMark(el)) entry.deletedParagraphMark = true;+ blocks.push(entry);+ } else if (el.tagName === "w:tbl") {+ ti++;+ blocks.push({ id: `t${ti}`, type: "table", rows: tableRows(el, changes) });+ }+ }+ const sections = [];+ const refs = elementsOf(doc.documentElement, "w:headerReference").concat(elementsOf(doc.documentElement, "w:footerReference"));+ const rels = pkg.relsOf("word/document.xml");+ for (const ref of refs) {+ const rel = rels.get(ref.getAttribute("r:id"));+ if (!rel) continue;+ const target = pkg.targetOf("word/document.xml", rel.target);+ const part = pkg.xml(target);+ sections.push({+ kind: ref.tagName === "w:headerReference" ? "header" : "footer",+ type: ref.getAttribute("w:type"),+ part: target,+ text: elementsOf(part.documentElement, "w:p").map((p) => blockText(p, changes)).filter(Boolean).join("\n")+ });+ }+ const notes = [];+ for (const [kind, part] of [["footnote", "word/footnotes.xml"], ["endnote", "word/endnotes.xml"]]) {+ if (!pkg.parts.has(part)) continue;+ for (const note of elementsOf(pkg.xml(part).documentElement, `w:${kind}`)) {+ const id = note.getAttribute("w:id");+ if (id === "-1" || id === "0") continue;+ notes.push({ kind, id, text: elementsOf(note, "w:p").map((p) => blockText(p, changes)).join(" ") });+ }+ }+ return { blocks, sections, notes, comments: commentsList(pkg, changes) };+}+function commentsIndex(pkg, doc) {+ const byEl = /* @__PURE__ */ new Map();+ if (!pkg.parts.has("word/comments.xml")) return byEl;+ for (const ref of elementsOf(doc.documentElement, "w:commentReference")) {+ let p = ref.parentNode;+ while (p && p.tagName !== "w:p") p = p.parentNode;+ if (!p) continue;+ const arr = byEl.get(p) ?? [];+ arr.push({ commentId: ref.getAttribute("w:id") });+ byEl.set(p, arr);+ }+ return byEl;+}+function commentsList(pkg, changes) {+ if (!pkg.parts.has("word/comments.xml")) return [];+ const commentsDoc = pkg.xml("word/comments.xml");+ const anchors = commentAnchors(pkg);+ return elementsOf(commentsDoc.documentElement, "w:comment").map((c) => ({+ id: c.getAttribute("w:id"),+ author: c.getAttribute("w:author"),+ initials: c.getAttribute("w:initials"),+ date: c.getAttribute("w:date"),+ text: elementsOf(c, "w:p").map((p) => blockText(p, changes)).join(" "),+ anchorsTo: anchors.get(c.getAttribute("w:id"))+ }));+}+function commentAnchors(pkg) {+ const map = /* @__PURE__ */ new Map();+ const doc = pkg.xml("word/document.xml");+ const index = blockIndex(doc);+ const byEl = new Map([...index].map(([id, el]) => [el, id]));+ for (const ref of elementsOf(doc.documentElement, "w:commentReference")) {+ let p = ref.parentNode;+ while (p && p.tagName !== "w:p") p = p.parentNode;+ if (p && byEl.has(p)) map.set(ref.getAttribute("w:id"), byEl.get(p));+ }+ return map;+}+function tableRows(tbl, changes) {+ return childrenOf(tbl, "w:tr").map((tr) => childrenOf(tr, "w:tc").map((tc) => {+ const gridSpan = firstOf(firstOf(tc, "w:tcPr") ?? tc, "w:gridSpan")?.getAttribute("w:val");+ const vMerge = firstOf(firstOf(tc, "w:tcPr") ?? tc, "w:vMerge");+ return {+ text: elementsOf(tc, "w:p").map((p) => blockText(p, changes)).join(" "),+ ...gridSpan ? { gridSpan: Number(gridSpan) } : {},+ ...vMerge ? { vMerge: vMerge.getAttribute("w:val") ?? "continue" } : {}+ };+ }));+}+function docxFields(pkg) {+ const out = [];+ for (const name of parts(pkg)) {+ const doc = pkg.xml(name);+ for (const fld of elementsOf(doc.documentElement, "w:fldSimple")) {+ out.push({ part: name, kind: "simple", instruction: fld.getAttribute("w:instr") ?? "", result: textOf(fld) });+ }+ const paras = elementsOf(doc.documentElement, "w:p");+ let open = null;+ const flush = () => {+ if (open) {+ delete open.phase;+ out.push(open);+ }+ open = null;+ };+ for (const p of paras) {+ for (const el of elementsOf(p)) {+ if (el.tagName === "w:fldChar") {+ const type = el.getAttribute("w:fldCharType");+ if (type === "begin") {+ flush();+ open = { part: name, kind: "complex", instruction: "", result: "" };+ } else if (type === "separate" && open) open.phase = "result";+ else if (type === "end") flush();+ } else if (open && el.tagName === "w:instrText" && open.phase !== "result") open.instruction += el.textContent;+ else if (open && open.phase === "result" && (el.tagName === "w:t" || el.tagName === "w:delText")) open.result += el.textContent;+ }+ }+ flush();+ }+ return out;+}+var EDIT_PARTS = (pkg, bodyOnly) => parts(pkg).filter((name) => name === "word/document.xml" || !bodyOnly && /^word\/(header|footer)\d+\.xml$|^word\/(footnotes|endnotes)\.xml$/.test(name));+function blockIndex(doc) {+ const body = firstOf(doc.documentElement, "w:body");+ const map = /* @__PURE__ */ new Map();+ let pi = 0, ti = 0;+ for (const el of childrenOf(body)) {+ if (el.tagName === "w:p") map.set(`p${++pi}`, el);+ else if (el.tagName === "w:tbl") map.set(`t${++ti}`, el);+ }+ return map;+}+function isDeleted(p, r) {+ for (let n = r; n && n !== p; n = n.parentNode) if (n.tagName === "w:del" || n.tagName === "w:moveFrom") return true;+ return false;+}+function docxEdit(pkg, ops) {+ const docs = /* @__PURE__ */ new Map();+ const getDoc = (name) => {+ if (!docs.has(name)) docs.set(name, pkg.xml(name));+ return docs.get(name);+ };++ const body = firstOf(getDoc("word/document.xml").documentElement, "w:body");++ const blocks = blockIndex(getDoc("word/document.xml"));++ const blockOf = (id) => {++ const block = blocks.get(id);++ if (!block || block.parentNode !== body) throw new Error(`no block ${id}`);++ return block;++ };+ const changed = /* @__PURE__ */ new Set();+ let count = 0;+ ops.forEach((op, index) => {+ try {- applyOp(pkg, getDoc, changed, op);++ applyOp(pkg, getDoc, blockOf, changed, op);+ count++;+ } catch (error) {+ const e = new Error(`op ${index} (${opKind(op)}): ${error.message}`);+ e.code = "ops";+ throw e;+ }+ });+ for (const [name, doc] of docs) if (changed.has(name)) pkg.putXml(name, doc);+ return { changed: [...changed], count };+}+var opKind = (op) => Object.keys(op).find((k) => !["o", "inPlace"].includes(k)) ?? "?";- function applyOp(pkg, getDoc, changed, op) {++function applyOp(pkg, getDoc, blockOf, changed, op) {+ const mainDoc = () => getDoc("word/document.xml");+ if (op.replace) {+ const { find, with: withText, regex = false, bodyOnly = false } = op.replace;+ const re = regex ? new RegExp(find, "g") : new RegExp(escapeRe(find), "g");+ for (const name of EDIT_PARTS(pkg, bodyOnly)) {+ const doc = getDoc(name);+ const n = replaceInDoc(doc, re, withText);+ if (n > 0) changed.add(name);+ }+ return;+ }+ if (op.set_cell) {+ const { table, row, col, text } = op.set_cell;- const tbl = blockIndex(mainDoc()).get(`t${table}`);- if (!tbl) throw new Error(`no table t${table}`);++ const tbl = blockOf(`t${table}`);+ const tr = childrenOf(tbl, "w:tr")[row - 1];+ const tc = tr && childrenOf(tr, "w:tc")[col - 1];+ if (!tc) throw new Error(`no cell r${row}c${col} in t${table}`);+ setCellText(getDoc("word/document.xml"), tc, String(text));+ changed.add("word/document.xml");+ return;+ }+ if (op.set_field) {+ const { match, value } = op.set_field;+ const re = new RegExp(match);+ let any = false;+ for (const name of EDIT_PARTS(pkg, false)) {+ const doc = getDoc(name);+ let hit = false;+ for (const fld of elementsOf(doc.documentElement, "w:fldSimple")) {+ if (re.test(fld.getAttribute("w:instr") ?? "")) {+ setFieldResult(doc, fld, String(value));+ hit = true;+ }+ }+ if (setComplexFieldResult(doc, re, String(value))) hit = true;+ if (hit) {+ changed.add(name);+ any = true;+ }+ }+ if (!any) throw new Error(`no field instruction matches /${match}/`);+ return;+ }+ if (op.insert) {+ const { after, before, text, style, like } = op.insert;+ const doc = mainDoc();- const index = blockIndex(doc);- const anchor = index.get(after ?? before);- if (!anchor) throw new Error(`no paragraph ${after ?? before}`);++ const anchor = blockOf(after ?? before);+ const p = doc.createElement("w:p");+ if (style || like) {+ const pPr = doc.createElement("w:pPr");+ const pStyle = doc.createElement("w:pStyle");- pStyle.setAttribute("w:val", style ?? paraStyle(index.get(like)) ?? "Normal");++ pStyle.setAttribute("w:val", style ?? paraStyle(blockOf(like)) ?? "Normal");+ pPr.appendChild(pStyle);+ p.appendChild(pPr);+ }+ const r = doc.createElement("w:r");+ const t = doc.createElement("w:t");+ t.setAttribute("xml:space", "preserve");+ t.appendChild(doc.createTextNode(text));+ r.appendChild(t);+ p.appendChild(r);+ anchor.parentNode.insertBefore(p, before ? anchor : anchor.nextSibling);+ changed.add("word/document.xml");+ return;+ }+ if (op.delete) {- const doc = mainDoc();- const index = blockIndex(doc);+ for (const id of op.delete.paragraphs) {- const el = index.get(id);- if (!el) throw new Error(`no block ${id}`);++ const el = blockOf(id);+ el.parentNode.removeChild(el);+ }+ changed.add("word/document.xml");+ return;+ }+ if (op.comment) {- addComment(pkg, getDoc, changed, op.comment);++ addComment(pkg, getDoc, blockOf, changed, op.comment);+ return;+ }+ if (op.accept_changes || op.reject_changes) {+ const accept = Boolean(op.accept_changes);+ for (const name of parts(pkg)) {+ if (!pkg.parts.has(name)) continue;+ const doc = getDoc(name);+ if (resolveChanges(doc, accept)) changed.add(name);+ }+ return;+ }+ throw new Error(`unknown op ${JSON.stringify(op)}`);+}+function escapeRe(s) {+ return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");+}+var expand = (m, withText) => withText.replace(/\$(\$|&|[1-9]\d?)/g, (_, g) => g === "$" ? "$" : g === "&" ? m[0] : m[Number(g)] ?? "");+var nearestPara = (el) => {+ for (let n = el.parentNode; n; n = n.parentNode) if (n.tagName === "w:p") return n;+ return null;+};+var cloneRun = (doc, src, text) => {+ const clone = src.cloneNode(false);+ const rPr = childrenOf(src, "w:rPr")[0];+ if (rPr) clone.appendChild(rPr.cloneNode(true));+ const t = doc.createElement("w:t");+ t.setAttribute("xml:space", "preserve");+ t.appendChild(doc.createTextNode(text));+ clone.appendChild(t);+ return clone;+};+function replaceInDoc(doc, re, withText) {+ let total = 0;+ const global = new RegExp(re.source, re.flags.includes("g") ? re.flags : re.flags + "g");+ for (const p of elementsOf(doc.documentElement, "w:p")) {+ const runs = elementsOf(p, "w:r").filter((r) => !isDeleted(p, r) && nearestPara(r) === p);+ const texts = runs.map((r) => elementsOf(r, "w:t").map((t) => t.textContent).join(""));+ const joined = texts.join("");+ const matches = [...joined.matchAll(global)];+ if (matches.length === 0) continue;++ if (runs.length === 0) {++ const run = doc.createElement("w:r");++ run.appendChild(doc.createElement("w:t"));++ p.appendChild(run);++ runs.push(run);++ texts.push("");++ }+ const bounds = [];+ let cursor = 0;+ for (const t of texts) {+ bounds.push([cursor, cursor + t.length]);+ cursor += t.length;+ }+ for (let i = 0; i < runs.length; i++) {+ const [rs, rend] = bounds[i];- const covers = matches.filter((m) => m.index < rend && (m.index + m[0].length > rs || m.index >= rs && m.index < rend));++ const startsHere = (m) => m.index >= rs && (m.index < rend || i === runs.length - 1 && m.index === rend);++ const covers = matches.filter((m) => startsHere(m) || m.index < rend && m.index + m[0].length > rs);+ if (covers.length === 0) continue;+ const pieces = [];+ let pos = 0;+ for (const m of covers) {+ const cs = Math.max(0, m.index - rs);+ const ce = Math.min(texts[i].length, m.index + m[0].length - rs);+ if (cs > pos) pieces.push({ text: texts[i].slice(pos, cs) });- if (m.index >= rs && m.index < rend) pieces.push({ repl: expand(m, withText) });++ if (startsHere(m)) pieces.push({ repl: expand(m, withText) });+ pos = ce;+ }+ if (pos < texts[i].length || pieces.length === 0) pieces.push({ text: texts[i].slice(pos) });+ const run = runs[i];+ let anchor = run;+ for (const [k, piece] of pieces.entries()) {+ if (k === 0) {+ setRunText(run, piece.text ?? "");+ if (piece.text !== void 0) continue;+ }+ const clone = cloneRun(doc, run, piece.repl ?? piece.text);+ anchor.parentNode.insertBefore(clone, anchor.nextSibling);+ anchor = clone;+ }- total += covers.filter((m) => m.index >= rs && m.index < rend).length;++ total += covers.filter(startsHere).length;+ }+ }+ return total;+}+function setRunText(run, text) {+ const ts = elementsOf(run, "w:t");+ if (ts.length === 0) return;+ ts[0].textContent = text;+ if (text !== text.trim()) ts[0].setAttribute("xml:space", "preserve");+ for (const extra of ts.slice(1)) extra.textContent = "";+}+function setCellText(doc, tc, text) {+ const paras = childrenOf(tc, "w:p");+ const pPr = paras[0] && childrenOf(paras[0], "w:pPr")[0];+ const firstRun = paras[0] && elementsOf(paras[0], "w:r")[0];+ const rPr = firstRun && childrenOf(firstRun, "w:rPr")[0];+ for (const p2 of paras) tc.removeChild(p2);+ const p = doc.createElement("w:p");+ if (pPr) p.appendChild(pPr);+ const r = doc.createElement("w:r");+ if (rPr) r.appendChild(rPr);+ const t = doc.createElement("w:t");+ t.setAttribute("xml:space", "preserve");+ t.appendChild(doc.createTextNode(text));+ r.appendChild(t);+ p.appendChild(r);+ tc.appendChild(p);+}+function setFieldResult(doc, fld, value) {+ const rPr = elementsOf(fld, "w:r")[0] && childrenOf(elementsOf(fld, "w:r")[0], "w:rPr")[0];+ for (const child2 of [...fld.childNodes]) fld.removeChild(child2);+ const r = doc.createElement("w:r");+ if (rPr) r.appendChild(rPr.cloneNode(true));+ const t = doc.createElement("w:t");+ t.setAttribute("xml:space", "preserve");+ t.appendChild(doc.createTextNode(value));+ r.appendChild(t);+ fld.appendChild(r);+}+function setComplexFieldResult(doc, re, value) {+ let hit = false;+ let depth = 0, inField = false, inResult = false, first = true;+ for (const el of elementsOf(doc.documentElement)) {+ if (el.tagName === "w:instrText") {+ if (!inField && re.test(el.textContent)) {+ inField = true;+ depth = 1;+ inResult = false;+ first = true;+ }+ continue;+ }+ if (!inField) continue;+ if (el.tagName === "w:fldChar") {+ const type = el.getAttribute("w:fldCharType");+ if (type === "begin") depth++;+ else if (type === "end") {+ depth--;+ if (depth === 0) inField = false;+ } else if (type === "separate" && depth === 1) inResult = true;+ continue;+ }+ if (inResult && el.tagName === "w:r") {+ if (first) {+ setRunText(el, value);+ first = false;+ } else setRunText(el, "");+ hit = true;+ }+ }+ return hit;+}+var ancestor = (node, tag) => {+ for (let n = node.parentNode; n; n = n.parentNode) if (n.tagName === tag) return n;+ return null;+};+function splitRunAt(doc, run, offset) {+ const text = elementsOf(run, "w:t").map((t) => t.textContent).join("");+ const clone = cloneRun(doc, run, text.slice(offset));+ setRunText(run, text.slice(0, offset));+ run.parentNode.insertBefore(clone, run.nextSibling);+ return clone;+}+function phraseRuns(doc, p, anchor) {+ const runs = elementsOf(p, "w:r").filter((r) => !isDeleted(p, r) && nearestPara(r) === p);+ const texts = runs.map((r) => elementsOf(r, "w:t").map((t) => t.textContent).join(""));+ const joined = texts.join("");+ const start = joined.indexOf(anchor);+ if (start < 0) return void 0;+ const end = start + anchor.length;+ const locate = (pos) => {+ let c = 0;+ for (let i = 0; i < runs.length; i++) {+ const e2 = c + texts[i].length;+ if (pos < e2 || pos === e2 && i === runs.length - 1) return { i, off: pos - c };+ c = e2;+ }+ return { i: runs.length - 1, off: texts.at(-1).length };+ };+ const e = locate(end), s = locate(start);+ let lastRun, firstRun;+ if (e.off === texts[e.i].length) lastRun = runs[e.i];+ else if (e.off === 0) lastRun = runs[e.i - 1];+ else {+ splitRunAt(doc, runs[e.i], e.off);+ lastRun = runs[e.i];+ }+ if (s.i === e.i && s.off > 0) {+ firstRun = lastRun = splitRunAt(doc, runs[s.i], s.off);+ } else {+ firstRun = s.off === 0 ? runs[s.i] : splitRunAt(doc, runs[s.i], s.off);+ }+ return { firstRun, lastRun };+}- function addComment(pkg, getDoc, changed, { paragraph, text, anchor, author = "Bot", initials = "B" }) {++function addComment(pkg, getDoc, blockOf, changed, { paragraph, text, anchor, author = "Bot", initials = "B" }) {+ const doc = getDoc("word/document.xml");- const p = blockIndex(doc).get(paragraph);- if (!p) throw new Error(`no paragraph ${paragraph}`);++ const p = blockOf(paragraph);+ let commentsDoc;+ if (!pkg.parts.has("word/comments.xml")) {+ commentsDoc = parseXml('<w:comments xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"/>');+ pkg.rels.set("word/document.xml", pkg.relsOf("word/document.xml"));+ let next = 1;+ const map = pkg.rels.get("word/document.xml");+ while (map.has(`rId${next}`)) next++;+ map.set(`rId${next}`, { id: `rId${next}`, type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments", target: "comments.xml", mode: "Internal" });+ pkg.override("word/comments.xml", "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml");+ } else commentsDoc = getDoc("word/comments.xml");+ const id = String(Math.max(0, ...elementsOf(commentsDoc.documentElement, "w:comment").map((c) => Number(c.getAttribute("w:id")) || 0)) + 1);+ const comment = commentsDoc.createElement("w:comment");+ comment.setAttribute("w:id", id);+ comment.setAttribute("w:author", author);+ comment.setAttribute("w:initials", initials);+ const cp = commentsDoc.createElement("w:p");+ const cr = commentsDoc.createElement("w:r");+ const ct = commentsDoc.createElement("w:t");+ ct.setAttribute("xml:space", "preserve");+ ct.appendChild(commentsDoc.createTextNode(text));+ cr.appendChild(ct);+ cp.appendChild(cr);+ comment.appendChild(cp);+ commentsDoc.documentElement.appendChild(comment);+ pkg.putXml("word/comments.xml", commentsDoc);+ const rangeStart = doc.createElement("w:commentRangeStart");+ rangeStart.setAttribute("w:id", id);+ const rangeEnd = doc.createElement("w:commentRangeEnd");+ rangeEnd.setAttribute("w:id", id);+ const ref = doc.createElement("w:r");+ const refEl = doc.createElement("w:commentReference");+ refEl.setAttribute("w:id", id);+ ref.appendChild(refEl);+ const pPr = childrenOf(p, "w:pPr")[0];+ if (anchor) {+ const span = phraseRuns(doc, p, anchor);+ if (!span) throw new Error(`anchor "${anchor}" not found in ${paragraph}`);+ span.firstRun.parentNode.insertBefore(rangeStart, span.firstRun);+ span.lastRun.parentNode.insertBefore(rangeEnd, span.lastRun.nextSibling);+ span.lastRun.parentNode.insertBefore(ref, rangeEnd.nextSibling);+ } else {+ p.insertBefore(rangeStart, pPr ? pPr.nextSibling : p.firstChild);+ p.appendChild(rangeEnd);+ p.appendChild(ref);+ }+ changed.add("word/document.xml");+}+function resolveChanges(doc, accept) {+ let dirty = false;+ const lift = (el) => {+ while (el.firstChild) el.parentNode.insertBefore(el.firstChild, el);+ el.parentNode.removeChild(el);+ };+ const mergeIntoNext = (p, pPr) => {+ const next = p.nextSibling;+ if (!next || next.tagName !== "w:p") return false;+ const nextPPr = childrenOf(next, "w:pPr")[0];+ const anchor = nextPPr ? nextPPr.nextSibling : next.firstChild;+ for (const node of [...p.childNodes]) {+ if (node === pPr) continue;+ next.insertBefore(node, anchor);+ }+ p.parentNode.removeChild(p);+ return true;+ };+ for (const p of elementsOf(doc.documentElement, "w:p")) {+ const pPr = childrenOf(p, "w:pPr")[0];+ const rPr = pPr && childrenOf(pPr, "w:rPr")[0];+ if (!rPr) continue;+ const del = childrenOf(rPr, "w:del")[0];+ const ins = childrenOf(rPr, "w:ins")[0];+ if (del) {+ dirty = true;+ if (!accept || !mergeIntoNext(p, pPr)) rPr.removeChild(del);+ } else if (ins) {+ dirty = true;+ if (accept || !mergeIntoNext(p, pPr)) rPr.removeChild(ins);+ }+ }+ for (const tr of elementsOf(doc.documentElement, "w:tr")) {+ const trPr = childrenOf(tr, "w:trPr")[0];+ if (!trPr) continue;+ const ins = childrenOf(trPr, "w:ins")[0];+ const del = childrenOf(trPr, "w:del")[0];+ if (ins) {+ dirty = true;+ if (accept) trPr.removeChild(ins);+ else tr.parentNode.removeChild(tr);+ } else if (del) {+ dirty = true;+ if (accept) tr.parentNode.removeChild(tr);+ else trPr.removeChild(del);+ }+ }+ for (const el of elementsOf(doc.documentElement)) {+ const tag = el.tagName;+ if (tag === "w:moveFromRangeStart" || tag === "w:moveFromRangeEnd" || tag === "w:moveToRangeStart" || tag === "w:moveToRangeEnd" || tag === "w:customXmlInsRangeStart" || tag === "w:customXmlInsRangeEnd" || tag === "w:customXmlDelRangeStart" || tag === "w:customXmlDelRangeEnd" || tag === "w:customXmlMoveFromRangeStart" || tag === "w:customXmlMoveFromRangeEnd" || tag === "w:customXmlMoveToRangeStart" || tag === "w:customXmlMoveToRangeEnd") {+ el.parentNode?.removeChild(el);+ dirty = true;+ }+ }+ for (const el of elementsOf(doc.documentElement)) {+ const tag = el.tagName;+ if (tag === "w:ins" || tag === "w:moveTo") {+ if (accept) lift(el);+ else el.parentNode.removeChild(el);+ dirty = true;+ } else if (tag === "w:del" || tag === "w:moveFrom") {+ if (accept) {+ el.parentNode.removeChild(el);+ dirty = true;+ } else {+ for (const t of elementsOf(el, "w:delText")) {+ t.tagName = "w:t";+ }+ lift(el);+ dirty = true;+ }+ } else if (tag === "w:numberingChange") {+ el.parentNode.removeChild(el);+ dirty = true;+ } else if (/^w:(pPrChange|rPrChange|tblPrChange|tcPrChange|trPrChange|sectPrChange)$/.test(tag)) {+ const parent = el.parentNode;+ if (accept) {+ parent.removeChild(el);+ dirty = true;+ } else {+ const stored = childrenOf(el)[0];+ const keep = /* @__PURE__ */ new Set();+ if (parent.tagName === "w:pPr") {+ keep.add("w:rPr");+ keep.add("w:sectPr");+ }+ if (parent.tagName === "w:sectPr") {+ keep.add("w:headerReference");+ keep.add("w:footerReference");+ }+ for (const c of [...parent.childNodes]) if (!keep.has(c.tagName) && c !== el) parent.removeChild(c);+ if (stored) {+ const kept = [...parent.childNodes].filter((c) => keep.has(c.tagName));+ const anchor = parent.tagName === "w:sectPr" ? kept.length > 0 ? kept.at(-1).nextSibling : parent.firstChild === el ? null : parent.firstChild : kept[0] ?? el;+ for (const s of [...stored.childNodes]) parent.insertBefore(s, anchor);+ }+ parent.removeChild(el);+ dirty = true;+ }+ } else if (tag === "w:cellIns" || tag === "w:cellDel") {+ const tc = ancestor(el, "w:tc");+ if (tc) {+ if (accept && tag === "w:cellDel") tc.parentNode?.removeChild(tc);+ else if (!accept && tag === "w:cellIns") tc.parentNode?.removeChild(tc);+ el.parentNode.removeChild(el);+ dirty = true;+ }+ }+ }+ return dirty;+}++// src/office/pptx.js+import { posix as posix3 } from "node:path";+var EMU = 914400;+var SLIDE_RE = /^ppt\/slides\/slide\d+\.xml$/;+var slideParts = (pkg) => [...pkg.parts.keys()].filter((n) => SLIDE_RE.test(n));+var deckOrder = (pkg) => {+ const pres = pkg.xml("ppt/presentation.xml");+ const lst = firstOf(pres.documentElement, "p:sldIdLst");+ const rels = pkg.relsOf("ppt/presentation.xml");+ return childrenOf(lst ?? pres.documentElement, "p:sldId").map((s) => {+ const rel = rels.get(s.getAttribute("r:id"));+ return { sldId: s.getAttribute("id"), rid: s.getAttribute("r:id"), part: rel && pkg.targetOf("ppt/presentation.xml", rel.target) };+ }).filter((e) => e.part);+};+var slideSize = (pkg) => {+ const sz = firstOf(pkg.xml("ppt/presentation.xml").documentElement, "p:sldSz");+ return { cx: Number(sz?.getAttribute("cx") ?? 0) / EMU, cy: Number(sz?.getAttribute("cy") ?? 0) / EMU };+};+var themeFonts = (pkg) => {+ const theme = [...pkg.parts.keys()].find((n) => /^ppt\/theme\/theme\d+\.xml$/.test(n));+ if (!theme) return {};+ const doc = pkg.xml(theme);+ const get = (tag) => elementsOf(doc.documentElement, tag).map((e) => firstOf(e, "a:latin")?.getAttribute("typeface")).find(Boolean);+ return { major: get("a:majorFont"), minor: get("a:minorFont") };+};+function relTarget(pkg, owner, el, attr = "r:id") {+ const rel = pkg.relsOf(owner).get(el?.getAttribute(attr));+ return rel && pkg.targetOf(owner, rel.target);+}+var relatedPart = (pkg, owner, tags) => {+ for (const rel of pkg.relList(owner)) if (tags.some((t) => rel.type.endsWith(`/${t}`))) return pkg.targetOf(owner, rel.target);+ return void 0;+};+var child = (el, tag) => childrenOf(el, tag)[0];+var nvPrOf = (sp) => child(child(sp, "p:nvSpPr") ?? child(sp, "p:nvPicPr") ?? child(sp, "p:nvGrpSpPr") ?? child(sp, "p:nvCxnSpPr") ?? child(sp, "p:nvGraphicFramePr") ?? sp, "p:nvPr");+function phOf(sp) {+ const ph = child(nvPrOf(sp) ?? sp, "p:ph");+ return ph ? { type: ph.getAttribute("type") ?? "body", idx: ph.getAttribute("idx") } : void 0;+}+var shapeName = (sp) => child(child(sp, "p:nvSpPr") ?? child(sp, "p:nvPicPr") ?? child(sp, "p:nvGrpSpPr") ?? child(sp, "p:nvCxnSpPr") ?? child(sp, "p:nvGraphicFramePr") ?? sp, "p:cNvPr")?.getAttribute("name");+var shapeId = (sp) => child(child(sp, "p:nvSpPr") ?? child(sp, "p:nvPicPr") ?? child(sp, "p:nvGrpSpPr") ?? child(sp, "p:nvCxnSpPr") ?? child(sp, "p:nvGraphicFramePr") ?? sp, "p:cNvPr")?.getAttribute("id");+var xfrmOf = (sp) => child(child(sp, "p:spPr") ?? sp, "a:xfrm");+var off = (xfrm) => ({ x: Number(firstOf(xfrm, "a:off")?.getAttribute("x") ?? 0), y: Number(firstOf(xfrm, "a:off")?.getAttribute("y") ?? 0) });+var ext = (xfrm) => ({ cx: Number(firstOf(xfrm, "a:ext")?.getAttribute("cx") ?? 0), cy: Number(firstOf(xfrm, "a:ext")?.getAttribute("cy") ?? 0) });+function applyGroup(box, grpSp) {+ const g = child(child(grpSp, "p:grpSpPr") ?? grpSp, "a:xfrm");+ if (!g) return box;+ const o = off(g), e = ext(g);+ const co = firstOf(g, "a:chOff"), ce = firstOf(g, "a:chExt");+ const sx = e.cx / Number(ce?.getAttribute("cx") || e.cx || 1);+ const sy = e.cy / Number(ce?.getAttribute("cy") || e.cy || 1);+ const cx0 = Number(co?.getAttribute("x") ?? 0), cy0 = Number(co?.getAttribute("y") ?? 0);+ return { x: o.x + (box.x - cx0) * sx, y: o.y + (box.y - cy0) * sy, cx: box.cx * sx, cy: box.cy * sy };+}+function shapeBox(pkg, sp, layoutDoc, masterDoc, groupChain = []) {+ const xfrm = xfrmOf(sp);+ let box;+ if (xfrm && (firstOf(xfrm, "a:off") || firstOf(xfrm, "a:ext"))) {+ const o = off(xfrm), e = ext(xfrm);+ box = { x: o.x, y: o.y, cx: e.cx, cy: e.cy };+ } else {+ const ph = phOf(sp);+ box = void 0;+ if (ph) {+ for (const doc of [layoutDoc, masterDoc]) {+ if (!doc) continue;+ const match = elementsOf(doc.documentElement).find((c) => (c.tagName === "p:sp" || c.tagName === "p:pic") && phMatch(phOf(c), ph));+ const inh = match && xfrmOf(match);+ if (inh) {+ box = { ...off(inh), ...ext(inh) };+ box = { x: box.x, y: box.y, cx: box.cx, cy: box.cy };+ break;+ }+ }+ }+ if (!box) return void 0;+ }+ for (const grp of groupChain) box = applyGroup(box, grp);+ return box;+}+var phMatch = (a, b) => a && b && a.type === b.type && String(a.idx ?? "") === String(b.idx ?? "");+var inches = (box) => ({ x: +(box.x / EMU).toFixed(2), y: +(box.y / EMU).toFixed(2), w: +(box.cx / EMU).toFixed(2), h: +(box.cy / EMU).toFixed(2) });+var KIND = { "p:sp": "text", "p:pic": "picture", "p:graphicFrame": "frame", "p:grpSp": "group", "p:cxnSp": "connector" };+function shapeKind(sp) {+ if (sp.tagName === "p:graphicFrame") {+ const data = firstOf(firstOf(sp, "a:graphic") ?? sp, "a:graphicData");+ const uri = data?.getAttribute("uri") ?? "";+ return uri.includes("chart") ? "chart" : uri.includes("table") ? "table" : "frame";+ }+ if (sp.tagName === "p:sp" && textOf(sp).trim() === "") return "shape";+ return KIND[sp.tagName] ?? sp.tagName;+}+function shapeText(sp) {+ const body = child(sp, "p:txBody");+ if (!body) return [];+ return childrenOf(body, "a:p").map((p) => ({+ text: textOf(p),+ runs: elementsOf(p, "a:r").map((r) => ({+ text: textOf(r),+ font: firstOf(firstOf(r, "a:rPr") ?? r, "a:latin")?.getAttribute("typeface"),+ size: Number(firstOf(r, "a:rPr")?.getAttribute("sz") ?? 0) / 100 || void 0+ }))+ })).filter((p) => p.text !== "" || p.runs.length > 0);+}+function shapesIn(spTree, pkg, layoutDoc, masterDoc, groupChain = []) {+ const out = [];+ for (const el of childrenOf(spTree)) {+ if (!KIND[el.tagName]) continue;+ if (el.tagName === "p:grpSp") {+ out.push(describe(el, pkg, layoutDoc, masterDoc, groupChain));+ out.push(...shapesIn(el, pkg, layoutDoc, masterDoc, [...groupChain, el]).map((s) => ({ ...s, inGroup: shapeName(el) })));+ continue;+ }+ out.push(describe(el, pkg, layoutDoc, masterDoc, groupChain));+ }+ return out;+}+function describe(sp, pkg, layoutDoc, masterDoc, groupChain) {+ const entry = { id: shapeId(sp), name: shapeName(sp), kind: shapeKind(sp) };+ const ph = phOf(sp);+ if (ph) entry.placeholder = ph;+ const box = shapeBox(pkg, sp, layoutDoc, masterDoc, groupChain);+ if (box) entry.box = inches(box);+ if (sp.tagName === "p:pic") {+ const blip = elementsOf(sp, "a:blip")[0];+ const media = blip && relTarget(pkg, entry.owner ?? sp.ownerDocument?.partName, blip, "r:embed");+ if (media) entry.media = media;+ }+ const paragraphs = shapeText(sp);+ if (paragraphs.length > 0) entry.text = paragraphs;+ return entry;+}+var layoutName = (doc) => firstOf(doc.documentElement, "p:cSld")?.getAttribute("name");+var notesText = (pkg, slide) => {+ const notes = relatedPart(pkg, slide, ["notesSlide"]);+ if (!notes || !pkg.parts.has(notes)) return "";+ return elementsOf(pkg.xml(notes).documentElement, "p:sp").map((s) => textOf(s).trim()).filter((t) => t && !/^(slide number|\d+)$/i.test(t)).join(" ");+};+function pptxInventory(pkg, slidesFilter) {+ const size = slideSize(pkg);+ const fonts = themeFonts(pkg);+ const order = deckOrder(pkg);+ const wanted = new Set(slidesFilter?.length ? slidesFilter.map(String) : order.map((_, i) => String(i + 1)));+ const slides = order.map((entry, i) => {+ const pos = i + 1;+ if (!wanted.has(String(pos)) && !wanted.has(entry.part)) return void 0;+ if (!pkg.parts.has(entry.part)) return { position: pos, part: entry.part, missing: true };+ const doc = pkg.xml(entry.part);+ doc.partName = entry.part;+ const layoutPart = relatedPart(pkg, entry.part, ["slideLayout"]);+ const masterPart = layoutPart && relatedPart(pkg, layoutPart, ["slideMaster"]);+ const layoutDoc = layoutPart && pkg.parts.has(layoutPart) ? pkg.xml(layoutPart) : void 0;+ const masterDoc = masterPart && pkg.parts.has(masterPart) ? pkg.xml(masterPart) : void 0;+ const tree = firstOf(firstOf(doc.documentElement, "p:cSld") ?? doc.documentElement, "p:spTree");+ const shapes = tree ? shapesIn(tree, pkg, layoutDoc, masterDoc) : [];+ for (const s of shapes) s.owner = void 0;+ return {+ position: pos,+ part: entry.part,+ sldId: entry.sldId,+ layout: layoutPart ? layoutName(pkg.xml(layoutPart)) : void 0,+ hidden: doc.documentElement.getAttribute("show") === "0" || void 0,+ notes: notesText(pkg, entry.part) || void 0,+ shapes+ };+ }).filter(Boolean);+ return { slideSize: size, themeFonts: fonts, slides };+}+function pptxLayout(pkg, slidesFilter, { autofit = false } = {}) {+ const inv = pptxInventory(pkg, slidesFilter);+ const size = inv.slideSize;+ const findings = [];+ const fitted = [];+ for (const slide of inv.slides) {+ if (!slide.shapes) continue;+ const allBoxes = [];+ const collect = (shapes) => {+ for (const s of shapes) {+ if (s.box) allBoxes.push(s);+ if (s.children) collect(s.children);+ }+ };+ collect(slide.shapes);+ const boxes = slide.shapes.filter((s) => s.box && s.text?.length);+ for (const s of allBoxes) {+ const a = s.box;+ if (a.x < 0 || a.y < 0 || a.x + a.w > size.cx + 0.01 || a.y + a.h > size.cy + 0.01) {+ findings.push({ slide: slide.position, rule: "off-slide", shape: s.name, box: a });+ }+ }+ for (let i = 0; i < boxes.length; i++) {+ for (let j = i + 1; j < boxes.length; j++) {+ const a = boxes[i].box, b = boxes[j].box;+ const ox = Math.max(0, Math.min(a.x + a.w, b.x + b.w) - Math.max(a.x, b.x));+ const oy = Math.max(0, Math.min(a.y + a.h, b.y + b.h) - Math.max(a.y, b.y));+ const area = ox * oy;+ if (area <= 0) continue;+ const share = area / Math.min(a.w * a.h, b.w * b.h);+ findings.push({ slide: slide.position, rule: "overlap", shapes: [boxes[i].name, boxes[j].name], area: +area.toFixed(2), shareOfSmaller: +share.toFixed(2) });+ }+ }+ if (autofit) {+ const names = new Set(findings.filter((f) => f.slide === slide.position).flatMap((f) => f.shapes ?? [f.shape]));+ if (names.size > 0) {+ const doc = pkg.xml(slide.part);+ for (const el of elementsOf(doc.documentElement, "p:sp")) {+ if (!names.has(shapeName(el))) continue;+ const body = firstOf(el, "p:txBody");+ const bodyPr = body && firstOf(body, "a:bodyPr");+ if (bodyPr && !firstOf(bodyPr, "a:normAutofit")) {+ for (const tag of ["a:noAutofit", "a:spAutoFit"]) {+ const old = firstOf(bodyPr, tag);+ if (old) bodyPr.removeChild(old);+ }+ const anchor = childrenOf(bodyPr).find((c) => ["a:scene3d", "a:sp3d", "a:flatTx", "a:extLst"].includes(c.tagName));+ bodyPr.insertBefore(doc.createElement("a:normAutofit"), anchor ?? null);+ fitted.push(`${slide.position}:${shapeName(el)}`);+ }+ }+ pkg.putXml(slide.part, doc);+ }+ }+ }+ return { findings, autofitApplied: fitted, note: "Text overflowing inside a box still needs a render to see." };+}+function pptxSlides(pkg, order) {+ const current = deckOrder(pkg);+ const pres = pkg.xml("ppt/presentation.xml");+ const lst = firstOf(pres.documentElement, "p:sldIdLst");+ const presRels = pkg.rels.get("ppt/presentation.xml");+ const usedSldIds = new Set(current.map((e) => Number(e.sldId)));+ const newSlidePart = () => {+ let n = 1;+ while (pkg.parts.has(`ppt/slides/slide${n}.xml`)) n++;+ return n;+ };+ const newSldId = () => {+ let n = Math.max(256, ...usedSldIds) + 1;+ usedSldIds.add(n);+ return n;+ };+ const seen = /* @__PURE__ */ new Set();+ const newEntries = [];+ const duplicated = [];+ for (const pos of order) {+ const source = current[pos - 1];+ if (!source) throw new Error(`no slide at position ${pos}`);+ if (!seen.has(pos)) {+ newEntries.push({ ...source });+ seen.add(pos);+ continue;+ }+ const dup = String(newSlidePart());+ const newPart = `ppt/slides/slide${dup}.xml`;+ pkg.parts.set(newPart, { data: pkg.get(source.part) });+ if (pkg.overrides.has(source.part)) pkg.overrides.set(newPart, pkg.overrides.get(source.part));+ const mapped = /* @__PURE__ */ new Map([[source.part, newPart]]);+ const rid = `rId${nextRid(presRels)}`;+ presRels.set(rid, { id: rid, type: presRels.get(source.rid)?.type ?? "http://schemas.openxmlformats.org/officeDocument/2006/relationships/slide", target: `slides/slide${dup}.xml`, mode: "Internal" });+ const sid = String(newSldId());+ const slideRels = /* @__PURE__ */ new Map();+ for (const [id, rel] of pkg.relsOf(source.part)) {+ if (rel.mode === "External") {+ slideRels.set(id, { ...rel });+ continue;+ }+ const target = pkg.targetOf(source.part, rel.target);+ if (/notesSlide|chart|package|oleObject|embeddings/i.test(rel.type) && pkg.parts.has(target)) {+ const newTarget = copyPart(pkg, target, mapped);+ slideRels.set(id, { ...rel, target: posix3.relative(posix3.dirname(newPart), newTarget) });+ } else slideRels.set(id, { ...rel });+ }+ pkg.rels.set(newPart, slideRels);+ for (const copy of mapped.values()) {+ const map = pkg.rels.get(copy);+ if (!map) continue;+ for (const rel of map.values()) {+ if (rel.mode === "External") continue;+ const abs = pkg.targetOf(copy, rel.target);+ if (mapped.has(abs)) rel.target = posix3.relative(posix3.dirname(copy), mapped.get(abs));+ }+ }+ newEntries.push({ sldId: sid, rid, part: newPart });+ duplicated.push(pos);+ }+ for (const el of childrenOf(lst)) lst.removeChild(el);+ for (const entry of newEntries) {+ const el = pres.createElement("p:sldId");+ el.setAttribute("id", entry.sldId);+ el.setAttribute("r:id", entry.rid);+ lst.appendChild(el);+ }+ for (const [rid, rel] of [...presRels]) {+ if (rel.type.endsWith("/slide") && !newEntries.some((e) => e.rid === rid)) presRels.delete(rid);+ }+ const kept = new Set(newEntries.map((e) => e.part));+ const removed = current.filter((e) => !kept.has(e.part)).map((e) => e.part);+ for (const part of removed) pkg.remove(part);+ pkg.putXml("ppt/presentation.xml", pres);+ const cleaned = pptxClean(pkg);+ return { order, duplicated, removed: [...removed, ...cleaned.removed] };+}+var maxNum = (names, re) => Math.max(0, ...names.map((n) => Number(re.exec(n)?.[1] ?? 0)));+var nextRid = (map) => {+ let i = 1;+ while (map.has(`rId${i}`)) i++;+ return i;+};+function copyPart(pkg, part, mapped = /* @__PURE__ */ new Map()) {+ const dir = posix3.dirname(part), base = posix3.basename(part);+ const stem = base.replace(/\d+(\.\w+)$/, ""), extn = base.match(/\.\w+$/)[0];+ const n = maxNum([...pkg.parts.keys()].filter((k) => k.startsWith(dir + "/")), new RegExp(`${stem}(\\d+)${extn.replace(".", "\\.")}$`)) + 1;+ const target = `${dir}/${stem}${n}${extn}`;+ pkg.parts.set(target, { data: pkg.get(part) });+ mapped.set(part, target);+ if (pkg.overrides.has(part)) pkg.overrides.set(target, pkg.overrides.get(part));+ const map = /* @__PURE__ */ new Map();+ for (const [id, rel] of pkg.relsOf(part)) {+ if (rel.mode === "External") {+ map.set(id, { ...rel });+ continue;+ }+ const t = pkg.targetOf(part, rel.target);+ if (/package|oleObject|workbook|embeddings|xlsx/i.test(rel.type) && pkg.parts.has(t)) {+ map.set(id, { ...rel, target: posix3.relative(dir, copyPart(pkg, t, mapped)) });+ } else map.set(id, { ...rel });+ }+ if (map.size > 0) pkg.rels.set(target, map);+ return target;+}+var CONTENT_REL = /\/(image|media|video|audio|chart|oleObject|package|diagramData|diagramLayout|diagramColors|diagramQuickStyle|drawing|hyperlink)$/;+function pptxClean(pkg, { dryRun = false } = {}) {+ const removed = [];+ for (const [owner, map] of [...pkg.rels]) {+ if (!pkg.parts.has(owner)) continue;+ const xml = pkg.get(owner) ?? Buffer.alloc(0);+ for (const [id, rel] of [...map]) {+ if (rel.mode !== "Internal" || !CONTENT_REL.test(rel.type)) continue;+ if (!xml.includes(`"${id}"`) && !xml.includes(`'${id}'`)) map.delete(id);+ }+ }+ const listed = new Set(pkg.parts.has("ppt/presentation.xml") ? deckOrder(pkg).map((e) => e.part) : []);+ for (const part of slideParts(pkg)) {+ if (!listed.has(part)) {+ removed.push(part);+ if (!dryRun) pkg.remove(part);+ }+ }+ const reachable = /* @__PURE__ */ new Set(["[Content_Types].xml"]);+ const queue = [""];+ while (queue.length) {+ const owner = queue.pop();+ for (const rel of pkg.relList(owner)) {+ if (rel.mode === "External") continue;+ const target = pkg.targetOf(owner, rel.target);+ if (!reachable.has(target) && pkg.parts.has(target)) {+ reachable.add(target);+ queue.push(target);+ }+ }+ }+ for (const name of [...pkg.parts.keys()]) {+ if (name.endsWith(".rels")) continue;+ if (!reachable.has(name)) {+ removed.push(name);+ if (!dryRun) pkg.remove(name);+ }+ }+ if (!dryRun) {+ for (const [owner, map] of [...pkg.rels]) {+ if (owner !== "" && !pkg.parts.has(owner)) {+ pkg.rels.delete(owner);+ continue;+ }+ for (const [id, rel] of [...map]) {+ if (rel.mode !== "External" && !pkg.parts.has(pkg.targetOf(owner, rel.target))) map.delete(id);+ }+ }+ for (const part of [...pkg.overrides.keys()]) if (!pkg.parts.has(part)) pkg.overrides.delete(part);+ const used = /* @__PURE__ */ new Set();+ for (const [owner] of pkg.rels) for (const rel of pkg.relList(owner)) used.add(pkg.targetOf(owner, rel.target));+ for (const name of [...pkg.parts.keys()]) {+ if (/^(ppt|word|xl)\/media\//.test(name) && !used.has(name)) {+ removed.push(name);+ pkg.remove(name);+ }+ }+ }+ return { removed: [...new Set(removed)], check: dryRun ? void 0 : checkPackage(pkg).length };+}++// src/office/xlsx.js+var DATE_FORMATS = /* @__PURE__ */ new Set([14, 15, 16, 17, 22, 45, 46, 47]);+var dateLike = (code) => /(^|[^\\])[ymdhs]/i.test(code ?? "");+function numFmts(pkg) {+ const map = /* @__PURE__ */ new Map();+ if (!pkg.parts.has("xl/styles.xml")) return map;+ const doc = pkg.xml("xl/styles.xml");+ const cellXfs = firstOf(doc.documentElement, "cellXfs");+ const custom = /* @__PURE__ */ new Map();+ for (const f of elementsOf(doc.documentElement, "numFmt")) custom.set(Number(f.getAttribute("numFmtId")), f.getAttribute("formatCode") ?? "");+ let i = 0;+ for (const xf of childrenOf(cellXfs)) {+ const id = Number(xf.getAttribute("numFmtId") ?? 0);+ map.set(i++, DATE_FORMATS.has(id) || dateLike(custom.get(id)) ? "date" : void 0);+ }+ return map;+}+function sharedStrings(pkg) {+ if (!pkg.parts.has("xl/sharedStrings.xml")) return [];+ return elementsOf(pkg.xml("xl/sharedStrings.xml").documentElement, "si").map((si) => textOf(si));+}+function sheetList(pkg) {+ const wb = pkg.xml("xl/workbook.xml");+ const rels = pkg.relsOf("xl/workbook.xml");+ return childrenOf(firstOf(wb.documentElement, "sheets") ?? wb.documentElement, "sheet").map((s) => {+ const rel = rels.get(s.getAttribute("r:id"));+ return { name: s.getAttribute("name"), state: s.getAttribute("state") ?? "visible", part: rel && pkg.targetOf("xl/workbook.xml", rel.target) };+ });+}+var colOf = (ref) => /^([A-Z]+)/.exec(ref)[1];+var rowOf = (ref) => Number(/(\d+)$/.exec(ref)[1]);+var colNum = (col) => [...col].reduce((n, c) => n * 26 + c.charCodeAt(0) - 64, 0);+function dateEpoch(pkg) {+ const wb = pkg.parts.has("xl/workbook.xml") ? pkg.xml("xl/workbook.xml") : void 0;+ return /^(1|true)$/i.test(firstOf(wb?.documentElement, "workbookPr")?.getAttribute("date1904") ?? "") ? 24107 : 25569;+}+function cellValue(c, shared, fmt, epoch = 25569) {+ const t = c.getAttribute("t"), v = firstOf(c, "v"), f = firstOf(c, "f");+ let value = v == null ? void 0 : v.textContent;+ if (t === "s" && value !== void 0) value = shared[Number(value)] ?? `#SST${value}`;+ else if (t === "b") value = value === "1";+ else if (t === "str" || t === "inlineStr") value = t === "inlineStr" ? textOf(firstOf(c, "is") ?? c) : value;+ else if (t === "e") value = value;+ else if (value !== void 0 && fmt.get(Number(c.getAttribute("s") ?? 0)) === "date" && !Number.isNaN(Number(value))) {+ const days = Number(value) - epoch;+ value = new Date(days * 864e5).toISOString().slice(0, value.includes(".") ? 19 : 10);+ }+ return { value, formula: f?.textContent };+}+function xlsxInventory(pkg) {+ const wb = pkg.xml("xl/workbook.xml");+ const names = [];+ const dn = firstOf(wb.documentElement, "definedNames");+ for (const d of childrenOf(dn, "definedName")) {+ names.push({ name: d.getAttribute("name"), scope: d.getAttribute("localSheetId"), value: d.textContent });+ }+ const sheets = sheetList(pkg).map((s) => {+ if (!s.part || !pkg.parts.has(s.part)) return { ...s, missing: true };+ const doc = pkg.xml(s.part);+ const dim = firstOf(doc.documentElement, "dimension")?.getAttribute("ref");+ const cells = elementsOf(doc.documentElement, "c");+ const errors = cells.filter((c) => c.getAttribute("t") === "e").map((c) => ({ cell: c.getAttribute("r"), value: firstOf(c, "v")?.textContent, formula: firstOf(c, "f")?.textContent }));+ const uncached = cells.filter((c) => firstOf(c, "f") && !firstOf(c, "v")).length;+ const tables = pkg.relList(s.part).filter((r) => r.type.endsWith("/table")).length;+ const charts = pkg.relList(s.part).filter((r) => r.type.endsWith("/chart") || r.type.endsWith("/drawing")).length;+ return {+ ...s,+ dimension: dim,+ cells: cells.length,+ formulas: cells.filter((c) => firstOf(c, "f")).length,+ merged: childrenOf(firstOf(doc.documentElement, "mergeCells"), "mergeCell").length,+ tables,+ drawings: charts,+ errors,+ uncachedFormulas: uncached || void 0+ };+ });+ return { sheets, definedNames: names };+}+function xlsxRead(pkg, sheetName, range) {+ const sheet = sheetList(pkg).find((s) => s.name === sheetName);+ if (!sheet) {+ const e = new Error(`no sheet named ${sheetName}`);+ e.code = "args";+ throw e;+ }+ if (!pkg.parts.has(sheet.part)) {+ const e = new Error(`sheet part ${sheet.part} missing`);+ e.code = "args";+ throw e;+ }+ const shared = sharedStrings(pkg);+ const fmt = numFmts(pkg);+ const epoch = dateEpoch(pkg);+ const doc = pkg.xml(sheet.part);+ const inRange = (ref) => {+ if (!range) return true;+ const [lo, hi] = range.split(":");+ const [c, r] = [colNum(colOf(ref)), rowOf(ref)];+ return c >= colNum(colOf(lo)) && c <= colNum(colOf(hi ?? lo)) && r >= rowOf(lo) && r <= rowOf(hi ?? lo);+ };+ const rows = [];+ for (const row of elementsOf(doc.documentElement, "row")) {+ const cells = {};+ for (const c of childrenOf(row, "c")) {+ const ref = c.getAttribute("r");+ if (!inRange(ref)) continue;+ const { value, formula } = cellValue(c, shared, fmt, epoch);+ cells[ref] = formula ? { v: value, f: formula } : { v: value };+ }+ if (Object.keys(cells).length > 0) rows.push({ row: Number(row.getAttribute("r")), cells });+ }+ return { sheet: sheetName, range, rows };+}++// src/office/png.js+import { deflateSync, inflateSync } from "node:zlib";+function fail3(message) {+ const error = new Error(message);+ error.code = "png";+ throw error;+}+function decodePng(buf) {+ if (buf.readUInt32BE(0) !== 2303741511 || buf.readUInt32BE(4) !== 218765834) fail3("not a PNG file");+ let width, height, depth, color, interlace;+ let palette, trns;+ const idat = [];+ for (let pos = 8; pos < buf.length; ) {+ const len = buf.readUInt32BE(pos), type = buf.toString("latin1", pos + 4, pos + 8);+ const data = buf.subarray(pos + 8, pos + 8 + len);+ if (type === "IHDR") {+ width = data.readUInt32BE(0);+ height = data.readUInt32BE(4);+ depth = data[8];+ color = data[9];+ interlace = data[12];+ } else if (type === "PLTE") palette = data;+ else if (type === "tRNS") trns = data;+ else if (type === "IDAT") idat.push(data);+ else if (type === "IEND") break;+ pos += 12 + len;+ }+ if (depth !== 8) fail3(`PNG bit depth ${depth} unsupported (8 only)`);+ if (interlace !== 0) fail3("interlaced PNG unsupported");+ const channels = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 }[color];+ if (channels === void 0) fail3(`PNG color type ${color} unsupported`);+ const raw = inflateSync(Buffer.concat(idat));+ const stride = width * channels;+ const out = Buffer.alloc(stride * height);+ for (let y = 0, pos = 0; y < height; y++) {+ const filter = raw[pos++];+ const row = raw.subarray(pos, pos + stride);+ const prev = y === 0 ? null : out.subarray((y - 1) * stride, y * stride);+ const cur = out.subarray(y * stride, (y + 1) * stride);+ for (let x = 0; x < stride; x++) {+ const a = x >= channels ? cur[x - channels] : 0;+ const b = prev ? prev[x] : 0;+ const c = prev && x >= channels ? prev[x - channels] : 0;+ let v = row[x];+ if (filter === 1) v = v + a & 255;+ else if (filter === 2) v = v + b & 255;+ else if (filter === 3) v = v + (a + b >> 1) & 255;+ else if (filter === 4) v = v + paeth(a, b, c) & 255;+ else if (filter !== 0) fail3(`PNG filter ${filter} unsupported`);+ cur[x] = v;+ }+ pos += stride;+ }+ const rgba = Buffer.alloc(width * height * 4);+ for (let i = 0; i < width * height; i++) {+ const s = i * channels, d = i * 4;+ if (color === 0) {+ rgba[d] = rgba[d + 1] = rgba[d + 2] = out[s];+ rgba[d + 3] = 255;+ } else if (color === 2) {+ rgba.set(out.subarray(s, s + 3), d);+ rgba[d + 3] = 255;+ } else if (color === 3) {+ const idx = out[s];+ rgba[d] = palette[idx * 3];+ rgba[d + 1] = palette[idx * 3 + 1];+ rgba[d + 2] = palette[idx * 3 + 2];+ rgba[d + 3] = trns && idx < trns.length ? trns[idx] : 255;+ } else if (color === 4) {+ rgba[d] = rgba[d + 1] = rgba[d + 2] = out[s];+ rgba[d + 3] = out[s + 1];+ } else rgba.set(out.subarray(s, s + 4), d);+ }+ return { width, height, data: rgba };+}+var paeth = (a, b, c) => {+ const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);+ return pa <= pb && pa <= pc ? a : pb <= pc ? b : c;+};+function encodePng({ width, height, data, channels = 4 }) {+ const stride = width * 3;+ const raw = Buffer.alloc((stride + 1) * height);+ for (let y = 0; y < height; y++) {+ raw[y * (stride + 1)] = 0;+ for (let x = 0; x < width; x++) {+ const s = (y * width + x) * channels;+ raw.set(data.subarray(s, s + 3), y * (stride + 1) + 1 + x * 3);+ }+ }+ const chunk = (type, payload) => {+ const buf = Buffer.alloc(12 + payload.length);+ buf.writeUInt32BE(payload.length, 0);+ buf.write(type, 4, "latin1");+ payload.copy(buf, 8);+ buf.writeUInt32BE(crc322(buf.subarray(4, 8 + payload.length)), 8 + payload.length);+ return buf;+ };+ const ihdr = Buffer.alloc(13);+ ihdr.writeUInt32BE(width, 0);+ ihdr.writeUInt32BE(height, 4);+ ihdr[8] = 8;+ ihdr[9] = 2;+ return Buffer.concat([+ Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),+ chunk("IHDR", ihdr),+ chunk("IDAT", deflateSync(raw, { level: 9 })),+ chunk("IEND", Buffer.alloc(0))+ ]);+}+var TABLE2 = (() => {+ const t = new Int32Array(256);+ for (let n = 0; n < 256; n++) {+ let c = n;+ for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;+ t[n] = c;+ }+ return t;+})();+var crc322 = (buf) => {+ let c = ~0;+ for (const b of buf) c = TABLE2[(c ^ b) & 255] ^ c >>> 8;+ return ~c >>> 0;+};+var DIGITS = {+ "0": [14, 17, 19, 21, 25, 17, 14],+ "1": [4, 12, 4, 4, 4, 4, 14],+ "2": [14, 17, 1, 6, 8, 16, 31],+ "3": [14, 17, 1, 6, 1, 17, 14],+ "4": [2, 6, 10, 18, 31, 2, 2],+ "5": [31, 16, 30, 1, 1, 17, 14],+ "6": [6, 8, 16, 30, 17, 17, 14],+ "7": [31, 1, 2, 4, 8, 8, 8],+ "8": [14, 17, 17, 14, 17, 17, 14],+ "9": [14, 17, 17, 15, 1, 2, 12]+};+function drawLabel(img, x, y, text, scale = 1) {+ let cx = x;+ for (const ch of text) {+ const glyph = DIGITS[ch];+ if (glyph) {+ for (let row = 0; row < 7; row++) {+ for (let col = 0; col < 5; col++) {+ if (!(glyph[row] & 16 >> col)) continue;+ for (let dy = 0; dy < scale; dy++) for (let dx = 0; dx < scale; dx++) {+ const px = cx + col * scale + dx, py = y + row * scale + dy;+ if (px < 0 || py < 0 || px >= img.width || py >= img.height) continue;+ const o = (py * img.width + px) * 4;+ img.data[o] = img.data[o + 1] = img.data[o + 2] = 40;+ img.data[o + 3] = 255;+ }+ }+ }+ }+ cx += 6 * scale;+ }+}+function contactSheet(images, { cols = 4, width = 320 } = {}) {+ const labelH = 10;+ const tiles = images.map((img) => {+ const h = Math.max(1, Math.round(img.height * width / img.width));+ return { img, h };+ });+ const rows = Math.ceil(tiles.length / cols);+ const rowH = [];+ for (let r = 0; r < rows; r++) rowH.push(Math.max(...tiles.slice(r * cols, (r + 1) * cols).map((t) => t.h), 1));+ const sheetW = cols * width;+ const sheetH = rowH.reduce((a, b) => a + b + labelH, 0);+ const data = Buffer.alloc(sheetW * sheetH * 4, 255);+ const sheet = { width: sheetW, height: sheetH, data, channels: 4 };+ let ty = 0;+ tiles.forEach((tile, i) => {+ const col = i % cols, row = Math.floor(i / cols);+ const y0 = ty;+ if (col === 0) ty = y0;+ const dstX = col * width, dstY = rowBaseline(rowH, row);+ for (let y = 0; y < tile.h; y++) {+ const sy = Math.floor(y * tile.img.height / tile.h);+ for (let x = 0; x < width; x++) {+ const sx = Math.floor(x * tile.img.width / width);+ const s = (sy * tile.img.width + sx) * 4, d = ((dstY + y) * sheetW + dstX + x) * 4;+ data.set(tile.img.data.subarray(s, s + 4), d);+ }+ }+ drawLabel(sheet, dstX + 2, dstY + tile.h + 1, String(i + 1), 1);+ ty = dstY;+ });+ return sheet;+}+var rowBaseline = (rowH, row) => rowH.slice(0, row).reduce((a, b) => a + b + 10, 0);++// src/office/cli.js+var USAGE = `ds-bot office — inspect, check and edit .docx/.pptx/.xlsx++unpack <file> <dir> extract with pretty-printed XML (new or reused dir)+pack <dir> <file> [--against <orig>] repack (strips formatting whitespace) and check+check <file|dir> [--against <orig>] [--fix [-o out|--in-place]]+docx read <file> [--changes] body blocks p1…/t1…, headers, notes, comments+docx fields <file> simple and complex fields+docx edit <file> -o out|--in-place --ops <json|@file>+pptx inventory <file|dir> [--slides N…|slideN.xml]+pptx layout <file> [--slides …] [--autofit (-o|--in-place)]+pptx slides <file> -o|--in-place --order 3,1,1,5+pptx clean <file|dir> [-o|--in-place] [--dry-run]+xlsx inventory <file>+xlsx read <file> --sheet <name> [--range A1:H40]+sheet <png…|dir> -o <contact.png> [--cols 4] [--width 320]`;+var JSON_MODE = false;+var Usage = class extends Error {+ constructor(m) {+ super(m);+ this.code = "usage";+ }+};+var need = (cond, message) => {+ if (!cond) throw new Usage(message);+};+function openAny(path) {+ return statSync2(path).isDirectory() ? Package.loadDir(path) : Package.open(path);+}+function outArgs(values, input) {+ if (values["in-place"]) return input;+ need(values.o !== void 0, "an edit writes to -o <file> or --in-place");+ return values.o;+}+var natural = (a, b) => a.localeCompare(b, void 0, { numeric: true });+async function main(argv) {+ const { values, positionals } = parseArgs({+ args: argv,+ strict: true,+ allowPositionals: true,+ options: {+ json: { type: "boolean" },+ o: { type: "string" },+ "in-place": { type: "boolean" },+ against: { type: "string" },+ fix: { type: "boolean" },+ changes: { type: "boolean" },+ ops: { type: "string" },+ slides: { type: "string", multiple: true },+ autofit: { type: "boolean" },+ order: { type: "string" },+ "dry-run": { type: "boolean" },+ sheet: { type: "string" },+ range: { type: "string" },+ cols: { type: "string", default: "4" },+ width: { type: "string", default: "320" }+ }+ });+ JSON_MODE = values.json;+ const [cmd, sub, ...rest] = positionals;+ const positional = sub !== void 0 && ["read", "fields", "edit", "inventory", "layout", "slides", "clean"].includes(sub) ? rest : [sub, ...rest];+ const file = positional[0];+ const command = ["unpack", "pack", "check", "docx", "pptx", "xlsx", "sheet"].includes(cmd) ? cmd : void 0;+ need(command !== void 0 && file !== void 0 || cmd === "sheet" && file !== void 0, USAGE);+ if (command === "unpack") {+ need(positional[1], "unpack <file> <dir>");+ Package.open(file).unpack(positional[1]);+ return { dir: positional[1] };+ }+ if (command === "pack") {+ const dir = file, target = positional[1];+ need(target, "pack <dir> <file>");+ const pkg2 = Package.loadDir(dir);+ for (const name of pkg2.parts.keys()) {+ if (!name.endsWith(".xml") && !name.endsWith(".rels")) continue;+ try {+ const doc = pkg2.xml(name);+ stripPrettyWhitespace(doc);+ pkg2.putXml(name, doc);+ } catch {+ }+ }+ writeFileSync2(target, pkg2.save());+ const against = values.against ? Package.open(values.against) : void 0;+ const findings = checkPackage(pkg2, against);+ return findings.length > 0 ? findingsResult(findings) : { file: target };+ }+ if (command === "check") {+ const pkg2 = openAny(file);+ if (values.fix) {+ const { fixed, remaining } = fixPackage(pkg2);+ const out = outArgs(values, file);+ if (statSync2(file).isDirectory()) pkg2.unpack(out);+ else writeFileSync2(out, pkg2.save());+ return remaining.length > 0 ? findingsResult(remaining, { fixed }) : { fixed, findings: [] };+ }+ const against = values.against ? openAny(values.against) : void 0;+ const findings = checkPackage(pkg2, against);+ return findings.length > 0 ? findingsResult(findings) : { findings: [] };+ }+ need(file && existsSync2(file), `no such file: ${String(file)}`);+ const pkg = ["docx", "pptx", "xlsx"].includes(command) ? openAny(file) : void 0;+ if (command === "docx") {+ if (sub === "read") return docxRead(pkg, { changes: values.changes });+ if (sub === "fields") return docxFields(pkg);+ if (sub === "edit") {+ need(values.ops, "docx edit needs --ops <json|@file>");+ const ops = JSON.parse(values.ops.startsWith("@") ? readFileSync2(values.ops.slice(1), "utf8") : values.ops);+ const result = docxEdit(pkg, ops);+ const out = outArgs(values, file);+ writeFileSync2(out, pkg.save());+ return { file: out, ...result };+ }+ throw new Usage("docx read|fields|edit");+ }+ if (command === "pptx") {+ if (sub === "inventory") return pptxInventory(pkg, values.slides);+ if (sub === "layout") {+ const result = pptxLayout(pkg, values.slides, { autofit: values.autofit });+ if (values.autofit && result.autofitApplied.length > 0) {+ const out = outArgs(values, file);+ writeFileSync2(out, pkg.save());+ result.file = out;+ }+ return result.findings.length > 0 ? findingsResult(result.findings, result) : result;+ }+ if (sub === "slides") {+ need(values.order, "pptx slides needs --order 3,1,1,5");+ const out = outArgs(values, file);+ const order = values.order.split(",").map((s) => Number(s.trim()));+ const result = pptxSlides(pkg, order);+ writeFileSync2(out, pkg.save());+ return { file: out, ...result };+ }+ if (sub === "clean") {+ const dry = values["dry-run"];+ const result = pptxClean(pkg, { dryRun: dry });+ if (!dry) {+ const out = outArgs(values, file);+ if (statSync2(file).isDirectory()) pkg.unpack(out);+ else writeFileSync2(out, pkg.save());+ result.file = out;+ }+ return result;+ }+ throw new Usage("pptx inventory|layout|slides|clean");+ }+ if (command === "xlsx") {+ if (sub === "inventory") return xlsxInventory(pkg);+ if (sub === "read") {+ need(values.sheet, "xlsx read needs --sheet <name>");+ return xlsxRead(pkg, values.sheet, values.range);+ }+ throw new Usage("xlsx inventory|read");+ }+ if (command === "sheet") {+ const inputs = positional.flatMap((p) => statSync2(p).isDirectory() ? readdirSync2(p).filter((n) => /\.png$/i.test(n)).sort(natural).map((n) => join2(p, n)) : [p]);+ need(inputs.length > 0 && values.o, "sheet <png…|dir> -o <contact.png>");+ const images = inputs.map((p) => decodePng(readFileSync2(p)));+ const sheetImg = contactSheet(images, { cols: Number(values.cols), width: Number(values.width) });+ mkdirSync2(join2(values.o, ".."), { recursive: true });+ writeFileSync2(values.o, encodePng(sheetImg));+ return { file: values.o, pages: images.length, width: sheetImg.width, height: sheetImg.height };+ }+ throw new Usage(USAGE);+}+function findingsResult(findings, extra = {}) {+ return { __findings: true, findings, ...extra };+}+main(process.argv.slice(2)).then((result) => {+ if (JSON_MODE) {+ const data = result?.__findings ? omit(result, ["__findings"]) : result;+ console.log(JSON.stringify({ ok: true, data }));+ process.exit(result?.__findings ? 1 : 0);+ }+ if (result?.__findings) {+ for (const f of result.findings) console.log(`${f.part}: ${f.message}`);+ process.exit(1);+ }+ console.log(typeof result === "string" ? result : JSON.stringify(result));+ process.exit(0);+}, (error) => {+ if (JSON_MODE) console.log(JSON.stringify({ ok: false, error: { code: error.code ?? "error", message: error.message } }));+ else console.error(error instanceof Usage ? `${error.message}+${USAGE}` : `office: ${error.message}`);+ process.exit(2);+});+var omit = (obj, keys) => Object.fromEntries(Object.entries(obj).filter(([k]) => !keys.includes(k)));diff --cc ds-bot/src/office/docx.jsindex a1241ac6,00000000..b35621b2mode 100644,000000..100644--- a/ds-bot/src/office/docx.js+++ b/ds-bot/src/office/docx.js@@@ -1,634 -1,0 +1,644 @@@+// docx commands: read (block ids, tables, headers/footers, notes, comments,+// tracked changes), fields, and edit (batched ops, all-or-nothing).+import { childrenOf, elementsOf, firstOf, textOf, parseXml } from './xml.js'+++const parts = (pkg) => [...pkg.parts.keys()].filter(name =>+ name === 'word/document.xml' || /^word\/(header|footer)\d+\.xml$/.test(name)+ || /^word\/(footnotes|endnotes|comments)\.xml$/.test(name))++// The paragraph/table texts a Bot reads, with tracked changes resolved one way.+function blockText(el, changes = false) {+ let out = ''+ const walk = (node, inside) => {+ if (node.nodeType === 3 || node.nodeType === 4) { if (!inside.del) out += node.data; return }+ if (node.nodeType !== 1) return+ const tag = node.tagName+ if (!changes) {+ for (const child of [...node.childNodes]) {+ if (tag === 'w:del' || tag === 'w:moveFrom') continue+ walk(child, inside)+ }+ return+ }+ let mark = inside+ let pre = '', post = ''+ const author = node.getAttribute?.('w:author') ?? ''+ if (tag === 'w:ins') { pre = `{+`; post = ` (${author})+}`; mark = { ...inside, del: false } }+ else if (tag === 'w:del') { pre = `{-`; post = ` (${author})-}`; mark = { ...inside, del: false } }+ else if (tag === 'w:moveFrom') { pre = `{<`; post = ` (${author})<}`; mark = { ...inside, del: false } }+ else if (tag === 'w:moveTo') { pre = `{>`; post = ` (${author})>}`; mark = { ...inside, del: false } }+ else if (tag === 'w:rPrChange' || tag === 'w:pPrChange') { out += '{~fmt~}'; return }+ else if (tag === 'w:moveFromRangeStart') { out += `{<move ${node.getAttribute('w:name') ?? ''}>`; return }+ else if (tag === 'w:moveToRangeStart') { out += `{>move ${node.getAttribute('w:name') ?? ''}>`; return }+ else if (tag === 'w:moveFromRangeEnd' || tag === 'w:moveToRangeEnd') { out += '{end}'; return }+ out += pre+ for (const child of [...node.childNodes]) walk(child, mark)+ out += post+ }+ walk(el, { del: false })+ return out+}++function paraStyle(p) { return firstOf(firstOf(p, 'w:pPr') ?? p, 'w:pStyle')?.getAttribute('w:val') }++function deletedParaMark(p) {+ const pPr = firstOf(p, 'w:pPr')+ return pPr !== undefined && firstOf(firstOf(pPr, 'w:rPr') ?? pPr, 'w:del') !== undefined+}++/** @returns {object[]} body blocks in reading order: pN paragraphs, tN tables */+export function docxRead(pkg, { changes = false } = {}) {+ const doc = pkg.xml('word/document.xml')+ const body = firstOf(doc.documentElement, 'w:body')+ const blocks = []+ let pi = 0, ti = 0+ const commentIds = commentsIndex(pkg, doc)+ for (const el of childrenOf(body)) {+ if (el.tagName === 'w:p') {+ pi+++ const id = `p${pi}`+ const entry = { id, type: 'paragraph', style: paraStyle(el), text: blockText(el, changes) }+ const anchored = commentIds.get(el)+ if (anchored) entry.comments = anchored+ if (deletedParaMark(el)) entry.deletedParagraphMark = true+ blocks.push(entry)+ } else if (el.tagName === 'w:tbl') {+ ti+++ blocks.push({ id: `t${ti}`, type: 'table', rows: tableRows(el, changes) })+ }+ }+ // headers/footers per section, footnotes, endnotes, comments.+ const sections = []+ const refs = elementsOf(doc.documentElement, 'w:headerReference').concat(elementsOf(doc.documentElement, 'w:footerReference'))+ const rels = pkg.relsOf('word/document.xml')+ for (const ref of refs) {+ const rel = rels.get(ref.getAttribute('r:id'))+ if (!rel) continue+ const target = pkg.targetOf('word/document.xml', rel.target)+ const part = pkg.xml(target)+ sections.push({+ kind: ref.tagName === 'w:headerReference' ? 'header' : 'footer',+ type: ref.getAttribute('w:type'), part: target,+ text: elementsOf(part.documentElement, 'w:p').map(p => blockText(p, changes)).filter(Boolean).join('\n'),+ })+ }+ const notes = []+ for (const [kind, part] of [['footnote', 'word/footnotes.xml'], ['endnote', 'word/endnotes.xml']]) {+ if (!pkg.parts.has(part)) continue+ for (const note of elementsOf(pkg.xml(part).documentElement, `w:${kind}`)) {+ const id = note.getAttribute('w:id')+ if (id === '-1' || id === '0') continue+ notes.push({ kind, id, text: elementsOf(note, 'w:p').map(p => blockText(p, changes)).join(' ') })+ }+ }+ return { blocks, sections, notes, comments: commentsList(pkg, changes) }+}++// pN ids number only the body's top-level paragraphs — the same ids docxRead+// gives. `doc` must be the parse the blocks come from: element keys from a+// second parse never match.+function commentsIndex(pkg, doc) {+ const byEl = new Map()+ if (!pkg.parts.has('word/comments.xml')) return byEl+ for (const ref of elementsOf(doc.documentElement, 'w:commentReference')) {+ let p = ref.parentNode+ while (p && p.tagName !== 'w:p') p = p.parentNode+ if (!p) continue+ const arr = byEl.get(p) ?? []+ arr.push({ commentId: ref.getAttribute('w:id') })+ byEl.set(p, arr)+ }+ return byEl+}++function commentsList(pkg, changes) {+ if (!pkg.parts.has('word/comments.xml')) return []+ const commentsDoc = pkg.xml('word/comments.xml')+ const anchors = commentAnchors(pkg)+ return elementsOf(commentsDoc.documentElement, 'w:comment').map(c => ({+ id: c.getAttribute('w:id'), author: c.getAttribute('w:author'), initials: c.getAttribute('w:initials'),+ date: c.getAttribute('w:date'), text: elementsOf(c, 'w:p').map(p => blockText(p, changes)).join(' '),+ anchorsTo: anchors.get(c.getAttribute('w:id')),+ }))+}++function commentAnchors(pkg) {+ const map = new Map()+ const doc = pkg.xml('word/document.xml')+ const index = blockIndex(doc)+ const byEl = new Map([...index].map(([id, el]) => [el, id]))+ for (const ref of elementsOf(doc.documentElement, 'w:commentReference')) {+ let p = ref.parentNode+ while (p && p.tagName !== 'w:p') p = p.parentNode+ if (p && byEl.has(p)) map.set(ref.getAttribute('w:id'), byEl.get(p))+ }+ return map+}++function tableRows(tbl, changes) {+ return childrenOf(tbl, 'w:tr').map(tr =>+ childrenOf(tr, 'w:tc').map(tc => {+ const gridSpan = firstOf(firstOf(tc, 'w:tcPr') ?? tc, 'w:gridSpan')?.getAttribute('w:val')+ const vMerge = firstOf(firstOf(tc, 'w:tcPr') ?? tc, 'w:vMerge')+ return {+ text: elementsOf(tc, 'w:p').map(p => blockText(p, changes)).join(' '),+ ...(gridSpan ? { gridSpan: Number(gridSpan) } : {}),+ ...(vMerge ? { vMerge: vMerge.getAttribute('w:val') ?? 'continue' } : {}),+ }+ }))+}++/** @returns {object[]} simple + complex fields with instruction and cached result */+export function docxFields(pkg) {+ const out = []+ for (const name of parts(pkg)) {+ const doc = pkg.xml(name)+ for (const fld of elementsOf(doc.documentElement, 'w:fldSimple')) {+ out.push({ part: name, kind: 'simple', instruction: fld.getAttribute('w:instr') ?? '', result: textOf(fld) })+ }+ // Complex fields: instrText between fldChar begin and separate, result till end.+ const paras = elementsOf(doc.documentElement, 'w:p')+ let open = null+ const flush = () => { if (open) { delete open.phase; out.push(open) } open = null }+ for (const p of paras) {+ for (const el of elementsOf(p)) {+ if (el.tagName === 'w:fldChar') {+ const type = el.getAttribute('w:fldCharType')+ if (type === 'begin') { flush(); open = { part: name, kind: 'complex', instruction: '', result: '' } }+ else if (type === 'separate' && open) open.phase = 'result'+ else if (type === 'end') flush()+ } else if (open && el.tagName === 'w:instrText' && open.phase !== 'result') open.instruction += el.textContent+ else if (open && open.phase === 'result' && (el.tagName === 'w:t' || el.tagName === 'w:delText')) open.result += el.textContent+ }+ }+ flush()+ }+ return out+}++// ---- edit ops ----++const EDIT_PARTS = (pkg, bodyOnly) => parts(pkg).filter(name =>+ name === 'word/document.xml' || (!bodyOnly && /^word\/(header|footer)\d+\.xml$|^word\/(footnotes|endnotes)\.xml$/.test(name)))++/** Map pN/tN ids to elements exactly as docxRead numbers them. */+export function blockIndex(doc) {+ const body = firstOf(doc.documentElement, 'w:body')+ const map = new Map()+ let pi = 0, ti = 0+ for (const el of childrenOf(body)) {+ if (el.tagName === 'w:p') map.set(`p${++pi}`, el)+ else if (el.tagName === 'w:tbl') map.set(`t${++ti}`, el)+ }+ return map+}++function isDeleted(p, r) {+ for (let n = r; n && n !== p; n = n.parentNode) if (n.tagName === 'w:del' || n.tagName === 'w:moveFrom') return true+ return false+}++++/**+ * Apply an array of ops to every docx part they reach. All-or-nothing: callers+ * hold the saved copy until every op reports success.+ * @returns {{ changed: string[], count: number }}+ */+export function docxEdit(pkg, ops) {+ const docs = new Map()+ const getDoc = (name) => {+ if (!docs.has(name)) docs.set(name, pkg.xml(name))+ return docs.get(name)+ }++ // All ids in a batch refer to the document the caller read, before any edits.++ const body = firstOf(getDoc('word/document.xml').documentElement, 'w:body')++ const blocks = blockIndex(getDoc('word/document.xml'))++ const blockOf = (id) => {++ const block = blocks.get(id)++ if (!block || block.parentNode !== body) throw new Error(`no block ${id}`)++ return block++ }+ const changed = new Set()+ let count = 0+ ops.forEach((op, index) => {- try { applyOp(pkg, getDoc, changed, op); count++ }++ try { applyOp(pkg, getDoc, blockOf, changed, op); count++ }+ catch (error) { const e = new Error(`op ${index} (${opKind(op)}): ${error.message}`); e.code = 'ops'; throw e }+ })+ for (const [name, doc] of docs) if (changed.has(name)) pkg.putXml(name, doc)+ return { changed: [...changed], count }+}++const opKind = (op) => Object.keys(op).find(k => !['o', 'inPlace'].includes(k)) ?? '?'+- function applyOp(pkg, getDoc, changed, op) {++function applyOp(pkg, getDoc, blockOf, changed, op) {+ const mainDoc = () => getDoc('word/document.xml')+ if (op.replace) {+ const { find, with: withText, regex = false, bodyOnly = false } = op.replace+ const re = regex ? new RegExp(find, 'g') : new RegExp(escapeRe(find), 'g')+ for (const name of EDIT_PARTS(pkg, bodyOnly)) {+ const doc = getDoc(name)+ const n = replaceInDoc(doc, re, withText)+ if (n > 0) changed.add(name)+ }+ return+ }+ if (op.set_cell) {+ const { table, row, col, text } = op.set_cell- const tbl = blockIndex(mainDoc()).get(`t${table}`)- if (!tbl) throw new Error(`no table t${table}`)++ const tbl = blockOf(`t${table}`)+ const tr = childrenOf(tbl, 'w:tr')[row - 1]+ const tc = tr && childrenOf(tr, 'w:tc')[col - 1]+ if (!tc) throw new Error(`no cell r${row}c${col} in t${table}`)+ setCellText(getDoc('word/document.xml'), tc, String(text))+ changed.add('word/document.xml')+ return+ }+ if (op.set_field) {+ const { match, value } = op.set_field+ const re = new RegExp(match)+ let any = false+ for (const name of EDIT_PARTS(pkg, false)) {+ const doc = getDoc(name)+ let hit = false+ for (const fld of elementsOf(doc.documentElement, 'w:fldSimple')) {+ if (re.test(fld.getAttribute('w:instr') ?? '')) { setFieldResult(doc, fld, String(value)); hit = true }+ }+ if (setComplexFieldResult(doc, re, String(value))) hit = true+ if (hit) { changed.add(name); any = true }+ }+ if (!any) throw new Error(`no field instruction matches /${match}/`)+ return+ }+ if (op.insert) {+ const { after, before, text, style, like } = op.insert+ const doc = mainDoc()- const index = blockIndex(doc)- const anchor = index.get(after ?? before)- if (!anchor) throw new Error(`no paragraph ${after ?? before}`)++ const anchor = blockOf(after ?? before)+ const p = doc.createElement('w:p')+ if (style || like) {+ const pPr = doc.createElement('w:pPr')+ const pStyle = doc.createElement('w:pStyle')- pStyle.setAttribute('w:val', style ?? paraStyle(index.get(like)) ?? 'Normal')++ pStyle.setAttribute('w:val', style ?? paraStyle(blockOf(like)) ?? 'Normal')+ pPr.appendChild(pStyle); p.appendChild(pPr)+ }+ const r = doc.createElement('w:r')+ const t = doc.createElement('w:t'); t.setAttribute('xml:space', 'preserve')+ t.appendChild(doc.createTextNode(text))+ r.appendChild(t); p.appendChild(r)+ anchor.parentNode.insertBefore(p, before ? anchor : anchor.nextSibling)+ changed.add('word/document.xml')+ return+ }+ if (op.delete) {- const doc = mainDoc()- const index = blockIndex(doc)+ for (const id of op.delete.paragraphs) {- const el = index.get(id)- if (!el) throw new Error(`no block ${id}`)++ const el = blockOf(id)+ el.parentNode.removeChild(el)+ }+ changed.add('word/document.xml')+ return+ }+ if (op.comment) {- addComment(pkg, getDoc, changed, op.comment)++ addComment(pkg, getDoc, blockOf, changed, op.comment)+ return+ }+ if (op.accept_changes || op.reject_changes) {+ const accept = Boolean(op.accept_changes)+ for (const name of parts(pkg)) {+ if (!pkg.parts.has(name)) continue+ const doc = getDoc(name)+ if (resolveChanges(doc, accept)) changed.add(name)+ }+ return+ }+ throw new Error(`unknown op ${JSON.stringify(op)}`)+}++function escapeRe(s) { return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') }++// Replacement text with $1..$9 group, $& match and $$ escapes resolved — the+// pattern is not re-run, so anchors and lookarounds cannot be lost.+const expand = (m, withText) =>+ withText.replace(/\$(\$|&|[1-9]\d?)/g, (_, g) => g === '$' ? '$' : g === '&' ? m[0] : (m[Number(g)] ?? ''))++const nearestPara = (el) => { for (let n = el.parentNode; n; n = n.parentNode) if (n.tagName === 'w:p') return n; return null }++// A new run holding `text`, with `src`'s w:rPr cloned so formatting survives.+const cloneRun = (doc, src, text) => {+ const clone = src.cloneNode(false)+ const rPr = childrenOf(src, 'w:rPr')[0]+ if (rPr) clone.appendChild(rPr.cloneNode(true))+ const t = doc.createElement('w:t'); t.setAttribute('xml:space', 'preserve')+ t.appendChild(doc.createTextNode(text)); clone.appendChild(t)+ return clone+}++// Replace text across runs inside one document; deletions skipped; formatting+// of the match-start run kept. Each affected run is rebuilt once from its+// original text and every match that touches it, so several matches in one+// run, adjacent matches and spanning matches all compose. Returns the count.+function replaceInDoc(doc, re, withText) {+ let total = 0+ const global = new RegExp(re.source, re.flags.includes('g') ? re.flags : re.flags + 'g')+ for (const p of elementsOf(doc.documentElement, 'w:p')) {+ const runs = elementsOf(p, 'w:r').filter(r => !isDeleted(p, r) && nearestPara(r) === p)+ const texts = runs.map(r => elementsOf(r, 'w:t').map(t => t.textContent).join(''))+ const joined = texts.join('')+ const matches = [...joined.matchAll(global)]+ if (matches.length === 0) continue++ if (runs.length === 0) {++ const run = doc.createElement('w:r')++ run.appendChild(doc.createElement('w:t'))++ p.appendChild(run)++ runs.push(run)++ texts.push('')++ }+ const bounds = []+ let cursor = 0+ for (const t of texts) { bounds.push([cursor, cursor + t.length]); cursor += t.length }+ for (let i = 0; i < runs.length; i++) {+ const [rs, rend] = bounds[i]- const covers = matches.filter(m => m.index < rend && (m.index + m[0].length > rs || (m.index >= rs && m.index < rend)))++ // The final run also owns the paragraph's end, including a zero-width match.++ const startsHere = m => m.index >= rs && (m.index < rend || (i === runs.length - 1 && m.index === rend))++ const covers = matches.filter(m => startsHere(m) || (m.index < rend && m.index + m[0].length > rs))+ if (covers.length === 0) continue+ // Pieces in order: kept text fragments alternating with replacement runs+ // (a run emits a replacement only for matches starting inside it).+ const pieces = []+ let pos = 0+ for (const m of covers) {+ const cs = Math.max(0, m.index - rs)+ const ce = Math.min(texts[i].length, m.index + m[0].length - rs)+ if (cs > pos) pieces.push({ text: texts[i].slice(pos, cs) })- if (m.index >= rs && m.index < rend) pieces.push({ repl: expand(m, withText) })++ if (startsHere(m)) pieces.push({ repl: expand(m, withText) })+ pos = ce+ }+ if (pos < texts[i].length || pieces.length === 0) pieces.push({ text: texts[i].slice(pos) })+ const run = runs[i]+ let anchor = run+ for (const [k, piece] of pieces.entries()) {+ if (k === 0) {+ setRunText(run, piece.text ?? '')+ if (piece.text !== undefined) continue+ }+ const clone = cloneRun(doc, run, piece.repl ?? piece.text)+ anchor.parentNode.insertBefore(clone, anchor.nextSibling)+ anchor = clone+ }- total += covers.filter(m => m.index >= rs && m.index < rend).length++ total += covers.filter(startsHere).length+ }+ }+ return total+}+++function setRunText(run, text) {+ const ts = elementsOf(run, 'w:t')+ if (ts.length === 0) return+ ts[0].textContent = text+ if (text !== text.trim()) ts[0].setAttribute('xml:space', 'preserve')+ for (const extra of ts.slice(1)) extra.textContent = ''+}++function setCellText(doc, tc, text) {+ // w:tcPr stays; the first paragraph's pPr and the first run's rPr carry over.+ const paras = childrenOf(tc, 'w:p')+ const pPr = paras[0] && childrenOf(paras[0], 'w:pPr')[0]+ const firstRun = paras[0] && elementsOf(paras[0], 'w:r')[0]+ const rPr = firstRun && childrenOf(firstRun, 'w:rPr')[0]+ for (const p of paras) tc.removeChild(p)+ const p = doc.createElement('w:p')+ if (pPr) p.appendChild(pPr)+ const r = doc.createElement('w:r')+ if (rPr) r.appendChild(rPr)+ const t = doc.createElement('w:t'); t.setAttribute('xml:space', 'preserve')+ t.appendChild(doc.createTextNode(text))+ r.appendChild(t); p.appendChild(r); tc.appendChild(p)+}++function setFieldResult(doc, fld, value) {+ // One run with the value, carrying the first run's rPr.+ const rPr = elementsOf(fld, 'w:r')[0] && childrenOf(elementsOf(fld, 'w:r')[0], 'w:rPr')[0]+ for (const child of [...fld.childNodes]) fld.removeChild(child)+ const r = doc.createElement('w:r')+ if (rPr) r.appendChild(rPr.cloneNode(true))+ const t = doc.createElement('w:t'); t.setAttribute('xml:space', 'preserve')+ t.appendChild(doc.createTextNode(value))+ r.appendChild(t); fld.appendChild(r)+}++// Complex fields can nest and span paragraphs: track begin/end depth, and in+// the result span (after the depth-1 separate, before the matching end) give+// the first run the value and clear the rest.+function setComplexFieldResult(doc, re, value) {+ let hit = false+ let depth = 0, inField = false, inResult = false, first = true+ for (const el of elementsOf(doc.documentElement)) {+ if (el.tagName === 'w:instrText') {+ if (!inField && re.test(el.textContent)) { inField = true; depth = 1; inResult = false; first = true }+ continue+ }+ if (!inField) continue+ if (el.tagName === 'w:fldChar') {+ const type = el.getAttribute('w:fldCharType')+ if (type === 'begin') depth+++ else if (type === 'end') { depth--; if (depth === 0) inField = false }+ else if (type === 'separate' && depth === 1) inResult = true+ continue+ }+ if (inResult && el.tagName === 'w:r') {+ if (first) { setRunText(el, value); first = false }+ else setRunText(el, '')+ hit = true+ }+ }+ return hit+}++const ancestor = (node, tag) => { for (let n = node.parentNode; n; n = n.parentNode) if (n.tagName === tag) return n; return null }++// Split `run` at `offset`: the original keeps the first half, a clone with its+// rPr takes the rest right after it. Returns the clone.+function splitRunAt(doc, run, offset) {+ const text = elementsOf(run, 'w:t').map(t => t.textContent).join('')+ const clone = cloneRun(doc, run, text.slice(offset))+ setRunText(run, text.slice(0, offset))+ run.parentNode.insertBefore(clone, run.nextSibling)+ return clone+}++// The run sequence covering `anchor` inside `p`, split at its exact edges.+// Returns { firstRun, lastRun } or undefined when the phrase is not there.+function phraseRuns(doc, p, anchor) {+ const runs = elementsOf(p, 'w:r').filter(r => !isDeleted(p, r) && nearestPara(r) === p)+ const texts = runs.map(r => elementsOf(r, 'w:t').map(t => t.textContent).join(''))+ const joined = texts.join('')+ const start = joined.indexOf(anchor)+ if (start < 0) return undefined+ const end = start + anchor.length+ const locate = (pos) => {+ let c = 0+ for (let i = 0; i < runs.length; i++) {+ const e = c + texts[i].length+ if (pos < e || (pos === e && i === runs.length - 1)) return { i, off: pos - c }+ c = e+ }+ return { i: runs.length - 1, off: texts.at(-1).length }+ }+ const e = locate(end), s = locate(start)+ let lastRun, firstRun+ if (e.off === texts[e.i].length) lastRun = runs[e.i]+ else if (e.off === 0) lastRun = runs[e.i - 1]+ else { splitRunAt(doc, runs[e.i], e.off); lastRun = runs[e.i] }+ if (s.i === e.i && s.off > 0) {+ // The phrase lives in the clone the start split creates, not the prefix run.+ firstRun = lastRun = splitRunAt(doc, runs[s.i], s.off)+ } else {+ firstRun = s.off === 0 ? runs[s.i] : splitRunAt(doc, runs[s.i], s.off)+ }+ return { firstRun, lastRun }+}+- function addComment(pkg, getDoc, changed, { paragraph, text, anchor, author = 'Bot', initials = 'B' }) {++function addComment(pkg, getDoc, blockOf, changed, { paragraph, text, anchor, author = 'Bot', initials = 'B' }) {+ const doc = getDoc('word/document.xml')- const p = blockIndex(doc).get(paragraph)- if (!p) throw new Error(`no paragraph ${paragraph}`)++ const p = blockOf(paragraph)+ // comments.xml + its rel + content type are created when missing.+ let commentsDoc+ if (!pkg.parts.has('word/comments.xml')) {+ commentsDoc = parseXml('<w:comments xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"/>')+ pkg.rels.set('word/document.xml', pkg.relsOf('word/document.xml'))+ let next = 1+ const map = pkg.rels.get('word/document.xml')+ while (map.has(`rId${next}`)) next+++ map.set(`rId${next}`, { id: `rId${next}`, type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments', target: 'comments.xml', mode: 'Internal' })+ pkg.override('word/comments.xml', 'application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml')+ } else commentsDoc = getDoc('word/comments.xml')+ const id = String(Math.max(0, ...elementsOf(commentsDoc.documentElement, 'w:comment').map(c => Number(c.getAttribute('w:id')) || 0)) + 1)+ const comment = commentsDoc.createElement('w:comment')+ comment.setAttribute('w:id', id); comment.setAttribute('w:author', author); comment.setAttribute('w:initials', initials)+ const cp = commentsDoc.createElement('w:p'); const cr = commentsDoc.createElement('w:r')+ const ct = commentsDoc.createElement('w:t'); ct.setAttribute('xml:space', 'preserve')+ ct.appendChild(commentsDoc.createTextNode(text)); cr.appendChild(ct); cp.appendChild(cr); comment.appendChild(cp)+ commentsDoc.documentElement.appendChild(comment)+ pkg.putXml('word/comments.xml', commentsDoc)+ const rangeStart = doc.createElement('w:commentRangeStart'); rangeStart.setAttribute('w:id', id)+ const rangeEnd = doc.createElement('w:commentRangeEnd'); rangeEnd.setAttribute('w:id', id)+ const ref = doc.createElement('w:r')+ const refEl = doc.createElement('w:commentReference'); refEl.setAttribute('w:id', id)+ ref.appendChild(refEl)+ // Range markers sit between runs, never before the paragraph's w:pPr.+ const pPr = childrenOf(p, 'w:pPr')[0]+ if (anchor) {+ const span = phraseRuns(doc, p, anchor)+ if (!span) throw new Error(`anchor "${anchor}" not found in ${paragraph}`)+ // The phrase can sit inside a w:hyperlink — insert beside the run itself.+ span.firstRun.parentNode.insertBefore(rangeStart, span.firstRun)+ span.lastRun.parentNode.insertBefore(rangeEnd, span.lastRun.nextSibling)+ span.lastRun.parentNode.insertBefore(ref, rangeEnd.nextSibling)+ } else {+ p.insertBefore(rangeStart, pPr ? pPr.nextSibling : p.firstChild)+ p.appendChild(rangeEnd)+ p.appendChild(ref)+ }+ changed.add('word/document.xml')+}++// accept/reject tracked changes across one document part.+export function resolveChanges(doc, accept) {+ let dirty = false+ const lift = (el) => { while (el.firstChild) el.parentNode.insertBefore(el.firstChild, el); el.parentNode.removeChild(el) }+ // Paragraph and row marks first: they restructure the tree, so the generic+ // ins/del pass must not see them. Merging moves this paragraph's content+ // children (all but w:pPr), in order, into the next paragraph after its w:pPr+ // — the merged paragraph keeps the next paragraph's mark and properties.+ const mergeIntoNext = (p, pPr) => {+ const next = p.nextSibling+ if (!next || next.tagName !== 'w:p') return false+ const nextPPr = childrenOf(next, 'w:pPr')[0]+ const anchor = nextPPr ? nextPPr.nextSibling : next.firstChild+ for (const node of [...p.childNodes]) {+ if (node === pPr) continue+ next.insertBefore(node, anchor)+ }+ p.parentNode.removeChild(p)+ return true+ }+ for (const p of elementsOf(doc.documentElement, 'w:p')) {+ const pPr = childrenOf(p, 'w:pPr')[0]+ const rPr = pPr && childrenOf(pPr, 'w:rPr')[0]+ if (!rPr) continue+ const del = childrenOf(rPr, 'w:del')[0]+ const ins = childrenOf(rPr, 'w:ins')[0]+ if (del) { dirty = true; if (!accept || !mergeIntoNext(p, pPr)) rPr.removeChild(del) }+ else if (ins) { dirty = true; if (accept || !mergeIntoNext(p, pPr)) rPr.removeChild(ins) }+ }+ for (const tr of elementsOf(doc.documentElement, 'w:tr')) {+ const trPr = childrenOf(tr, 'w:trPr')[0]+ if (!trPr) continue+ const ins = childrenOf(trPr, 'w:ins')[0]+ const del = childrenOf(trPr, 'w:del')[0]+ if (ins) { dirty = true; if (accept) trPr.removeChild(ins); else tr.parentNode.removeChild(tr) }+ else if (del) { dirty = true; if (accept) tr.parentNode.removeChild(tr); else trPr.removeChild(del) }+ }+ // Range markers next so wrappers see clean ranges.+ for (const el of elementsOf(doc.documentElement)) {+ const tag = el.tagName+ if (tag === 'w:moveFromRangeStart' || tag === 'w:moveFromRangeEnd' || tag === 'w:moveToRangeStart' || tag === 'w:moveToRangeEnd'+ || tag === 'w:customXmlInsRangeStart' || tag === 'w:customXmlInsRangeEnd'+ || tag === 'w:customXmlDelRangeStart' || tag === 'w:customXmlDelRangeEnd'+ || tag === 'w:customXmlMoveFromRangeStart' || tag === 'w:customXmlMoveFromRangeEnd'+ || tag === 'w:customXmlMoveToRangeStart' || tag === 'w:customXmlMoveToRangeEnd') {+ el.parentNode?.removeChild(el); dirty = true+ }+ }+ for (const el of elementsOf(doc.documentElement)) {+ const tag = el.tagName+ if (tag === 'w:ins' || tag === 'w:moveTo') {+ if (accept) lift(el)+ else el.parentNode.removeChild(el)+ dirty = true+ }+ else if (tag === 'w:del' || tag === 'w:moveFrom') {+ if (accept) { el.parentNode.removeChild(el); dirty = true }+ else {+ // w:delText → w:t restores the deleted text.+ for (const t of elementsOf(el, 'w:delText')) { t.tagName = 'w:t' }+ lift(el); dirty = true+ }+ } else if (tag === 'w:numberingChange') {+ el.parentNode.removeChild(el); dirty = true+ } else if (/^w:(pPrChange|rPrChange|tblPrChange|tcPrChange|trPrChange|sectPrChange)$/.test(tag)) {+ const parent = el.parentNode+ if (accept) { parent.removeChild(el); dirty = true }+ else {+ // Restore the stored old properties: the parent keeps the parts the+ // stored copy never holds (a pPr's mark rPr and sectPr; a sectPr's+ // header/footer references) and takes the rest from the stored copy.+ const stored = childrenOf(el)[0]+ const keep = new Set()+ if (parent.tagName === 'w:pPr') { keep.add('w:rPr'); keep.add('w:sectPr') }+ if (parent.tagName === 'w:sectPr') { keep.add('w:headerReference'); keep.add('w:footerReference') }+ for (const c of [...parent.childNodes]) if (!keep.has(c.tagName) && c !== el) parent.removeChild(c)+ if (stored) {+ // pPr keeps its mark rPr/sectPr at the end; a sectPr's header/footer+ // references come first, so restored children go after them (the+ // change element is removed anyway).+ const kept = [...parent.childNodes].filter(c => keep.has(c.tagName))+ const anchor = parent.tagName === 'w:sectPr'+ ? (kept.length > 0 ? kept.at(-1).nextSibling : parent.firstChild === el ? null : parent.firstChild)+ : (kept[0] ?? el)+ for (const s of [...stored.childNodes]) parent.insertBefore(s, anchor)+ }+ parent.removeChild(el)+ dirty = true+ }+ } else if (tag === 'w:cellIns' || tag === 'w:cellDel') {+ const tc = ancestor(el, 'w:tc')+ if (tc) {+ if (accept && tag === 'w:cellDel') tc.parentNode?.removeChild(tc)+ else if (!accept && tag === 'w:cellIns') tc.parentNode?.removeChild(tc)+ el.parentNode.removeChild(el); dirty = true+ }+ }+ }+ return dirty+}diff --cc ds-bot/test/office.test.jsindex eae9cf3f,00000000..b7a64476mode 100644,000000..100644--- a/ds-bot/test/office.test.js+++ b/ds-bot/test/office.test.js@@@ -1,732 -1,0 +1,778 @@@+// Tests for the ds-bot Office CLI (src/office → office.js). Fixtures are the+// small packages under fixtures/office generated by dev/office-fixtures.py.+import { execFileSync } from 'node:child_process'+import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync, existsSync } from 'node:fs'+import { tmpdir } from 'node:os'+import { join, dirname } from 'node:path'+import { fileURLToPath } from 'node:url'+import { describe, test } from 'node:test'+import assert from 'node:assert'+import { readZip, writeZip } from '../src/office/zip.js'+import { Package } from '../src/office/package.js'+import { checkPackage, fixPackage } from '../src/office/check.js'+import { docxRead, docxEdit, resolveChanges } from '../src/office/docx.js'+import { pptxInventory, pptxLayout, pptxClean, pptxSlides } from '../src/office/pptx.js'+import { xlsxInventory, xlsxRead } from '../src/office/xlsx.js'+import { decodePng, encodePng, contactSheet } from '../src/office/png.js'+import { parseXml, elementsOf, childrenOf, textOf } from '../src/office/xml.js'++const ROOT = dirname(dirname(fileURLToPath(import.meta.url)))+const FIXTURES = join(ROOT, 'test', 'fixtures', 'office')+const CLI = join(ROOT, 'office.js')+const NODE = process.execPath++const fixture = (name) => join(FIXTURES, name)+const tmp = () => mkdtempSync(join(tmpdir(), 'office-test-'))++// exit 1 means "findings remain" — still a JSON result, not a failure.+const cli = (...args) => {+ try {+ return JSON.parse(execFileSync(NODE, [CLI, ...args, '--json'], { encoding: 'utf8' }))+ } catch (error) {+ if (error.stdout) return JSON.parse(error.stdout)+ throw error+ }+}++describe('zip', () => {+ test('round trip keeps unchanged members byte-identical', () => {+ const docx = fixture('sample.docx')+ const pkg = Package.open(docx)+ const before = readZip(readFileSync(docx))+ pkg.put('word/styles.xml', pkg.get('word/styles.xml')) // same bytes through put()+ const after = readZip(pkg.save())+ const a = before.find(m => m.name === 'word/document.xml')+ const b = after.find(m => m.name === 'word/document.xml')+ assert.deepEqual(b.raw, a.raw) // compressed bytes preserved for untouched parts+ assert.equal(after[0].name, '[Content_Types].xml')+ assert.equal(before.length, after.length)+ })++ test('rejects zip64 with a clear error', () => {+ const docx = readFileSync(fixture('sample.docx'))+ const copy = Buffer.from(docx)+ const eocd = copy.length - 22+ copy.writeUInt32LE(0xffffffff, eocd + 16)+ assert.throws(() => readZip(copy), /zip64/)+ })+})++describe('check', () => {+ const rules = [+ ['malformed-xml', (pkg) => pkg.put('word/styles.xml', '<w:styles><broken')],+ ['override-absent-part', (pkg) => pkg.overrides.set('word/ghost.xml', 'application/x')],+ ['dangling-rel', (pkg) => {+ const doc = pkg.xml('word/_rels/document.xml.rels')+ const rel = doc.createElement('Relationship')+ rel.setAttribute('Id', 'rId99'); rel.setAttribute('Type', 'x'); rel.setAttribute('Target', 'gone.xml')+ doc.documentElement.appendChild(rel)+ pkg.putXml('word/_rels/document.xml.rels', doc)+ }],+ ['missing-xml-space', (pkg) => {+ const doc = pkg.xml('word/document.xml')+ const p = parseXml('<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:r><w:t> tail</w:t></w:r></w:p>').documentElement+ doc.documentElement.appendChild(p.ownerDocument === doc ? p : doc.importNode(p, true))+ pkg.putXml('word/document.xml', doc)+ }],+ ]+ for (const [rule, breakIt] of rules) {+ test(`reports ${rule}`, () => {+ const pkg = Package.open(fixture('sample.docx'))+ breakIt(pkg)+ assert.ok(checkPackage(pkg).some(f => f.rule === rule), `no ${rule}`)+ })+ }+ test('clean fixture passes', () => {+ assert.deepEqual(checkPackage(Package.open(fixture('sample.docx'))), [])+ assert.deepEqual(checkPackage(Package.open(fixture('sample.pptx'))), [])+ assert.deepEqual(checkPackage(Package.open(fixture('sample.xlsx'))), [])+ })+ test('--against reports only new issues', () => {+ const original = Package.open(fixture('sample.docx'))+ const edited = Package.open(fixture('sample.docx'))+ const doc = edited.xml('word/_rels/document.xml.rels')+ const rel = doc.createElement('Relationship')+ rel.setAttribute('Id', 'rId99'); rel.setAttribute('Type', 'x'); rel.setAttribute('Target', 'gone.xml')+ doc.documentElement.appendChild(rel)+ edited.putXml('word/_rels/document.xml.rels', doc)+ const found = checkPackage(edited, original)+ assert.equal(found.length, 1)+ assert.equal(found[0].rule, 'dangling-rel')+ })+ test('--fix repairs missing-xml-space and dangling rels', () => {+ const pkg = Package.open(fixture('sample.docx'))+ const doc = pkg.xml('word/document.xml')+ const p = parseXml('<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:r><w:t> tail</w:t></w:r></w:p>').documentElement+ doc.documentElement.appendChild(doc.importNode(p, true))+ pkg.putXml('word/document.xml', doc)+ pkg.rels.get('word/document.xml').set('rId99', { id: 'rId99', type: 'x', target: 'gone.xml', mode: 'Internal' })+ const { remaining } = fixPackage(pkg)+ assert.deepEqual(remaining, [])+ })+})++describe('docx', () => {+ test('read gives pN/tN ids, tables, headers, comments', () => {+ const { blocks, sections, comments } = docxRead(Package.open(fixture('sample.docx')))+ assert.equal(blocks[0].id, 'p1')+ assert.equal(blocks[0].style, 'Title')+ const table = blocks.find(b => b.id === 't1')+ assert.equal(table.rows[0][0].gridSpan, 2)+ assert.ok(blocks.some(b => b.deletedParagraphMark))+ assert.equal(sections.find(s => s.kind === 'header').text, 'Report header')+ assert.equal(comments[0].author, 'Ana')+ assert.equal(comments[0].anchorsTo, 'p3')+ })+ test('read --changes marks tracked changes inline', () => {+ const { blocks } = docxRead(Package.open(fixture('sample.docx')), { changes: true })+ const text = blocks[1].text+ assert.match(text, /\{\+ fast \(Ana\)\+\}/)+ assert.match(text, /\{- old \(Ana\)-\}/)+ })+ test('replace works across runs and keeps start formatting', () => {+ const dir = tmp()+ const out = join(dir, 'out.docx')+ const res = cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops',+ JSON.stringify([{ replace: { find: 'north region', with: 'south area' } }]))+ assert.ok(res.ok)+ const { blocks } = docxRead(Package.open(out))+ assert.match(blocks[1].text, /south area/)+ assert.deepEqual(cli('check', out, '--against', fixture('sample.docx')).data.findings, [])+ })+ test('all-or-nothing: a failing op writes nothing', () => {+ const dir = tmp()+ const out = join(dir, 'out.docx')- assert.throws(() => execFileSync(NODE, [CLI, 'docx', 'edit', fixture('sample.docx'), '-o', out, '--ops',- JSON.stringify([{ delete: { paragraphs: ['p1'] } }, { insert: { after: 'p999', text: 'x' } }]), '--json']))- assert.ok(!existsSync(out))++ for (const op of [{ insert: { after: 'p999', text: 'x' } }, { comment: { paragraph: 'p1', text: 'gone' } }]) {++ assert.throws(() => execFileSync(NODE, [CLI, 'docx', 'edit', fixture('sample.docx'), '-o', out, '--ops',++ JSON.stringify([{ delete: { paragraphs: ['p1'] } }, op]), '--json']))++ assert.ok(!existsSync(out))++ }++ })++ test('a batch keeps the original paragraph ids after deletions', () => {++ const dir = tmp()++ const out = join(dir, 'out.docx')++ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops', JSON.stringify([++ { delete: { paragraphs: ['p1'] } },++ { delete: { paragraphs: ['p2'] } },++ ]))++ assert.equal(docxRead(Package.open(out)).blocks.find(b => b.type === 'paragraph').text, 'Second paragraph with a field:')++ })++ test('insertions keep later anchors, style references and comments on the original paragraphs', () => {++ const dir = tmp()++ const out = join(dir, 'out.docx')++ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops', JSON.stringify([++ { insert: { before: 'p1', text: 'Introduction' } },++ { insert: { after: 'p3', text: 'Follow-up', like: 'p1' } },++ { comment: { paragraph: 'p2', text: 'Check the revenue.' } },++ ]))++ const { blocks, comments } = docxRead(Package.open(out))++ const following = blocks.find(b => b.text === 'Follow-up')++ assert.equal(following.style, 'Title')++ assert.equal(blocks[blocks.indexOf(following) - 1].text, 'Second paragraph with a field:')++ const comment = comments.find(c => c.text === 'Check the revenue.')++ assert.equal(blocks.find(b => b.id === comment.anchorsTo).text, 'Revenue grew fast in the north region. moved')+ })+ test('accept and reject changes resolve to expected text', () => {+ const dir = tmp()+ const accepted = join(dir, 'a.docx'), rejected = join(dir, 'r.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', accepted, '--ops', JSON.stringify([{ accept_changes: {} }]))+ cli('docx', 'edit', fixture('sample.docx'), '-o', rejected, '--ops', JSON.stringify([{ reject_changes: {} }]))+ const acc = docxRead(Package.open(accepted)).blocks[1].text+ const rej = docxRead(Package.open(rejected)).blocks[1].text+ assert.equal(acc, 'Revenue grew fast in the north region. moved')+ assert.equal(rej, 'Revenue grew in the north old region.')+ })+ test('set_cell, insert, delete, comment, set_field ops apply', () => {+ const dir = tmp()+ const out = join(dir, 'ops.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops', JSON.stringify([+ { set_cell: { table: 1, row: 2, col: 2, text: '99' } },+ { insert: { after: 'p5', text: 'Added', style: 'Normal' } },+ { delete: { paragraphs: ['p4'] } },+ { comment: { paragraph: 'p2', text: 'Noted', author: 'Bo' } },+ { set_field: { match: 'PAGE', value: '7' } },+ ]))+ const { blocks, comments } = docxRead(Package.open(out))+ assert.equal(blocks.find(b => b.id === 't1').rows[1][1].text, '99')+ assert.ok(comments.some(c => c.author === 'Bo'))+ assert.deepEqual(cli('check', out, '--against', fixture('sample.docx')).data.findings, [])+ })+})++describe('pptx', () => {+ test('inventory resolves boxes incl. inherited placeholder and group transform', () => {+ const inv = pptxInventory(Package.open(fixture('sample.pptx')))+ assert.equal(inv.slideSize.cx, 10)+ const s1 = inv.slides[0]+ assert.equal(s1.layout, 'Title Slide')+ assert.equal(s1.notes, 'Speaker notes for the overview.')+ const title = s1.shapes.find(s => s.name === 'Title 1')+ assert.ok(title.box.w > 0) // box inherited from the layout placeholder+ assert.ok(s1.shapes.some(s => s.kind === 'chart') && s1.shapes.some(s => s.media))+ assert.equal(inv.slides[1].hidden, true)+ })+ test('layout reports overlap; autofit sets normAutofit', () => {+ const dir = tmp()+ const out = join(dir, 'fit.pptx')+ const res = cli('pptx', 'layout', fixture('sample.pptx'), '--autofit', '-o', out, '--json')+ assert.ok(res.data.findings.some(f => f.rule === 'overlap' && f.slide === 3))+ const fitted = pptxLayout(Package.open(out)).findings+ assert.ok(fitted.length > 0) // boxes unchanged; normAutofit flag written+ })+ test('slides reorder, duplicate, remove; check stays clean', () => {+ const dir = tmp()+ const out = join(dir, 'reordered.pptx')+ const res = cli('pptx', 'slides', fixture('sample.pptx'), '-o', out, '--order', '3,1,1')+ assert.deepEqual(res.data.order, [3, 1, 1])+ const inv = pptxInventory(Package.open(out))+ assert.equal(inv.slides.length, 3)+ assert.equal(inv.slides[0].part, 'ppt/slides/slide3.xml')+ assert.equal(checkPackage(Package.open(out)).length, 0)+ })+ test('clean --dry-run lists without removing', () => {+ const res = cli('pptx', 'clean', fixture('sample.pptx'), '--dry-run')+ assert.deepEqual(res.data.removed, [])+ })+})++describe('xlsx', () => {+ test('inventory lists sheets, names, formula counts', () => {+ const inv = xlsxInventory(Package.open(fixture('sample.xlsx')))+ assert.equal(inv.sheets[0].name, 'Sheet1')+ assert.equal(inv.sheets[0].formulas, 3)+ assert.equal(inv.sheets[0].merged, 1)+ assert.ok(inv.definedNames.some(n => n.name === 'Totals'))+ })+ test('read returns cached values, formulas and ISO dates', () => {+ const grid = xlsxRead(Package.open(fixture('sample.xlsx')), 'Sheet1')+ const row2 = grid.rows.find(r => r.row === 2).cells+ assert.equal(row2.D2.v, '2026-10-01')+ assert.equal(row2.C2.f, 'B2*2')+ })+})++describe('png + sheet', () => {+ test('decode/encode round trip', () => {+ const png = { width: 2, height: 2, data: Buffer.from([255, 0, 0, 255, 0, 255, 0, 255, 0, 0, 255, 255, 255, 255, 0, 255]), channels: 4 }+ const decoded = decodePng(encodePng(png))+ assert.equal(decoded.width, 2)+ assert.deepEqual(decoded.data, png.data)+ })+ test('contact sheet dimensions and tiles', () => {+ const imgs = [1, 2, 3].map(() => ({ width: 10, height: 10, data: Buffer.alloc(400, 255) }))+ const sheet = contactSheet(imgs, { cols: 2, width: 10 })+ assert.equal(sheet.width, 20)+ assert.equal(sheet.height, 40)+ })+ test('sheet command writes a contact png', () => {+ const dir = tmp()+ const one = join(dir, '1.png'), two = join(dir, '2.png')+ writeFileSync(one, encodePng({ width: 4, height: 4, data: Buffer.alloc(64, 200), channels: 4 }))+ writeFileSync(two, encodePng({ width: 4, height: 4, data: Buffer.alloc(64, 100), channels: 4 }))+ const res = cli('sheet', dir, '-o', join(dir, 'out.png'), '--cols', '2', '--width', '4')+ const png = decodePng(readFileSync(res.data.file))+ assert.equal(png.width, 8)+ })+})++describe('unpack/pack', () => {+ test('unpack writes pretty XML and pack --against checks the result', () => {+ const dir = tmp()+ const dest = join(dir, 'un')+ cli('unpack', fixture('sample.docx'), dest)+ assert.ok(readFileSync(join(dest, 'word', 'document.xml'), 'utf8').includes('\n'))+ const res = cli('pack', dest, join(dir, 'back.docx'), '--against', fixture('sample.docx'))+ assert.ok(res.ok)+ assert.equal(checkPackage(Package.open(join(dir, 'back.docx'))).length, 0)+ })+ test('unpack reuses an earlier unpack and removes stale files', () => {+ const dir = tmp()+ const dest = join(dir, 'un')+ cli('unpack', fixture('sample.docx'), dest)+ writeFileSync(join(dest, 'stale.xml'), '<x/>')+ cli('unpack', fixture('sample.docx'), dest)+ assert.ok(!existsSync(join(dest, 'stale.xml')))+ })+ test('unpack refuses an existing directory that is not an unpack', () => {+ const dir = tmp()+ writeFileSync(join(dir, 'random.txt'), 'hi')+ assert.throws(() => execFileSync(NODE, [CLI, 'unpack', fixture('sample.docx'), dir, '--json']), /unpack/)+ })+})++describe('paragraph and row marks (review 1)', () => {+ test('accept merges a paragraph with a deleted mark into the next, in order', () => {+ const dir = tmp()+ const out = join(dir, 'merged.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops', JSON.stringify([{ accept_changes: {} }]))+ const { blocks } = docxRead(Package.open(out))+ assert.equal(blocks.length, 6) // p5 merged into the field paragraph+ const merged = blocks.find(b => /Final closing/.test(b.text))+ assert.match(merged.text, /Final closing paragraph\. PAGE/)+ assert.ok(!merged.deletedParagraphMark)+ })+ test('reject drops the deleted paragraph mark and keeps both paragraphs', () => {+ const dir = tmp()+ const out = join(dir, 'rejected.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops', JSON.stringify([{ reject_changes: {} }]))+ const { blocks } = docxRead(Package.open(out))+ assert.ok(blocks.some(b => b.text === 'Final closing paragraph.' && !b.deletedParagraphMark))+ assert.ok(blocks.some(b => / PAGE /.test(b.text)))+ })+})++describe('property change restore (review 2)', () => {+ test('reject restores stored run properties under the run rPr', () => {+ const dir = tmp()+ const out = join(dir, 'rej.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops', JSON.stringify([{ reject_changes: {} }]))+ const doc = Package.open(out).xml('word/document.xml')+ // The "." run carried rPrChange storing a bold rPr: on reject the run+ // becomes bold again, with no change element left.+ const runs = elementsOf(doc.documentElement, 'w:r')+ const dot = runs.find(r => textOf(r) === '.')+ assert.ok(dot, 'no "." run')+ assert.ok(childrenOf(childrenOf(dot, 'w:rPr')[0], 'w:b')[0] !== undefined)+ assert.equal(elementsOf(doc.documentElement, 'w:rPrChange').length, 0)+ })+})++describe('replace edge cases (review 3)', () => {++ test('zero-width regex replacements include paragraph ends and empty paragraphs', () => {++ const runs = '<w:r><w:rPr><w:b/></w:rPr><w:t>ab</w:t></w:r><w:r><w:t>cd</w:t></w:r><w:r><w:t/></w:r>'++ for (const [content, find, expected] of [++ [runs, '$', 'abcd!'],++ [runs, '^|$', '!abcd!'],++ [runs, '(?=cd)|$', 'ab!cd!'],++ [runs, 'd?$', 'abc!!'],++ ['', '^$', '!'],++ ]) {++ const pkg = Package.open(fixture('sample.docx'))++ const doc = pkg.xml('word/document.xml')++ const body = childrenOf(doc.documentElement, 'w:body')[0]++ for (const child of [...body.childNodes]) body.removeChild(child)++ const p = parseXml(`<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">${content}</w:p>`).documentElement++ body.appendChild(doc.importNode(p, true))++ pkg.putXml('word/document.xml', doc)++ docxEdit(pkg, [{ replace: { find, with: '!', regex: true } }])++ assert.equal(docxRead(pkg).blocks[0].text, expected, find)++ }++ })+ test('a→aa terminates (no re-scan of inserted text)', () => {+ const dir = tmp()+ const out = join(dir, 'aa.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops', JSON.stringify([{ replace: { find: 'a', with: 'aa' } }]))+ const { blocks } = docxRead(Package.open(out))+ assert.ok(blocks.some(b => (b.text ?? '').includes('aa')))+ })+ test('regex groups expand ($1), and case-insensitive flags hold', () => {+ const dir = tmp()+ const out = join(dir, 're.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops',+ JSON.stringify([{ replace: { find: '(north) region', with: 'south-$1 area', regex: true } }]))+ assert.match(docxRead(Package.open(out)).blocks[1].text, /south-north area/)+ })+})++describe('comment op (review 4)', () => {+ test('anchor wraps exactly the phrase and passes check', () => {+ const dir = tmp()+ const out = join(dir, 'c.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops',+ JSON.stringify([{ comment: { paragraph: 'p2', text: 'look here', anchor: 'north' } }]))+ const pkg = Package.open(out)+ assert.deepEqual(checkPackage(pkg), [])+ const doc = pkg.xml('word/document.xml')+ const p = elementsOf(doc.documentElement, 'w:p').find(p => textOf(p).includes('south') || textOf(p).includes('north'))+ const start = elementsOf(p, 'w:commentRangeStart')[0]+ assert.ok(start)+ // The range opens right before the run holding the phrase.+ assert.match(textOf(start.nextSibling), /^north$/)+ })+ test('an anchor that is not in the paragraph fails the whole batch', () => {+ const dir = tmp()+ const out = join(dir, 'c2.docx')+ const res = cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops',+ JSON.stringify([{ comment: { paragraph: 'p2', text: 'x', anchor: 'zz-not-there' } }]))+ assert.equal(res.ok, false)+ assert.match(res.error.message, /op 0/)+ assert.ok(!existsSync(out))+ })+})++describe('field and cell edits (review 5, 6)', () => {+ test('set_field rewrites the complex result and touches only document.xml', () => {+ const dir = tmp()+ const out = join(dir, 'f.docx')+ const res = cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops',+ JSON.stringify([{ set_field: { match: 'PAGE', value: '7' } }]))+ assert.deepEqual(res.data.changed, ['word/document.xml'])+ const fields = cli('docx', 'fields', out).data+ assert.ok(fields.some(f => f.instruction.includes('PAGE') && f.result === '7'))+ })+ test('set_cell keeps tcPr, pPr and the run rPr', () => {+ const dir = tmp()+ const out = join(dir, 'cell.docx')+ cli('docx', 'edit', fixture('sample.docx'), '-o', out, '--ops',+ JSON.stringify([{ set_cell: { table: 1, row: 1, col: 1, text: 'New title' } }]))+ const { blocks } = docxRead(Package.open(out))+ assert.equal(blocks.find(b => b.id === 't1').rows[0][0].gridSpan, 2)+ })+})++describe('pptx duplication and clean (review 7, 8)', () => {+ test('duplicated slide gets its Override and the notes slide points back at it', () => {+ const dir = tmp()+ const out = join(dir, 'dup.pptx')+ cli('pptx', 'slides', fixture('sample.pptx'), '-o', out, '--order', '1,1,2,3')+ const pkg = Package.open(out)+ const dup = 'ppt/slides/slide4.xml'+ assert.equal(pkg.contentType(dup), 'application/vnd.openxmlformats-officedocument.presentationml.slide+xml')+ const notesRel = [...pkg.relsOf(dup).values()].find(r => r.type.endsWith('/notesSlide'))+ assert.ok(notesRel, 'duplicated slide kept no notes slide')+ const notes = pkg.targetOf(dup, notesRel.target)+ const back = [...pkg.relsOf(notes).values()].find(r => r.type.endsWith('/slide'))+ assert.equal(pkg.targetOf(notes, back.target), dup)+ assert.deepEqual(checkPackage(pkg), [])+ })+ test('clean drops relationship ids that no XML uses', () => {+ const dir = tmp()+ const broken = join(dir, 'b.pptx')+ const pkg = Package.open(fixture('sample.pptx'))+ const doc = pkg.xml('ppt/slides/slide1.xml')+ const pic = elementsOf(doc.documentElement, 'p:pic')[0]+ pic.parentNode.removeChild(pic)+ pkg.putXml('ppt/slides/slide1.xml', doc)+ writeFileSync(broken, pkg.save())+ const res = cli('pptx', 'clean', broken, '-o', join(dir, 'c.pptx'))+ assert.ok(res.data.removed.some(n => n === 'ppt/media/image1.png'))+ assert.deepEqual(checkPackage(Package.open(res.data.file)), [])+ })+})++describe('check rules (review 10, 11)', () => {+ test('o:id in VML is not a relationship reference', () => {+ const pkg = Package.open(fixture('sample.docx'))+ const doc = pkg.xml('word/document.xml')+ const p = parseXml(`<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office"><w:r><w:pict><v:shape o:id="_x0000_s1" id="x" style="width:10pt;height:10pt"/></w:pict></w:r></w:p>`).documentElement+ doc.documentElement.appendChild(doc.importNode(p, true))+ pkg.putXml('word/document.xml', doc)+ assert.ok(!checkPackage(pkg).some(f => f.rule === 'unknown-rel-ref'))+ })+ test('wrong-content-type reports and --fix sets the Override', () => {+ const pkg = Package.open(fixture('sample.docx'))+ pkg.override('word/styles.xml', 'application/xml')+ const found = checkPackage(pkg)+ assert.ok(found.some(f => f.rule === 'wrong-content-type' && f.part === 'word/styles.xml'))+ const { remaining } = fixPackage(pkg)+ assert.deepEqual(remaining, [])+ assert.equal(pkg.contentType('word/styles.xml'), 'application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml')+ })+})++describe('re-review fixes', () => {+ test('clean keeps a single-quoted r:embed', () => {+ const pkg = Package.open(fixture('sample.pptx'))+ const rel = [...pkg.relsOf('ppt/slides/slide1.xml').values()].find(r => r.type.endsWith('/image'))+ const xml = String(pkg.get('ppt/slides/slide1.xml')).replace(`"${rel.id}"`, `'${rel.id}'`)+ pkg.put('ppt/slides/slide1.xml', xml)+ assert.ok(pptxClean(pkg, { dryRun: true }).removed.every(n => n !== 'ppt/media/image1.png'))+ })+ test('sectPr reject puts header/footer references before restored properties', () => {+ const pkg = Package.open(fixture('sample.docx'))+ const doc = pkg.xml('word/document.xml')+ const sectPr = elementsOf(doc.documentElement, 'w:sectPr')[0]+ const ref = doc.createElement('w:headerReference')+ ref.setAttribute('w:type', 'default')+ sectPr.insertBefore(ref, sectPr.firstChild)+ const change = doc.createElement('w:sectPrChange')+ const stored = doc.createElement('w:sectPr')+ const sz = doc.createElement('w:pgSz')+ sz.setAttribute('w:w', '11906'); sz.setAttribute('w:h', '16838')+ stored.appendChild(sz); change.appendChild(stored)+ sectPr.appendChild(change)+ resolveChanges(doc, false)+ const names = childrenOf(sectPr).map(c => c.tagName)+ assert.equal(names[0], 'w:headerReference')+ assert.ok(names.includes('w:pgSz'))+ assert.ok(!names.includes('w:sectPrChange'))+ })+ test('comment anchor inside a w:hyperlink wraps the phrase', () => {+ const pkg = Package.open(fixture('sample.docx'))+ const doc = pkg.xml('word/document.xml')+ const p = parseXml(`<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:hyperlink w:history="1" w:anchor="top"><w:r><w:t xml:space="preserve">click here text</w:t></w:r></w:hyperlink></w:p>`).documentElement+ childrenOf(doc.documentElement, 'w:body')[0].appendChild(doc.importNode(p, true))+ pkg.putXml('word/document.xml', doc)+ const dir = tmp(), out = join(dir, 'hl.docx')+ writeFileSync(join(dir, 'hl-src.docx'), pkg.save())+ cli('docx', 'edit', join(dir, 'hl-src.docx'), '-o', out, '--ops',+ JSON.stringify([{ comment: { paragraph: 'p7', text: 'hi', anchor: 'here' } }]))+ const read = docxRead(Package.open(out))+ assert.ok(read.comments.some(c => c.text === 'hi' && c.anchorsTo === 'p7'))+ assert.deepEqual(checkPackage(Package.open(out)), [])+ })+})++describe('re-review pass 2', () => {+ test('zip slip: unsafe member names are refused on open', () => {+ for (const name of ['../evil.xml', 'word/../../x.xml', '/abs/x.xml', 'C:/win/x.xml', 'word\\..\\x.xml']) {+ const buf = writeZip([{ name, data: Buffer.from('x') }])+ const file = join(tmp(), 'z.docx')+ writeFileSync(file, buf)+ assert.throws(() => Package.open(file), /unsafe member name/)+ }+ })+ test('zip bomb: inflate stops at the declared size', () => {+ const buf = writeZip([{ name: 'x.xml', data: Buffer.alloc(5000, 65) }])+ buf.writeUInt32LE(10, 22) // lie: declared usize 10, real 5000+ const cdOff = buf.readUInt32LE(buf.length - 22 + 16)+ buf.writeUInt32LE(10, cdOff + 24)+ assert.throws(() => readZip(buf), /past its declared size/)+ })+ test('replace: several matches in one run, adjacent and spanning', () => {+ const pkg = Package.open(fixture('sample.docx'))+ const doc = pkg.xml('word/document.xml')+ const body = childrenOf(doc.documentElement, 'w:body')[0]+ const addP = (runs) => {+ const p = parseXml(`<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">${runs.map(r => `<w:r><w:t xml:space="preserve">${r}</w:t></w:r>`).join('')}</w:p>`).documentElement+ body.appendChild(doc.importNode(p, true))+ }+ addP(['cat cat'])+ addP(['x x x'])+ addP(['catcat'])+ addP(['ca', 't c', 'at'])+ pkg.putXml('word/document.xml', doc)+ docxEdit(pkg, [{ replace: { find: 'cat', with: 'dog' } }, { replace: { find: 'x', with: 'y' } }])+ const { blocks } = docxRead(pkg)+ const texts = blocks.slice(-4).map(b => b.text)+ assert.equal(texts[0], 'dog dog')+ assert.equal(texts[1], 'y y y')+ assert.equal(texts[2], 'dogdog')+ assert.equal(texts[3], 'dog dog')+ })+ test('replace and comment keep run rPr', () => {+ const pkg = Package.open(fixture('sample.docx'))+ const doc = pkg.xml('word/document.xml')+ const body = childrenOf(doc.documentElement, 'w:body')[0]+ body.appendChild(doc.importNode(parseXml(`<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:r><w:rPr><w:b/></w:rPr><w:t>bold bold</w:t></w:r></w:p>`).documentElement, true))+ pkg.putXml('word/document.xml', doc)+ docxEdit(pkg, [{ replace: { find: 'bold', with: 'strong' } }])+ const fresh = pkg.xml('word/document.xml')+ const strongs = elementsOf(fresh.documentElement, 'w:r').filter(r => elementsOf(r, 'w:t').some(t => t.textContent === 'strong'))+ assert.equal(strongs.length, 2)+ assert.ok(strongs.every(r => childrenOf(childrenOf(r, 'w:rPr')[0], 'w:b')[0] !== undefined))+ })+ test('comment anchors: mid-run, run edges, spanning, hyperlink', () => {+ const mkPkg = (runs) => {+ const pkg = Package.open(fixture('sample.docx'))+ const doc = pkg.xml('word/document.xml')+ const body = childrenOf(doc.documentElement, 'w:body')[0]+ body.appendChild(doc.importNode(parseXml(`<w:p xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">${runs}</w:p>`).documentElement, true))+ pkg.putXml('word/document.xml', doc)+ return pkg+ }+ const anchorOk = (pkg, pId, anchor) => {+ docxEdit(pkg, [{ comment: { paragraph: pId, text: 'c', anchor } }])+ const doc = pkg.xml('word/document.xml')+ const p = elementsOf(doc.documentElement, 'w:p').at(-1)+ const order = []+ for (const el of elementsOf(p)) {+ if (el.tagName === 'w:commentRangeStart') order.push('S')+ if (el.tagName === 'w:commentRangeEnd') order.push('E')+ if (el.tagName === 'w:commentReference') order.push('R')+ }+ assert.ok(order.indexOf('S') < order.indexOf('E'), `${anchor}: ${order}`)+ assert.ok(order.indexOf('E') < order.indexOf('R'))+ }+ anchorOk(mkPkg('<w:r><w:t xml:space="preserve">aa bb cc</w:t></w:r>'), 'p7', 'bb')+ anchorOk(mkPkg('<w:r><w:t xml:space="preserve">aa bb cc</w:t></w:r>'), 'p7', 'aa')+ anchorOk(mkPkg('<w:r><w:t xml:space="preserve">aa bb cc</w:t></w:r>'), 'p7', 'cc')+ anchorOk(mkPkg('<w:r><w:t>ab</w:t></w:r><w:r><w:t>cd</w:t></w:r>'), 'p7', 'bc')+ anchorOk(mkPkg('<w:hyperlink w:anchor="t"><w:r><w:t>click here</w:t></w:r></w:hyperlink>'), 'p7', 'here')+ })+ test('check --fix on an unpacked dir flushes the model to disk', () => {+ const dir = join(tmp(), 'un')+ cli('unpack', fixture('sample.docx'), dir)+ const pkg = Package.loadDir(dir)+ pkg.override('word/styles.xml', 'application/xml')+ pkg.relsOf('word/document.xml').set('rId99', { id: 'rId99', type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/header', target: 'missing.xml', mode: 'Internal' })+ pkg.unpack(dir)+ const res = cli('check', dir, '--fix', '--in-place')+ assert.equal(res.ok, true)+ assert.deepEqual(res.data.findings, [])+ assert.deepEqual(checkPackage(Package.loadDir(dir)), [])+ assert.ok(!readFileSync(join(dir, 'word/_rels/document.xml.rels'), 'utf8').includes('rId99'))+ })+ test('check --fix on a file no longer reports the dangling rel it fixed', () => {+ const dir = tmp()+ const bad = join(dir, 'b.docx')+ const pkg = Package.open(fixture('sample.docx'))+ pkg.relsOf('word/document.xml').set('rId99', { id: 'rId99', type: 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/header', target: 'missing.xml', mode: 'Internal' })+ writeFileSync(bad, pkg.save())+ const res = cli('check', bad, '--fix', '-o', join(dir, 'fixed.docx'))+ assert.equal(res.ok, true)+ assert.deepEqual(res.data.findings, [])+ assert.deepEqual(checkPackage(Package.open(join(dir, 'fixed.docx'))), [])+ })+ test('pptx clean works on docx and xlsx', () => {+ const dir = tmp()+ for (const ext of ['docx', 'xlsx']) {+ const res = cli('pptx', 'clean', fixture(`sample.${ext}`), '-o', join(dir, `c.${ext}`))+ assert.equal(res.ok, true, JSON.stringify(res))+ }+ })+ test('duplicated slides never overwrite a live rel id', () => {+ const pkg = Package.open(fixture('sample.pptx'))+ const pres = pkg.xml('ppt/presentation.xml')+ const lst = childrenOf(pres.documentElement, 'p:sldIdLst')[0]+ const entries = childrenOf(lst, 'p:sldId')+ const removedRid = entries[1].getAttribute('r:id')+ lst.removeChild(entries[1]) // gap in the rel ids+ pkg.rels.get('ppt/presentation.xml').delete(removedRid)+ pkg.putXml('ppt/presentation.xml', pres)+ pptxSlides(pkg, [1, 1, 2])+ const after = pkg.xml('ppt/presentation.xml')+ const rids = childrenOf(childrenOf(after.documentElement, 'p:sldIdLst')[0], 'p:sldId').map(e => e.getAttribute('r:id'))+ assert.equal(new Set(rids).size, rids.length)+ for (const rid of rids) {+ const rel = pkg.rels.get('ppt/presentation.xml').get(rid)+ assert.ok(rel && pkg.parts.has(pkg.targetOf('ppt/presentation.xml', rel.target)), `${rid} unresolved`)+ }+ assert.equal(rids.length, 3)+ })+ test('docx read shows comments on their anchored block', () => {+ const { blocks, comments } = docxRead(Package.open(fixture('sample.docx')))+ const p3 = blocks.find(b => b.id === 'p3') // the fixture comment anchors to p3+ assert.ok(comments.length > 0)+ assert.ok(p3.comments?.length > 0)+ })+ test('xlsx dates honour date1904', () => {+ const read = (pkg) => xlsxRead(pkg, 'Sheet1').rows.flatMap(r => Object.values(r.cells).map(c => c.v)).find(v => /^\d{4}-\d{2}-\d{2}/.test(String(v)))+ const normal = read(Package.open(fixture('sample.xlsx')))+ const pkg = Package.open(fixture('sample.xlsx'))+ const wb = pkg.xml('xl/workbook.xml')+ let pr = childrenOf(wb.documentElement, 'workbookPr')[0]+ if (!pr) { pr = wb.createElement('workbookPr'); wb.documentElement.appendChild(pr) }+ pr.setAttribute('date1904', '1')+ pkg.putXml('xl/workbook.xml', wb)+ const shifted = read(pkg)+ assert.notEqual(shifted, normal)+ assert.ok(Date.parse(shifted) > Date.parse(normal))+ })+ test('layout flags a picture past the slide edge', () => {+ const pkg = Package.open(fixture('sample.pptx'))+ const doc = pkg.xml('ppt/slides/slide1.xml')+ const pic = elementsOf(doc.documentElement, 'p:pic')[0]+ const off = elementsOf(pic, 'a:off')[0]+ off.setAttribute('x', String(9144000)) // one inch past a 10in slide+ pkg.putXml('ppt/slides/slide1.xml', doc)+ const { findings } = pptxLayout(pkg)+ assert.ok(findings.some(f => f.rule === 'off-slide' && /picture|pic/i.test(f.shape ?? '')))+ })+})++describe('re-review pass 3', () => {+ test('malformed .rels survives unpack and save byte-identical, check still reports it', () => {+ const dir = tmp()+ const members = readZip(readFileSync(fixture('sample.docx')))+ const garbage = Buffer.from('<Relationships><broken')+ for (const m of members) if (m.name === 'word/_rels/document.xml.rels') { delete m.raw; m.data = garbage }+ const file = join(dir, 'bad.docx')+ writeFileSync(file, writeZip(members))+ const pkg = Package.open(file)+ const out = join(dir, 'un')+ pkg.unpack(out)+ assert.equal(readFileSync(join(out, 'word/_rels/document.xml.rels')).toString(), garbage.toString())+ const saved = readZip(pkg.save()).find(m => m.name === 'word/_rels/document.xml.rels')+ assert.deepEqual(saved.data, garbage)+ assert.ok(checkPackage(pkg).length > 0)+ })+ test('a valid-but-empty .rels keeps its bytes; a model-emptied map still deletes it', () => {+ const dir = tmp()+ const members = readZip(readFileSync(fixture('sample.docx')))+ const empty = Buffer.from('<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"/>')+ for (const m of members) if (m.name === 'word/_rels/document.xml.rels') { delete m.raw; m.data = empty }+ const file = join(dir, 'e.docx')+ writeFileSync(file, writeZip(members))+ const pkg = Package.open(file)+ const out = join(dir, 'un')+ pkg.unpack(out)+ assert.equal(readFileSync(join(out, 'word/_rels/document.xml.rels')).toString(), empty.toString())+ const full = Package.open(fixture('sample.docx'))+ full.rels.get('word/document.xml').clear()+ const names = readZip(full.save()).map(m => m.name)+ assert.ok(!names.includes('word/_rels/document.xml.rels'))+ })+ test('xlsx dates honour date1904="true" too', () => {+ const pkg = Package.open(fixture('sample.xlsx'))+ const wb = pkg.xml('xl/workbook.xml')+ const pr = childrenOf(wb.documentElement, 'workbookPr')[0] ?? wb.documentElement.appendChild(wb.createElement('workbookPr'))+ pr.setAttribute('date1904', 'true')+ pkg.putXml('xl/workbook.xml', wb)+ const v = xlsxRead(pkg, 'Sheet1').rows.flatMap(r => Object.values(r.cells).map(c => c.v)).find(v => /^\d{4}-/.test(String(v)))+ const normal = xlsxRead(Package.open(fixture('sample.xlsx')), 'Sheet1').rows.flatMap(r => Object.values(r.cells).map(c => c.v)).find(v => /^\d{4}-/.test(String(v)))+ assert.ok(Date.parse(v) > Date.parse(normal))+ })+ test('a deflated member declaring 0 bytes but carrying data fails; a real empty member opens', () => {+ const buf = writeZip([{ name: 'x.xml', data: Buffer.alloc(64, 66) }])+ buf.writeUInt32LE(0, 22) // lie: declares 0 uncompressed bytes+ const cdOff = buf.readUInt32LE(buf.length - 22 + 16)+ buf.writeUInt32LE(0, cdOff + 24)+ assert.throws(() => readZip(buf))+ const ok = readZip(writeZip([{ name: 'e.xml', data: Buffer.alloc(0) }]))+ assert.equal(ok[0].data.length, 0)+ })+ test('unpack refuses a linked subdirectory inside the destination', () => {+ const dir = join(tmp(), 'un')+ cli('unpack', fixture('sample.docx'), dir)+ const outside = join(tmp(), 'real')+ mkdirSync(outside, { recursive: true })+ writeFileSync(join(outside, 'keep.txt'), 'x')+ rmSync(join(dir, 'word'), { recursive: true })+ symlinkSync(outside, join(dir, 'word'), 'junction')+ assert.throws(() => execFileSync(NODE, [CLI, 'unpack', fixture('sample.docx'), dir, '--json']))+ assert.ok(!existsSync(join(outside, 'document.xml')))+ })+ test('unpack refuses a symlinked file inside the destination', (t) => {+ const dir = join(tmp(), 'un')+ cli('unpack', fixture('sample.docx'), dir)+ const outside = join(tmp(), 'out.xml')+ writeFileSync(outside, '<x/>')+ rmSync(join(dir, 'word/document.xml'))+ try { symlinkSync(outside, join(dir, 'word/document.xml')) }+ catch (err) { if (err.code === 'EPERM') { t.skip('no symlink privilege'); return } throw err }+ assert.throws(() => execFileSync(NODE, [CLI, 'unpack', fixture('sample.docx'), dir, '--json']))+ assert.ok(!readFileSync(outside, 'utf8').includes('w:document'))+ })+})++describe('JSON findings shape (review 14)', () => {+ test('findings come back ok:true with exit 1', () => {+ const dir = tmp()+ const pkg = Package.open(fixture('sample.docx'))+ pkg.override('word/styles.xml', 'application/xml')+ const file = join(dir, 'bad.docx')+ writeFileSync(file, pkg.save())+ const res = cli('check', file)+ assert.equal(res.ok, true)+ assert.ok(res.data.findings.some(f => f.rule === 'wrong-content-type'))+ let status = 0+ try { execFileSync(NODE, [CLI, 'check', file, '--json']) } catch (e) { status = e.status }+ assert.equal(status, 1)+ })+})++describe('flush keeps untouched members (review 16)', () => {+ test('a document.xml-only edit preserves every other member byte', () => {+ const src = fixture('sample.docx')+ const pkg = Package.open(src)+ const before = readZip(readFileSync(src))+ docxEdit(pkg, [{ set_cell: { table: 1, row: 2, col: 2, text: '99' } }])+ const after = readZip(pkg.save())+ const changed = after.filter(m => {+ const old = before.find(b => b.name === m.name)+ return !old || !old.raw.equals(m.raw)+ }).map(m => m.name)+ assert.deepEqual(changed.sort(), ['word/document.xml'])+ })+})