ds-bot-sansheng/office.js

8909 lines
311 KiB
JavaScript
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/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 = "<22>";
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 == "<" && "&lt;" || c == ">" && "&gt;" || c == "&" && "&amp;" || c == '"' && "&quot;" || "&#" + 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 RUN_MARKS = { "w:tab": " ", "w:br": "\n", "w:cr": "\n" };
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 (tag in RUN_MARKS) {
if (node.parentNode?.tagName === "w:r") out += RUN_MARKS[tag];
return;
}
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, 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, 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 = 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 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(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) {
for (const id of op.delete.paragraphs) {
const el = blockOf(id);
el.parentNode.removeChild(el);
}
changed.add("word/document.xml");
return;
}
if (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")) {
let joined = "";
const spans = [];
for (const node of elementsOf(p)) {
if (node.parentNode?.tagName !== "w:r" || nearestPara(node) !== p || isDeleted(p, node)) continue;
const value = node.tagName === "w:t" ? node.textContent : RUN_MARKS[node.tagName];
if (value === void 0) continue;
const start = joined.length;
joined += value;
spans.push({ node, start, end: joined.length });
}
const matches = [...joined.matchAll(global)];
if (matches.length === 0) continue;
if (spans.length === 0) {
const run = doc.createElement("w:r");
const node = doc.createElement("w:t");
run.appendChild(node);
p.appendChild(run);
spans.push({ node, start: 0, end: 0 });
}
if (spans.at(-1).node.tagName !== "w:t") {
const last = spans.at(-1).node;
const node = doc.createElement("w:t");
last.parentNode.insertBefore(node, last.nextSibling);
spans.push({ node, start: joined.length, end: joined.length });
}
for (const match of matches.reverse()) {
const start = match.index, end = start + match[0].length;
const first = spans.find((span) => span.end > start) ?? spans.at(-1);
for (const span of spans) {
if (span !== first && (span.end <= start || span.start >= end)) continue;
const { node } = span;
const replacement = span === first ? expand(match, withText) : "";
if (node.tagName === "w:t") {
const before = node.textContent.slice(0, Math.max(0, start - span.start));
const after = node.textContent.slice(Math.max(0, end - span.start));
node.textContent = before + replacement + after;
if (node.textContent !== node.textContent.trim()) node.setAttribute("xml:space", "preserve");
} else {
const text = doc.createElement("w:t");
text.setAttribute("xml:space", "preserve");
text.textContent = replacement;
node.parentNode.insertBefore(text, node);
if (end > span.start) node.parentNode.removeChild(node);
}
}
total++;
}
}
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, blockOf, changed, { paragraph, text, anchor, author = "Bot", initials = "B" }) {
const doc = getDoc("word/document.xml");
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) => sp.tagName === "p:graphicFrame" ? child(sp, "p:xfrm") : 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]);
function dateLike(code, value) {
const sections = (code ?? "").replace(/"[^"]*"|\\.|_.|\*./g, "").split(";").slice(0, 3);
const condition = (part) => /\[(<=|>=|<>|=|<|>)(-?\d+(?:\.\d+)?)\]/.exec(part);
let section;
if (sections.some(condition)) {
section = sections.find((part) => {
const test = condition(part);
if (!test) return true;
const n = Number(test[2]);
return { "<": value < n, ">": value > n, "<=": value <= n, ">=": value >= n, "=": value === n, "<>": value !== n }[test[1]];
}) ?? "";
} else section = sections[value < 0 && sections.length > 1 ? 1 : value === 0 && sections.length > 2 ? 2 : 0];
return /[ymdhs]/i.test(section.replace(/\[(?![hms]+\])[^\]]*\]/gi, ""));
}
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) ? "date" : custom.get(id));
}
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" || dateLike(fmt.get(Number(c.getAttribute("s") ?? 0)), Number(value))) && !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)));