@7niao/doc-previewer 0.0.0-stage → 0.1.1

package/dist/assets/DocxRenderer-6BCR0R9L.js

@@ -0,0 +1,3173 @@
+import { i as e } from "./rolldown-runtime-CwxnZyOB.js";
+import { t } from "./jszip.min-OjSHaKmg.js";
+import { t as n } from "./_plugin-vue_export-helper-Djzt4Yr7.js";
+import { createElementBlock as r, createElementVNode as i, defineComponent as a, onBeforeUnmount as o, onMounted as s, openBlock as c, ref as l } from "vue";
+// node_modules/.pnpm/docx-preview@0.4.1/node_modules/docx-preview/dist/docx-preview.mjs
+var u = /* @__PURE__ */ e(t(), 1), d;
+(function(e) {
+	e.OfficeDocument = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument", e.FontTable = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable", e.Image = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", e.Numbering = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering", e.Styles = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles", e.StylesWithEffects = "http://schemas.microsoft.com/office/2007/relationships/stylesWithEffects", e.Theme = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme", e.Settings = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings", e.WebSettings = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings", e.Hyperlink = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", e.Footnotes = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes", e.Endnotes = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes", e.Footer = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", e.Header = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", e.ExtendedProperties = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties", e.CoreProperties = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties", e.CustomProperties = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/custom-properties", e.Comments = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments", e.CommentsExtended = "http://schemas.microsoft.com/office/2011/relationships/commentsExtended", e.AltChunk = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/aFChunk";
+})(d ||= {});
+function f(e, t) {
+	return t.elements(e).map((e) => ({
+		id: t.attr(e, "Id"),
+		type: t.attr(e, "Type"),
+		target: t.attr(e, "Target"),
+		targetMode: t.attr(e, "TargetMode")
+	}));
+}
+function p(e) {
+	return e?.replace(/[ .]+/g, "-").replace(/[&]+/g, "and").toLowerCase();
+}
+function m(e) {
+	return /^[^"'].*\s.*[^"']$/.test(e) ? `'${e}'` : e;
+}
+function h(e) {
+	let t = e.lastIndexOf("/") + 1;
+	return [t == 0 ? "" : e.substring(0, t), t == 0 ? e : e.substring(t)];
+}
+function g(e, t) {
+	try {
+		return new URL(e, "http://docx/" + t).toString().substring(12);
+	} catch {
+		return `${t}${e}`;
+	}
+}
+function _(e, t) {
+	return e.reduce((e, n) => (e[t(n)] = n, e), {});
+}
+function ee(e) {
+	return new Promise((t, n) => {
+		let r = new FileReader();
+		r.onloadend = () => t(r.result), r.onerror = () => n(), r.readAsDataURL(e);
+	});
+}
+function v(e) {
+	return e && typeof e == "object" && !Array.isArray(e);
+}
+function y(e) {
+	return typeof e == "string" || e instanceof String;
+}
+function b(e, ...t) {
+	if (!t.length) return e;
+	let n = t.shift();
+	if (v(e) && v(n)) for (let t in n) v(n[t]) ? b(e[t] ?? (e[t] = {}), n[t]) : e[t] = n[t];
+	return b(e, ...t);
+}
+function x(e) {
+	return Array.isArray(e) ? e : [e];
+}
+function te(e, t, n) {
+	return t > e ? t : n < e ? n : e;
+}
+var S = { wordml: "http://schemas.openxmlformats.org/wordprocessingml/2006/main" }, C = {
+	Dxa: {
+		mul: .05,
+		unit: "pt"
+	},
+	Emu: {
+		mul: 1 / 12700,
+		unit: "pt"
+	},
+	FontSize: {
+		mul: .5,
+		unit: "pt"
+	},
+	Border: {
+		mul: .125,
+		unit: "pt",
+		min: .25,
+		max: 12
+	},
+	Point: {
+		mul: 1,
+		unit: "pt"
+	},
+	Percent: {
+		mul: .02,
+		unit: "%"
+	}
+};
+function w(e, t = C.Dxa) {
+	if (e == null || /.+(p[xt]|[%])$/.test(e)) return e;
+	var n = parseInt(e) * t.mul;
+	return t.min && t.max && (n = te(n, t.min, t.max)), `${n.toFixed(2)}${t.unit}`;
+}
+function ne(e, t = !1) {
+	switch (e) {
+		case "1": return !0;
+		case "0": return !1;
+		case "on": return !0;
+		case "off": return !1;
+		case "true": return !0;
+		case "false": return !1;
+		default: return t;
+	}
+}
+function T(e, t, n) {
+	if (e.namespaceURI != S.wordml) return !1;
+	switch (e.localName) {
+		case "color":
+			t.color = n.attr(e, "val");
+			break;
+		case "sz":
+			t.fontSize = n.lengthAttr(e, "val", C.FontSize);
+			break;
+		default: return !1;
+	}
+	return !0;
+}
+function re(e, t = !1) {
+	t && (e = e.replace(/<[?].*[?]>/, "")), e = ae(e);
+	let n = new DOMParser().parseFromString(e, "application/xml"), r = ie(n);
+	if (r) throw Error(r);
+	return n;
+}
+function ie(e) {
+	return e.getElementsByTagName("parsererror")[0]?.textContent;
+}
+function ae(e) {
+	return e.charCodeAt(0) === 65279 ? e.substring(1) : e;
+}
+function oe(e) {
+	return new XMLSerializer().serializeToString(e);
+}
+var E = class {
+	elements(e, t = null) {
+		let n = [];
+		for (let r = 0, i = e.childNodes.length; r < i; r++) {
+			let i = e.childNodes.item(r);
+			i.nodeType == Node.ELEMENT_NODE && (t == null || i.localName == t) && n.push(i);
+		}
+		return n;
+	}
+	element(e, t) {
+		for (let n = 0, r = e.childNodes.length; n < r; n++) {
+			let r = e.childNodes.item(n);
+			if (r.nodeType == 1 && r.localName == t) return r;
+		}
+		return null;
+	}
+	elementAttr(e, t, n) {
+		var r = this.element(e, t);
+		return r ? this.attr(r, n) : void 0;
+	}
+	attrs(e) {
+		return Array.from(e.attributes);
+	}
+	attr(e, t) {
+		for (let n = 0, r = e.attributes.length; n < r; n++) {
+			let r = e.attributes.item(n);
+			if (r.localName == t) return r.value;
+		}
+		return null;
+	}
+	intAttr(e, t, n = null) {
+		var r = this.attr(e, t);
+		return r ? parseInt(r) : n;
+	}
+	hexAttr(e, t, n = null) {
+		var r = this.attr(e, t);
+		return r ? parseInt(r, 16) : n;
+	}
+	floatAttr(e, t, n = null) {
+		var r = this.attr(e, t);
+		return r ? parseFloat(r) : n;
+	}
+	boolAttr(e, t, n = null) {
+		return ne(this.attr(e, t), n);
+	}
+	lengthAttr(e, t, n = C.Dxa) {
+		return w(this.attr(e, t), n);
+	}
+}, D = new E(), O = class {
+	constructor(e, t) {
+		this._package = e, this.path = t;
+	}
+	async load() {
+		this.rels = await this._package.loadRelationships(this.path);
+		let e = await this._package.load(this.path), t = this._package.parseXmlDocument(e);
+		this._package.options.keepOrigin && (this._xmlDocument = t), this.parseXml(t.firstElementChild);
+	}
+	save() {
+		this._package.update(this.path, oe(this._xmlDocument));
+	}
+	parseXml(e) {}
+}, se = {
+	embedRegular: "regular",
+	embedBold: "bold",
+	embedItalic: "italic",
+	embedBoldItalic: "boldItalic"
+};
+function ce(e, t) {
+	return t.elements(e).map((e) => le(e, t));
+}
+function le(e, t) {
+	let n = {
+		name: t.attr(e, "name"),
+		embedFontRefs: []
+	};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "family":
+			n.family = t.attr(r, "val");
+			break;
+		case "altName":
+			n.altName = t.attr(r, "val");
+			break;
+		case "embedRegular":
+		case "embedBold":
+		case "embedItalic":
+		case "embedBoldItalic": n.embedFontRefs.push(ue(r, t));
+	}
+	return n;
+}
+function ue(e, t) {
+	return {
+		id: t.attr(e, "id"),
+		key: t.attr(e, "fontKey"),
+		type: se[e.localName]
+	};
+}
+var de = class extends O {
+	parseXml(e) {
+		this.fonts = ce(e, this._package.xmlParser);
+	}
+};
+function fe(e, t) {
+	return t.elements(e).map((e) => ({
+		extension: t.attr(e, "Extension"),
+		partName: t.attr(e, "PartName"),
+		contentType: t.attr(e, "ContentType")
+	}));
+}
+var pe = class e {
+	constructor(e, t) {
+		this._zip = e, this.options = t, this.xmlParser = new E();
+	}
+	get(e) {
+		let t = me(e);
+		return this._zip.files[t] ?? this._zip.files[t.replace(/\//g, "\\")];
+	}
+	update(e, t) {
+		this._zip.file(e, t);
+	}
+	static async load(t, n) {
+		let r = await u.default.loadAsync(t);
+		return new e(r, n);
+	}
+	save(e = "blob") {
+		return this._zip.generateAsync({ type: e });
+	}
+	load(e, t = "string") {
+		return this.get(e)?.async(t) ?? Promise.resolve(null);
+	}
+	async loadRelationships(e = null) {
+		let t = "_rels/.rels";
+		if (e != null) {
+			let [n, r] = h(e);
+			t = `${n}_rels/${r}.rels`;
+		}
+		let n = await this.load(t);
+		return n ? f(this.parseXmlDocument(n).firstElementChild, this.xmlParser) : null;
+	}
+	async loadContentTypes() {
+		let e = await this.load("[Content_Types].xml");
+		return e ? fe(this.parseXmlDocument(e).firstElementChild, this.xmlParser) : [];
+	}
+	parseXmlDocument(e) {
+		return re(e, this.options.trimXmlDeclaration);
+	}
+};
+function me(e) {
+	return e.startsWith("/") ? e.substr(1) : e;
+}
+var he = class extends O {
+	constructor(e, t, n) {
+		super(e, t), this._documentParser = n;
+	}
+	parseXml(e) {
+		this.body = this._documentParser.parseDocumentFile(e);
+	}
+};
+function k(e, t) {
+	return {
+		type: t.attr(e, "val"),
+		color: t.attr(e, "color"),
+		size: t.lengthAttr(e, "sz", C.Border),
+		offset: t.lengthAttr(e, "space", C.Point),
+		frame: t.boolAttr(e, "frame"),
+		shadow: t.boolAttr(e, "shadow")
+	};
+}
+function ge(e, t) {
+	var n = {};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "left":
+			n.left = k(r, t);
+			break;
+		case "top":
+			n.top = k(r, t);
+			break;
+		case "right":
+			n.right = k(r, t);
+			break;
+		case "bottom": n.bottom = k(r, t);
+	}
+	return n;
+}
+var _e;
+(function(e) {
+	e.Continuous = "continuous", e.NextPage = "nextPage", e.NextColumn = "nextColumn", e.EvenPage = "evenPage", e.OddPage = "oddPage";
+})(_e ||= {});
+function A(e, t = D) {
+	var n = {};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "pgSz":
+			n.pageSize = {
+				width: t.lengthAttr(r, "w"),
+				height: t.lengthAttr(r, "h"),
+				orientation: t.attr(r, "orient")
+			};
+			break;
+		case "type":
+			n.type = t.attr(r, "val");
+			break;
+		case "pgMar":
+			n.pageMargins = {
+				left: t.lengthAttr(r, "left"),
+				right: t.lengthAttr(r, "right"),
+				top: t.lengthAttr(r, "top"),
+				bottom: t.lengthAttr(r, "bottom"),
+				header: t.lengthAttr(r, "header"),
+				footer: t.lengthAttr(r, "footer"),
+				gutter: t.lengthAttr(r, "gutter")
+			};
+			break;
+		case "cols":
+			n.columns = ve(r, t);
+			break;
+		case "headerReference":
+			(n.headerRefs ??= []).push(j(r, t));
+			break;
+		case "footerReference":
+			(n.footerRefs ??= []).push(j(r, t));
+			break;
+		case "titlePg":
+			n.titlePage = t.boolAttr(r, "val", !0);
+			break;
+		case "pgBorders":
+			n.pageBorders = ge(r, t);
+			break;
+		case "pgNumType": n.pageNumber = ye(r, t);
+	}
+	return n;
+}
+function ve(e, t) {
+	return {
+		numberOfColumns: t.intAttr(e, "num"),
+		space: t.lengthAttr(e, "space"),
+		separator: t.boolAttr(e, "sep"),
+		equalWidth: t.boolAttr(e, "equalWidth", !0),
+		columns: t.elements(e, "col").map((e) => ({
+			width: t.lengthAttr(e, "w"),
+			space: t.lengthAttr(e, "space")
+		}))
+	};
+}
+function ye(e, t) {
+	return {
+		chapSep: t.attr(e, "chapSep"),
+		chapStyle: t.attr(e, "chapStyle"),
+		format: t.attr(e, "fmt"),
+		start: t.intAttr(e, "start")
+	};
+}
+function j(e, t) {
+	return {
+		id: t.attr(e, "id"),
+		type: t.attr(e, "type")
+	};
+}
+function be(e, t) {
+	return {
+		before: t.lengthAttr(e, "before"),
+		after: t.lengthAttr(e, "after"),
+		line: t.intAttr(e, "line"),
+		lineRule: t.attr(e, "lineRule")
+	};
+}
+function M(e, t) {
+	let n = {};
+	for (let r of t.elements(e)) xe(r, n, t);
+	return n;
+}
+function xe(e, t, n) {
+	return !!T(e, t, n);
+}
+function N(e, t) {
+	let n = {};
+	for (let r of t.elements(e)) P(r, n, t);
+	return n;
+}
+function P(e, t, n) {
+	if (e.namespaceURI != S.wordml) return !1;
+	if (T(e, t, n)) return !0;
+	switch (e.localName) {
+		case "tabs":
+			t.tabs = Se(e, n);
+			break;
+		case "sectPr":
+			t.sectionProps = A(e, n);
+			break;
+		case "numPr":
+			t.numbering = Ce(e, n);
+			break;
+		case "spacing": return t.lineSpacing = be(e, n), !1;
+		case "textAlignment": return t.textAlignment = n.attr(e, "val"), !1;
+		case "keepLines":
+			t.keepLines = n.boolAttr(e, "val", !0);
+			break;
+		case "keepNext":
+			t.keepNext = n.boolAttr(e, "val", !0);
+			break;
+		case "pageBreakBefore":
+			t.pageBreakBefore = n.boolAttr(e, "val", !0);
+			break;
+		case "outlineLvl":
+			t.outlineLevel = n.intAttr(e, "val");
+			break;
+		case "pStyle":
+			t.styleName = n.attr(e, "val");
+			break;
+		case "rPr":
+			t.runProps = M(e, n);
+			break;
+		default: return !1;
+	}
+	return !0;
+}
+function Se(e, t) {
+	return t.elements(e, "tab").map((e) => ({
+		position: t.lengthAttr(e, "pos"),
+		leader: t.attr(e, "leader"),
+		style: t.attr(e, "val")
+	}));
+}
+function Ce(e, t) {
+	var n = {};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "numId":
+			n.id = t.attr(r, "val");
+			break;
+		case "ilvl": n.level = t.intAttr(r, "val");
+	}
+	return n;
+}
+function we(e, t) {
+	let n = {
+		numberings: [],
+		abstractNumberings: [],
+		bulletPictures: []
+	};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "num":
+			n.numberings.push(Te(r, t));
+			break;
+		case "abstractNum":
+			n.abstractNumberings.push(Ee(r, t));
+			break;
+		case "numPicBullet": n.bulletPictures.push(Oe(r, t));
+	}
+	return n;
+}
+function Te(e, t) {
+	let n = {
+		id: t.attr(e, "numId"),
+		overrides: []
+	};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "abstractNumId":
+			n.abstractId = t.attr(r, "val");
+			break;
+		case "lvlOverride": n.overrides.push(De(r, t));
+	}
+	return n;
+}
+function Ee(e, t) {
+	let n = {
+		id: t.attr(e, "abstractNumId"),
+		levels: []
+	};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "name":
+			n.name = t.attr(r, "val");
+			break;
+		case "multiLevelType":
+			n.multiLevelType = t.attr(r, "val");
+			break;
+		case "numStyleLink":
+			n.numberingStyleLink = t.attr(r, "val");
+			break;
+		case "styleLink":
+			n.styleLink = t.attr(r, "val");
+			break;
+		case "lvl": n.levels.push(F(r, t));
+	}
+	return n;
+}
+function F(e, t) {
+	let n = { level: t.intAttr(e, "ilvl") };
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "start":
+			n.start = t.attr(r, "val");
+			break;
+		case "lvlRestart":
+			n.restart = t.intAttr(r, "val");
+			break;
+		case "numFmt":
+			n.format = t.attr(r, "val");
+			break;
+		case "lvlText":
+			n.text = t.attr(r, "val");
+			break;
+		case "lvlJc":
+			n.justification = t.attr(r, "val");
+			break;
+		case "lvlPicBulletId":
+			n.bulletPictureId = t.attr(r, "val");
+			break;
+		case "pStyle":
+			n.paragraphStyle = t.attr(r, "val");
+			break;
+		case "pPr":
+			n.paragraphProps = N(r, t);
+			break;
+		case "rPr": n.runProps = M(r, t);
+	}
+	return n;
+}
+function De(e, t) {
+	let n = { level: t.intAttr(e, "ilvl") };
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "startOverride":
+			n.start = t.intAttr(r, "val");
+			break;
+		case "lvl": n.numberingLevel = F(r, t);
+	}
+	return n;
+}
+function Oe(e, t) {
+	var n = t.element(e, "pict"), r = n && t.element(n, "shape"), i = r && t.element(r, "imagedata");
+	return i ? {
+		id: t.attr(e, "numPicBulletId"),
+		referenceId: t.attr(i, "id"),
+		style: t.attr(r, "style")
+	} : null;
+}
+var ke = class extends O {
+	constructor(e, t, n) {
+		super(e, t), this._documentParser = n;
+	}
+	parseXml(e) {
+		Object.assign(this, we(e, this._package.xmlParser)), this.domNumberings = this._documentParser.parseNumberingFile(e);
+	}
+}, Ae = class extends O {
+	constructor(e, t, n) {
+		super(e, t), this._documentParser = n;
+	}
+	parseXml(e) {
+		this.styles = this._documentParser.parseStylesFile(e);
+	}
+}, I;
+(function(e) {
+	e.Document = "document", e.Paragraph = "paragraph", e.Run = "run", e.Break = "break", e.NoBreakHyphen = "noBreakHyphen", e.Table = "table", e.Row = "row", e.Cell = "cell", e.Hyperlink = "hyperlink", e.SmartTag = "smartTag", e.Drawing = "drawing", e.Image = "image", e.Text = "text", e.Tab = "tab", e.Symbol = "symbol", e.BookmarkStart = "bookmarkStart", e.BookmarkEnd = "bookmarkEnd", e.Footer = "footer", e.Header = "header", e.FootnoteReference = "footnoteReference", e.EndnoteReference = "endnoteReference", e.Footnote = "footnote", e.Endnote = "endnote", e.SimpleField = "simpleField", e.ComplexField = "complexField", e.Instruction = "instruction", e.VmlPicture = "vmlPicture", e.MmlMath = "mmlMath", e.MmlMathParagraph = "mmlMathParagraph", e.MmlFraction = "mmlFraction", e.MmlFunction = "mmlFunction", e.MmlFunctionName = "mmlFunctionName", e.MmlNumerator = "mmlNumerator", e.MmlDenominator = "mmlDenominator", e.MmlRadical = "mmlRadical", e.MmlBase = "mmlBase", e.MmlDegree = "mmlDegree", e.MmlSuperscript = "mmlSuperscript", e.MmlSubscript = "mmlSubscript", e.MmlPreSubSuper = "mmlPreSubSuper", e.MmlSubArgument = "mmlSubArgument", e.MmlSuperArgument = "mmlSuperArgument", e.MmlNary = "mmlNary", e.MmlDelimiter = "mmlDelimiter", e.MmlRun = "mmlRun", e.MmlEquationArray = "mmlEquationArray", e.MmlLimit = "mmlLimit", e.MmlLimitLower = "mmlLimitLower", e.MmlMatrix = "mmlMatrix", e.MmlMatrixRow = "mmlMatrixRow", e.MmlBox = "mmlBox", e.MmlBar = "mmlBar", e.MmlGroupChar = "mmlGroupChar", e.VmlElement = "vmlElement", e.Inserted = "inserted", e.Deleted = "deleted", e.DeletedText = "deletedText", e.Comment = "comment", e.CommentReference = "commentReference", e.CommentRangeStart = "commentRangeStart", e.CommentRangeEnd = "commentRangeEnd", e.AltChunk = "altChunk";
+})(I ||= {});
+var L = class {
+	constructor() {
+		this.children = [], this.cssStyle = {};
+	}
+}, je = class extends L {
+	constructor() {
+		super(...arguments), this.type = I.Header;
+	}
+}, Me = class extends L {
+	constructor() {
+		super(...arguments), this.type = I.Footer;
+	}
+}, R = class extends O {
+	constructor(e, t, n) {
+		super(e, t), this._documentParser = n;
+	}
+	parseXml(e) {
+		this.rootElement = this.createRootElement(), this.rootElement.children = this._documentParser.parseBodyElements(e);
+	}
+}, Ne = class extends R {
+	createRootElement() {
+		return new je();
+	}
+}, Pe = class extends R {
+	createRootElement() {
+		return new Me();
+	}
+};
+function Fe(e, t) {
+	let n = {};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "Template":
+			n.template = r.textContent;
+			break;
+		case "Pages":
+			n.pages = z(r.textContent);
+			break;
+		case "Words":
+			n.words = z(r.textContent);
+			break;
+		case "Characters":
+			n.characters = z(r.textContent);
+			break;
+		case "Application":
+			n.application = r.textContent;
+			break;
+		case "Lines":
+			n.lines = z(r.textContent);
+			break;
+		case "Paragraphs":
+			n.paragraphs = z(r.textContent);
+			break;
+		case "Company":
+			n.company = r.textContent;
+			break;
+		case "AppVersion": n.appVersion = r.textContent;
+	}
+	return n;
+}
+function z(e) {
+	if (e !== void 0) return parseInt(e);
+}
+var Ie = class extends O {
+	parseXml(e) {
+		this.props = Fe(e, this._package.xmlParser);
+	}
+};
+function Le(e, t) {
+	let n = {};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "title":
+			n.title = r.textContent;
+			break;
+		case "description":
+			n.description = r.textContent;
+			break;
+		case "subject":
+			n.subject = r.textContent;
+			break;
+		case "creator":
+			n.creator = r.textContent;
+			break;
+		case "keywords":
+			n.keywords = r.textContent;
+			break;
+		case "language":
+			n.language = r.textContent;
+			break;
+		case "lastModifiedBy":
+			n.lastModifiedBy = r.textContent;
+			break;
+		case "revision": r.textContent && (n.revision = parseInt(r.textContent));
+	}
+	return n;
+}
+var Re = class extends O {
+	parseXml(e) {
+		this.props = Le(e, this._package.xmlParser);
+	}
+}, ze = class {};
+function Be(e, t) {
+	var n = new ze(), r = t.element(e, "themeElements");
+	for (let e of t.elements(r)) switch (e.localName) {
+		case "clrScheme":
+			n.colorScheme = Ve(e, t);
+			break;
+		case "fontScheme": n.fontScheme = He(e, t);
+	}
+	return n;
+}
+function Ve(e, t) {
+	var n = {
+		name: t.attr(e, "name"),
+		colors: {}
+	};
+	for (let a of t.elements(e)) {
+		var r = t.element(a, "srgbClr"), i = t.element(a, "sysClr");
+		r ? n.colors[a.localName] = t.attr(r, "val") : i && (n.colors[a.localName] = t.attr(i, "lastClr"));
+	}
+	return n;
+}
+function He(e, t) {
+	var n = { name: t.attr(e, "name") };
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "majorFont":
+			n.majorFont = B(r, t);
+			break;
+		case "minorFont": n.minorFont = B(r, t);
+	}
+	return n;
+}
+function B(e, t) {
+	return {
+		latinTypeface: t.elementAttr(e, "latin", "typeface"),
+		eaTypeface: t.elementAttr(e, "ea", "typeface"),
+		csTypeface: t.elementAttr(e, "cs", "typeface")
+	};
+}
+var Ue = class extends O {
+	constructor(e, t) {
+		super(e, t);
+	}
+	parseXml(e) {
+		this.theme = Be(e, this._package.xmlParser);
+	}
+}, V = class {}, We = class extends V {
+	constructor() {
+		super(...arguments), this.type = I.Footnote;
+	}
+}, Ge = class extends V {
+	constructor() {
+		super(...arguments), this.type = I.Endnote;
+	}
+}, H = class extends O {
+	constructor(e, t, n) {
+		super(e, t), this._documentParser = n;
+	}
+}, Ke = class extends H {
+	constructor(e, t, n) {
+		super(e, t, n);
+	}
+	parseXml(e) {
+		this.notes = this._documentParser.parseNotes(e, "footnote", We);
+	}
+}, qe = class extends H {
+	constructor(e, t, n) {
+		super(e, t, n);
+	}
+	parseXml(e) {
+		this.notes = this._documentParser.parseNotes(e, "endnote", Ge);
+	}
+};
+function Je(e, t) {
+	var n = {};
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "defaultTabStop":
+			n.defaultTabStop = t.lengthAttr(r, "val");
+			break;
+		case "footnotePr":
+			n.footnoteProps = U(r, t);
+			break;
+		case "endnotePr":
+			n.endnoteProps = U(r, t);
+			break;
+		case "autoHyphenation":
+			n.autoHyphenation = t.boolAttr(r, "val");
+			break;
+		case "evenAndOddHeaders": n.evenAndOddHeaders = t.boolAttr(r, "val", !0);
+	}
+	return n;
+}
+function U(e, t) {
+	var n = { defaultNoteIds: [] };
+	for (let r of t.elements(e)) switch (r.localName) {
+		case "numFmt":
+			n.nummeringFormat = t.attr(r, "val");
+			break;
+		case "footnote":
+		case "endnote": n.defaultNoteIds.push(t.attr(r, "id"));
+	}
+	return n;
+}
+var Ye = class extends O {
+	constructor(e, t) {
+		super(e, t);
+	}
+	parseXml(e) {
+		this.settings = Je(e, this._package.xmlParser);
+	}
+};
+function Xe(e, t) {
+	return t.elements(e, "property").map((e) => {
+		let n = e.firstChild;
+		return {
+			formatId: t.attr(e, "fmtid"),
+			name: t.attr(e, "name"),
+			type: n.nodeName,
+			value: n.textContent
+		};
+	});
+}
+var Ze = class extends O {
+	parseXml(e) {
+		this.props = Xe(e, this._package.xmlParser);
+	}
+}, Qe = class extends O {
+	constructor(e, t, n) {
+		super(e, t), this._documentParser = n;
+	}
+	parseXml(e) {
+		this.comments = this._documentParser.parseComments(e), this.commentMap = _(this.comments, (e) => e.id);
+	}
+}, $e = class extends O {
+	constructor(e, t) {
+		super(e, t), this.comments = [];
+	}
+	parseXml(e) {
+		let t = this._package.xmlParser;
+		for (let n of t.elements(e, "commentEx")) this.comments.push({
+			paraId: t.attr(n, "paraId"),
+			paraIdParent: t.attr(n, "paraIdParent"),
+			done: t.boolAttr(n, "done")
+		});
+		this.commentMap = _(this.comments, (e) => e.paraId);
+	}
+}, et = [
+	{
+		type: d.OfficeDocument,
+		target: "word/document.xml"
+	},
+	{
+		type: d.ExtendedProperties,
+		target: "docProps/app.xml"
+	},
+	{
+		type: d.CoreProperties,
+		target: "docProps/core.xml"
+	},
+	{
+		type: d.CustomProperties,
+		target: "docProps/custom.xml"
+	}
+], tt = class e {
+	constructor() {
+		this.parts = [], this.partsMap = {}, this.contentTypes = [];
+	}
+	static async load(t, n, r) {
+		var i = new e();
+		return i._options = r, i._parser = n, i._package = await pe.load(t, r), i.rels = await i._package.loadRelationships(), i.contentTypes = await i._package.loadContentTypes(), await Promise.all(et.map((e) => {
+			let t = i.rels.find((t) => t.type === e.type) ?? e;
+			return i.loadRelationshipPart(t.target, t.type);
+		})), i;
+	}
+	save(e = "blob") {
+		return this._package.save(e);
+	}
+	async loadRelationshipPart(e, t) {
+		if (this.partsMap[e]) return this.partsMap[e];
+		if (!this._package.get(e)) return null;
+		let n = null;
+		switch (t) {
+			case d.OfficeDocument:
+				this.documentPart = n = new he(this._package, e, this._parser);
+				break;
+			case d.FontTable:
+				this.fontTablePart = n = new de(this._package, e);
+				break;
+			case d.Numbering:
+				this.numberingPart = n = new ke(this._package, e, this._parser);
+				break;
+			case d.Styles:
+				this.stylesPart = n = new Ae(this._package, e, this._parser);
+				break;
+			case d.Theme:
+				this.themePart = n = new Ue(this._package, e);
+				break;
+			case d.Footnotes:
+				this.footnotesPart = n = new Ke(this._package, e, this._parser);
+				break;
+			case d.Endnotes:
+				this.endnotesPart = n = new qe(this._package, e, this._parser);
+				break;
+			case d.Footer:
+				n = new Pe(this._package, e, this._parser);
+				break;
+			case d.Header:
+				n = new Ne(this._package, e, this._parser);
+				break;
+			case d.CoreProperties:
+				this.corePropsPart = n = new Re(this._package, e);
+				break;
+			case d.ExtendedProperties:
+				this.extendedPropsPart = n = new Ie(this._package, e);
+				break;
+			case d.CustomProperties:
+				n = new Ze(this._package, e);
+				break;
+			case d.Settings:
+				this.settingsPart = n = new Ye(this._package, e);
+				break;
+			case d.Comments:
+				this.commentsPart = n = new Qe(this._package, e, this._parser);
+				break;
+			case d.CommentsExtended: this.commentsExtendedPart = n = new $e(this._package, e);
+		}
+		if (n == null) return Promise.resolve(null);
+		if (this.partsMap[e] = n, this.parts.push(n), await n.load(), n.rels?.length > 0) {
+			let [e] = h(n.path);
+			await Promise.all(n.rels.map((t) => this.loadRelationshipPart(g(t.target, e), t.type)));
+		}
+		return n;
+	}
+	async loadDocumentImage(e, t) {
+		let n = this.getPathById(t ?? this.documentPart, e);
+		return n ? this.blobToURL(await this._package.load(n, "blob"), n) : null;
+	}
+	async loadNumberingImage(e) {
+		let t = this.getPathById(this.numberingPart, e);
+		return t ? this.blobToURL(await this._package.load(t, "blob"), t) : null;
+	}
+	async loadFont(e, t) {
+		let n = this.getPathById(this.fontTablePart, e);
+		if (!n) return null;
+		let r = await this._package.load(n, "uint8array");
+		return r && this.blobToURL(new Blob([nt(r, t)]), n);
+	}
+	async loadAltChunk(e, t) {
+		let n = this.getPathById(t ?? this.documentPart, e);
+		return n ? this._package.load(n, "string") : Promise.resolve(null);
+	}
+	blobToURL(e, t) {
+		if (!e) return null;
+		if (t) {
+			let n = this.contentTypes.find((e) => e.partName === t || e.extension && t.endsWith(`.${e.extension}`));
+			e = n ? new Blob([e], { type: n.contentType }) : e;
+		}
+		return this._options.useBase64URL ? ee(e) : URL.createObjectURL(e);
+	}
+	findPartByRelId(e, t = null) {
+		var n = (t.rels ?? this.rels).find((t) => t.id == e);
+		let r = t ? h(t.path)[0] : "";
+		return n ? this.partsMap[g(n.target, r)] : null;
+	}
+	getPathById(e, t) {
+		let n = e.rels.find((e) => e.id == t), [r] = h(e.path);
+		return n ? g(n.target, r) : null;
+	}
+};
+function nt(e, t) {
+	let n = t.replace(/{|}|-/g, ""), r = Array(16);
+	for (let e = 0; e < 16; e++) r[16 - e - 1] = parseInt(n.substring(e * 2, e * 2 + 2), 16);
+	for (let t = 0; t < 32; t++) e[t] = e[t] ^ r[t % 16];
+	return e;
+}
+function rt(e, t) {
+	return {
+		type: I.BookmarkStart,
+		id: t.attr(e, "id"),
+		name: t.attr(e, "name"),
+		colFirst: t.intAttr(e, "colFirst"),
+		colLast: t.intAttr(e, "colLast")
+	};
+}
+function it(e, t) {
+	return {
+		type: I.BookmarkEnd,
+		id: t.attr(e, "id")
+	};
+}
+var at = class extends L {
+	constructor() {
+		super(...arguments), this.type = I.VmlElement, this.attrs = {};
+	}
+};
+function W(e, t) {
+	var n = new at();
+	switch (e.localName) {
+		case "rect":
+			n.tagName = "rect", Object.assign(n.attrs, {
+				width: "100%",
+				height: "100%"
+			});
+			break;
+		case "oval":
+			n.tagName = "ellipse", Object.assign(n.attrs, {
+				cx: "50%",
+				cy: "50%",
+				rx: "50%",
+				ry: "50%"
+			});
+			break;
+		case "line":
+			n.tagName = "line";
+			break;
+		case "shape":
+			n.tagName = "g";
+			break;
+		case "textbox":
+			n.tagName = "foreignObject", Object.assign(n.attrs, {
+				width: "100%",
+				height: "100%"
+			});
+			break;
+		default: return null;
+	}
+	for (let t of D.attrs(e)) switch (t.localName) {
+		case "style":
+			n.cssStyleText = t.value;
+			break;
+		case "fillcolor":
+			n.attrs.fill = t.value;
+			break;
+		case "from":
+			let [e, r] = G(t.value);
+			Object.assign(n.attrs, {
+				x1: e,
+				y1: r
+			});
+			break;
+		case "to":
+			let [i, a] = G(t.value);
+			Object.assign(n.attrs, {
+				x2: i,
+				y2: a
+			});
+	}
+	for (let r of D.elements(e)) switch (r.localName) {
+		case "stroke":
+			Object.assign(n.attrs, ot(r));
+			break;
+		case "fill":
+			Object.assign(n.attrs, st());
+			break;
+		case "imagedata":
+			n.tagName = "image", Object.assign(n.attrs, {
+				width: "100%",
+				height: "100%"
+			}), n.imageHref = {
+				id: D.attr(r, "id"),
+				title: D.attr(r, "title")
+			};
+			break;
+		case "txbxContent":
+			n.children.push(...t.parseBodyElements(r));
+			break;
+		default:
+			let e = W(r, t);
+			e && n.children.push(e);
+	}
+	return n;
+}
+function ot(e) {
+	return {
+		stroke: D.attr(e, "color"),
+		"stroke-width": D.lengthAttr(e, "weight", C.Emu) ?? "1px"
+	};
+}
+function st(e) {
+	return {};
+}
+function G(e) {
+	return e.split(",");
+}
+var ct = class extends L {
+	constructor() {
+		super(...arguments), this.type = I.Comment;
+	}
+}, lt = class extends L {
+	constructor(e) {
+		super(), this.id = e, this.type = I.CommentReference;
+	}
+}, ut = class extends L {
+	constructor(e) {
+		super(), this.id = e, this.type = I.CommentRangeStart;
+	}
+}, dt = class extends L {
+	constructor(e) {
+		super(), this.id = e, this.type = I.CommentRangeEnd;
+	}
+}, K = {
+	shd: "inherit",
+	color: "black",
+	borderColor: "black",
+	highlight: "transparent"
+}, ft = [], q = {
+	oMath: I.MmlMath,
+	oMathPara: I.MmlMathParagraph,
+	f: I.MmlFraction,
+	func: I.MmlFunction,
+	fName: I.MmlFunctionName,
+	num: I.MmlNumerator,
+	den: I.MmlDenominator,
+	rad: I.MmlRadical,
+	deg: I.MmlDegree,
+	e: I.MmlBase,
+	sSup: I.MmlSuperscript,
+	sSub: I.MmlSubscript,
+	sPre: I.MmlPreSubSuper,
+	sup: I.MmlSuperArgument,
+	sub: I.MmlSubArgument,
+	d: I.MmlDelimiter,
+	nary: I.MmlNary,
+	eqArr: I.MmlEquationArray,
+	lim: I.MmlLimit,
+	limLow: I.MmlLimitLower,
+	m: I.MmlMatrix,
+	mr: I.MmlMatrixRow,
+	box: I.MmlBox,
+	bar: I.MmlBar,
+	groupChr: I.MmlGroupChar
+}, pt = class {
+	constructor(e) {
+		this.options = {
+			ignoreWidth: !1,
+			debug: !1,
+			...e
+		};
+	}
+	parseNotes(e, t, n) {
+		var r = [];
+		for (let i of D.elements(e, t)) {
+			let e = new n();
+			e.id = D.attr(i, "id"), e.noteType = D.attr(i, "type"), e.children = this.parseBodyElements(i), r.push(e);
+		}
+		return r;
+	}
+	parseComments(e) {
+		var t = [];
+		for (let n of D.elements(e, "comment")) {
+			let e = new ct();
+			e.id = D.attr(n, "id"), e.author = D.attr(n, "author"), e.initials = D.attr(n, "initials"), e.date = D.attr(n, "date"), e.children = this.parseBodyElements(n), t.push(e);
+		}
+		return t;
+	}
+	parseDocumentFile(e) {
+		var t = D.element(e, "body"), n = D.element(e, "background"), r = D.element(t, "sectPr");
+		return {
+			type: I.Document,
+			children: this.parseBodyElements(t),
+			props: r ? A(r, D) : {},
+			cssStyle: n ? this.parseBackground(n) : {}
+		};
+	}
+	parseBackground(e) {
+		var t = {}, n = J.colorAttr(e, "color");
+		return n && (t["background-color"] = n), t;
+	}
+	parseBodyElements(e) {
+		var t = [];
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "p":
+				t.push(this.parseParagraph(n));
+				break;
+			case "altChunk":
+				t.push(this.parseAltChunk(n));
+				break;
+			case "tbl":
+				t.push(this.parseTable(n));
+				break;
+			case "sdt": t.push(...this.parseSdt(n, (e) => this.parseBodyElements(e)));
+		}
+		return t;
+	}
+	parseStylesFile(e) {
+		var t = [];
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "style":
+				t.push(this.parseStyle(n));
+				break;
+			case "docDefaults": t.push(this.parseDefaultStyles(n));
+		}
+		return t;
+	}
+	parseDefaultStyles(e) {
+		var t = {
+			id: null,
+			name: null,
+			target: null,
+			basedOn: null,
+			styles: []
+		};
+		for (let i of D.elements(e)) switch (i.localName) {
+			case "rPrDefault":
+				var n = D.element(i, "rPr");
+				n && t.styles.push({
+					target: "span",
+					values: this.parseDefaultProperties(n, {})
+				});
+				break;
+			case "pPrDefault":
+				var r = D.element(i, "pPr");
+				r && t.styles.push({
+					target: "p",
+					values: this.parseDefaultProperties(r, {})
+				});
+		}
+		return t;
+	}
+	parseStyle(e) {
+		var t = {
+			id: D.attr(e, "styleId"),
+			isDefault: D.boolAttr(e, "default"),
+			name: null,
+			target: null,
+			basedOn: null,
+			styles: [],
+			linked: null
+		};
+		switch (D.attr(e, "type")) {
+			case "paragraph":
+				t.target = "p";
+				break;
+			case "table":
+				t.target = "table";
+				break;
+			case "character": t.target = "span";
+		}
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "basedOn":
+				t.basedOn = D.attr(n, "val");
+				break;
+			case "name":
+				t.name = D.attr(n, "val");
+				break;
+			case "link":
+				t.linked = D.attr(n, "val");
+				break;
+			case "next":
+				t.next = D.attr(n, "val");
+				break;
+			case "aliases":
+				t.aliases = D.attr(n, "val").split(",");
+				break;
+			case "pPr":
+				t.styles.push({
+					target: "p",
+					values: this.parseDefaultProperties(n, {})
+				}), t.paragraphProps = N(n, D);
+				break;
+			case "rPr":
+				t.styles.push({
+					target: "span",
+					values: this.parseDefaultProperties(n, {})
+				}), t.runProps = M(n, D);
+				break;
+			case "tblPr":
+			case "tcPr":
+				t.styles.push({
+					target: "td",
+					values: this.parseDefaultProperties(n, {})
+				});
+				break;
+			case "tblStylePr":
+				for (let e of this.parseTableStyle(n)) t.styles.push(e);
+				break;
+			case "rsid":
+			case "qFormat":
+			case "hidden":
+			case "semiHidden":
+			case "unhideWhenUsed":
+			case "autoRedefine":
+			case "uiPriority": break;
+			default: this.options.debug && console.warn(`DOCX: Unknown style element: ${n.localName}`);
+		}
+		return t;
+	}
+	parseTableStyle(e) {
+		var t = [], n = D.attr(e, "type"), r = "", i = "";
+		switch (n) {
+			case "firstRow":
+				i = ".first-row", r = "tr.first-row td";
+				break;
+			case "lastRow":
+				i = ".last-row", r = "tr.last-row td";
+				break;
+			case "firstCol":
+				i = ".first-col", r = "td.first-col";
+				break;
+			case "lastCol":
+				i = ".last-col", r = "td.last-col";
+				break;
+			case "band1Vert":
+				i = ":not(.no-vband)", r = "td.odd-col";
+				break;
+			case "band2Vert":
+				i = ":not(.no-vband)", r = "td.even-col";
+				break;
+			case "band1Horz":
+				i = ":not(.no-hband)", r = "tr.odd-row";
+				break;
+			case "band2Horz":
+				i = ":not(.no-hband)", r = "tr.even-row";
+				break;
+			default: return [];
+		}
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "pPr":
+				t.push({
+					target: `${r} p`,
+					mod: i,
+					values: this.parseDefaultProperties(n, {})
+				});
+				break;
+			case "rPr":
+				t.push({
+					target: `${r} span`,
+					mod: i,
+					values: this.parseDefaultProperties(n, {})
+				});
+				break;
+			case "tblPr":
+			case "tcPr": t.push({
+				target: r,
+				mod: i,
+				values: this.parseDefaultProperties(n, {})
+			});
+		}
+		return t;
+	}
+	parseNumberingFile(e) {
+		let t = [], n = [], r = [];
+		for (let i of D.elements(e)) switch (i.localName) {
+			case "abstractNum":
+				t.push(...this.parseAbstractNumbering(i, r));
+				break;
+			case "numPicBullet":
+				r.push(this.parseNumberingPicBullet(i));
+				break;
+			case "num": n.push({
+				numId: D.attr(i, "numId"),
+				abstractNumId: D.elementAttr(i, "abstractNumId", "val")
+			});
+		}
+		return n.flatMap((e) => t.filter((t) => e.abstractNumId == t.id).map((t) => ({
+			...t,
+			id: e.numId
+		})));
+	}
+	parseNumberingPicBullet(e) {
+		var t = D.element(e, "pict"), n = t && D.element(t, "shape"), r = n && D.element(n, "imagedata");
+		return r ? {
+			id: D.intAttr(e, "numPicBulletId"),
+			src: D.attr(r, "id"),
+			style: D.attr(n, "style")
+		} : null;
+	}
+	parseAbstractNumbering(e, t) {
+		var n = [], r = D.attr(e, "abstractNumId");
+		for (let i of D.elements(e)) switch (i.localName) {
+			case "lvl": n.push(this.parseNumberingLevel(r, i, t));
+		}
+		return n;
+	}
+	parseNumberingLevel(e, t, n) {
+		var r = {
+			id: e,
+			level: D.intAttr(t, "ilvl"),
+			start: 1,
+			pStyleName: void 0,
+			pStyle: {},
+			rStyle: {},
+			suff: "tab"
+		};
+		for (let e of D.elements(t)) switch (e.localName) {
+			case "start":
+				r.start = D.intAttr(e, "val");
+				break;
+			case "pPr":
+				this.parseDefaultProperties(e, r.pStyle);
+				break;
+			case "rPr":
+				this.parseDefaultProperties(e, r.rStyle);
+				break;
+			case "lvlPicBulletId":
+				var i = D.intAttr(e, "val");
+				r.bullet = n.find((e) => e?.id == i);
+				break;
+			case "lvlText":
+				r.levelText = D.attr(e, "val");
+				break;
+			case "pStyle":
+				r.pStyleName = D.attr(e, "val");
+				break;
+			case "numFmt":
+				r.format = D.attr(e, "val");
+				break;
+			case "suff": r.suff = D.attr(e, "val");
+		}
+		return r;
+	}
+	parseSdt(e, t) {
+		let n = D.element(e, "sdtContent");
+		return n ? t(n) : [];
+	}
+	parseChange(e, t, n) {
+		return {
+			type: e,
+			children: n(t)?.children ?? [],
+			id: D.attr(t, "id"),
+			author: D.attr(t, "author"),
+			date: D.attr(t, "date")
+		};
+	}
+	parseAltChunk(e) {
+		return {
+			type: I.AltChunk,
+			children: [],
+			id: D.attr(e, "id")
+		};
+	}
+	parseParagraph(e) {
+		var t = {
+			type: I.Paragraph,
+			children: []
+		};
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "pPr":
+				this.parseParagraphProperties(n, t);
+				break;
+			case "r":
+				t.children.push(this.parseRun(n, t));
+				break;
+			case "hyperlink":
+				t.children.push(this.parseHyperlink(n, t));
+				break;
+			case "smartTag":
+				t.children.push(this.parseSmartTag(n, t));
+				break;
+			case "bookmarkStart":
+				t.children.push(rt(n, D));
+				break;
+			case "bookmarkEnd":
+				t.children.push(it(n, D));
+				break;
+			case "commentRangeStart":
+				t.children.push(new ut(D.attr(n, "id")));
+				break;
+			case "commentRangeEnd":
+				t.children.push(new dt(D.attr(n, "id")));
+				break;
+			case "oMath":
+			case "oMathPara":
+				t.children.push(this.parseMathElement(n));
+				break;
+			case "sdt":
+				t.children.push(...this.parseSdt(n, (e) => this.parseParagraph(e).children));
+				break;
+			case "ins":
+				t.children.push(this.parseChange(I.Inserted, n, (e) => this.parseParagraph(e)));
+				break;
+			case "del": t.children.push(this.parseChange(I.Deleted, n, (e) => this.parseParagraph(e)));
+		}
+		return t;
+	}
+	parseParagraphProperties(e, t) {
+		this.parseDefaultProperties(e, t.cssStyle = {}, null, (e) => {
+			if (P(e, t, D)) return !0;
+			switch (e.localName) {
+				case "pStyle":
+					t.styleName = D.attr(e, "val");
+					break;
+				case "cnfStyle":
+					t.className = Y.classNameOfCnfStyle(e);
+					break;
+				case "framePr":
+					this.parseFrame(e, t);
+					break;
+				case "rPr": break;
+				default: return !1;
+			}
+			return !0;
+		});
+	}
+	parseFrame(e, t) {
+		D.attr(e, "dropCap") == "drop" && (t.cssStyle.float = "left");
+	}
+	parseHyperlink(e, t) {
+		var n = {
+			type: I.Hyperlink,
+			parent: t,
+			children: []
+		};
+		n.anchor = D.attr(e, "anchor"), n.id = D.attr(e, "id");
+		for (let t of D.elements(e)) switch (t.localName) {
+			case "r": n.children.push(this.parseRun(t, n));
+		}
+		return n;
+	}
+	parseSmartTag(e, t) {
+		var n = {
+			type: I.SmartTag,
+			parent: t,
+			children: []
+		}, r = D.attr(e, "uri"), i = D.attr(e, "element");
+		r && (n.uri = r), i && (n.element = i);
+		for (let t of D.elements(e)) switch (t.localName) {
+			case "r":
+				n.children.push(this.parseRun(t, n));
+				break;
+			case "smartTag": n.children.push(this.parseSmartTag(t, n));
+		}
+		return n;
+	}
+	parseRun(e, t) {
+		var n = {
+			type: I.Run,
+			parent: t,
+			children: []
+		};
+		for (let t of D.elements(e)) switch (t = this.checkAlternateContent(t), t?.localName) {
+			case "t":
+				n.children.push({
+					type: I.Text,
+					text: t.textContent
+				});
+				break;
+			case "delText":
+				n.children.push({
+					type: I.DeletedText,
+					text: t.textContent
+				});
+				break;
+			case "commentReference":
+				n.children.push(new lt(D.attr(t, "id")));
+				break;
+			case "fldSimple":
+				n.children.push({
+					type: I.SimpleField,
+					instruction: D.attr(t, "instr"),
+					lock: D.boolAttr(t, "lock", !1),
+					dirty: D.boolAttr(t, "dirty", !1)
+				});
+				break;
+			case "instrText":
+				n.fieldRun = !0, n.children.push({
+					type: I.Instruction,
+					text: t.textContent
+				});
+				break;
+			case "fldChar":
+				n.fieldRun = !0, n.children.push({
+					type: I.ComplexField,
+					charType: D.attr(t, "fldCharType"),
+					lock: D.boolAttr(t, "lock", !1),
+					dirty: D.boolAttr(t, "dirty", !1)
+				});
+				break;
+			case "noBreakHyphen":
+				n.children.push({ type: I.NoBreakHyphen });
+				break;
+			case "br":
+				n.children.push({
+					type: I.Break,
+					break: D.attr(t, "type") || "textWrapping"
+				});
+				break;
+			case "lastRenderedPageBreak":
+				n.children.push({
+					type: I.Break,
+					break: "lastRenderedPageBreak"
+				});
+				break;
+			case "sym":
+				n.children.push({
+					type: I.Symbol,
+					font: m(D.attr(t, "font")),
+					char: D.hexAttr(t, "char")
+				});
+				break;
+			case "tab":
+				n.children.push({ type: I.Tab });
+				break;
+			case "footnoteReference":
+				n.children.push({
+					type: I.FootnoteReference,
+					id: D.attr(t, "id")
+				});
+				break;
+			case "endnoteReference":
+				n.children.push({
+					type: I.EndnoteReference,
+					id: D.attr(t, "id")
+				});
+				break;
+			case "drawing":
+				let e = this.parseDrawing(t);
+				e && n.children.push(e);
+				break;
+			case "pict":
+				n.children.push(this.parseVmlPicture(t));
+				break;
+			case "rPr": this.parseRunProperties(t, n);
+		}
+		return n;
+	}
+	parseMathElement(e) {
+		let t = `${e.localName}Pr`, n = {
+			type: q[e.localName],
+			children: []
+		};
+		for (let i of D.elements(e)) if (q[i.localName]) n.children.push(this.parseMathElement(i));
+		else if (i.localName == "r") {
+			var r = this.parseRun(i);
+			r.type = I.MmlRun, n.children.push(r);
+		} else i.localName == t && (n.props = this.parseMathProperies(i));
+		return n;
+	}
+	parseMathProperies(e) {
+		let t = {};
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "chr":
+				t.char = D.attr(n, "val");
+				break;
+			case "vertJc":
+				t.verticalJustification = D.attr(n, "val");
+				break;
+			case "pos":
+				t.position = D.attr(n, "val");
+				break;
+			case "degHide":
+				t.hideDegree = D.boolAttr(n, "val");
+				break;
+			case "begChr":
+				t.beginChar = D.attr(n, "val");
+				break;
+			case "endChr": t.endChar = D.attr(n, "val");
+		}
+		return t;
+	}
+	parseRunProperties(e, t) {
+		this.parseDefaultProperties(e, t.cssStyle = {}, null, (e) => {
+			switch (e.localName) {
+				case "rStyle":
+					t.styleName = D.attr(e, "val");
+					break;
+				case "vertAlign":
+					t.verticalAlign = Y.valueOfVertAlign(e, !0);
+					break;
+				default: return !1;
+			}
+			return !0;
+		});
+	}
+	parseVmlPicture(e) {
+		let t = {
+			type: I.VmlPicture,
+			children: []
+		};
+		for (let n of D.elements(e)) {
+			let e = W(n, this);
+			e && t.children.push(e);
+		}
+		return t;
+	}
+	checkAlternateContent(e) {
+		if (e.localName != "AlternateContent") return e;
+		var t = D.element(e, "Choice");
+		if (t) {
+			var n = D.attr(t, "Requires"), r = e.lookupNamespaceURI(n);
+			if (ft.includes(r)) return t.firstElementChild;
+		}
+		return D.element(e, "Fallback")?.firstElementChild;
+	}
+	parseDrawing(e) {
+		for (var t of D.elements(e)) switch (t.localName) {
+			case "inline":
+			case "anchor": return this.parseDrawingWrapper(t);
+		}
+	}
+	parseDrawingWrapper(e) {
+		var t = {
+			type: I.Drawing,
+			children: [],
+			cssStyle: {}
+		}, n = e.localName == "anchor";
+		let r = null, i = D.boolAttr(e, "simplePos");
+		D.boolAttr(e, "behindDoc");
+		let a = {
+			relative: "page",
+			align: "left",
+			offset: "0"
+		}, o = {
+			relative: "page",
+			align: "top",
+			offset: "0"
+		};
+		for (var s of D.elements(e)) switch (s.localName) {
+			case "simplePos":
+				i && (a.offset = D.lengthAttr(s, "x", C.Emu), o.offset = D.lengthAttr(s, "y", C.Emu));
+				break;
+			case "extent":
+				t.cssStyle.width = D.lengthAttr(s, "cx", C.Emu), t.cssStyle.height = D.lengthAttr(s, "cy", C.Emu);
+				break;
+			case "positionH":
+			case "positionV":
+				if (!i) {
+					let e = s.localName == "positionH" ? a : o;
+					var c = D.element(s, "align"), l = D.element(s, "posOffset");
+					e.relative = D.attr(s, "relativeFrom") ?? e.relative, c && (e.align = c.textContent), l && (e.offset = w(l.textContent, C.Emu));
+				}
+				break;
+			case "wrapTopAndBottom":
+				r = "wrapTopAndBottom";
+				break;
+			case "wrapNone":
+				r = "wrapNone";
+				break;
+			case "graphic":
+				var u = this.parseGraphic(s);
+				u && t.children.push(u);
+		}
+		return r == "wrapTopAndBottom" ? (t.cssStyle.display = "block", a.align && (t.cssStyle["text-align"] = a.align, t.cssStyle.width = "100%")) : r == "wrapNone" ? (t.cssStyle.display = "block", t.cssStyle.position = "relative", t.cssStyle.width = "0px", t.cssStyle.height = "0px", a.offset && (t.cssStyle.left = a.offset), o.offset && (t.cssStyle.top = o.offset)) : n && (a.align == "left" || a.align == "right") && (t.cssStyle.float = a.align), t;
+	}
+	parseGraphic(e) {
+		var t = D.element(e, "graphicData");
+		for (let e of D.elements(t)) switch (e.localName) {
+			case "pic": return this.parsePicture(e);
+		}
+		return null;
+	}
+	parsePicture(e) {
+		var t = {
+			type: I.Image,
+			src: "",
+			cssStyle: {}
+		}, n = D.element(e, "blipFill"), r = D.element(n, "blip"), i = D.element(n, "srcRect");
+		t.src = D.attr(r, "embed"), i && (t.srcRect = [
+			D.intAttr(i, "l", 0) / 1e5,
+			D.intAttr(i, "t", 0) / 1e5,
+			D.intAttr(i, "r", 0) / 1e5,
+			D.intAttr(i, "b", 0) / 1e5
+		]);
+		var a = D.element(e, "spPr"), o = D.element(a, "xfrm");
+		if (t.cssStyle.position = "relative", o) {
+			t.rotation = D.intAttr(o, "rot", 0) / 6e4;
+			for (var s of D.elements(o)) switch (s.localName) {
+				case "ext":
+					t.cssStyle.width = D.lengthAttr(s, "cx", C.Emu), t.cssStyle.height = D.lengthAttr(s, "cy", C.Emu);
+					break;
+				case "off": t.cssStyle.left = D.lengthAttr(s, "x", C.Emu), t.cssStyle.top = D.lengthAttr(s, "y", C.Emu);
+			}
+		}
+		return t;
+	}
+	parseTable(e) {
+		var t = {
+			type: I.Table,
+			children: []
+		};
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "tr":
+				t.children.push(this.parseTableRow(n));
+				break;
+			case "tblGrid":
+				t.columns = this.parseTableColumns(n);
+				break;
+			case "tblPr": this.parseTableProperties(n, t);
+		}
+		return t;
+	}
+	parseTableColumns(e) {
+		var t = [];
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "gridCol": t.push({ width: D.lengthAttr(n, "w") });
+		}
+		return t;
+	}
+	parseTableProperties(e, t) {
+		switch (t.cssStyle = {}, t.cellStyle = {}, this.parseDefaultProperties(e, t.cssStyle, t.cellStyle, (e) => {
+			switch (e.localName) {
+				case "tblStyle":
+					t.styleName = D.attr(e, "val");
+					break;
+				case "tblLook":
+					t.className = Y.classNameOftblLook(e);
+					break;
+				case "tblpPr":
+					this.parseTablePosition(e, t);
+					break;
+				case "tblStyleColBandSize":
+					t.colBandSize = D.intAttr(e, "val");
+					break;
+				case "tblStyleRowBandSize":
+					t.rowBandSize = D.intAttr(e, "val");
+					break;
+				case "hidden":
+					t.cssStyle.display = "none";
+					break;
+				default: return !1;
+			}
+			return !0;
+		}), t.cssStyle["text-align"]) {
+			case "center":
+				delete t.cssStyle["text-align"], t.cssStyle["margin-left"] = "auto", t.cssStyle["margin-right"] = "auto";
+				break;
+			case "right": delete t.cssStyle["text-align"], t.cssStyle["margin-left"] = "auto";
+		}
+	}
+	parseTablePosition(e, t) {
+		var n = D.lengthAttr(e, "topFromText"), r = D.lengthAttr(e, "bottomFromText"), i = D.lengthAttr(e, "rightFromText"), a = D.lengthAttr(e, "leftFromText");
+		t.cssStyle.float = "left", t.cssStyle["margin-bottom"] = Y.addSize(t.cssStyle["margin-bottom"], r), t.cssStyle["margin-left"] = Y.addSize(t.cssStyle["margin-left"], a), t.cssStyle["margin-right"] = Y.addSize(t.cssStyle["margin-right"], i), t.cssStyle["margin-top"] = Y.addSize(t.cssStyle["margin-top"], n);
+	}
+	parseTableRow(e) {
+		var t = {
+			type: I.Row,
+			children: []
+		};
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "tc":
+				t.children.push(this.parseTableCell(n));
+				break;
+			case "trPr":
+			case "tblPrEx": this.parseTableRowProperties(n, t);
+		}
+		return t;
+	}
+	parseTableRowProperties(e, t) {
+		t.cssStyle = this.parseDefaultProperties(e, {}, null, (e) => {
+			switch (e.localName) {
+				case "cnfStyle":
+					t.className = Y.classNameOfCnfStyle(e);
+					break;
+				case "tblHeader":
+					t.isHeader = D.boolAttr(e, "val");
+					break;
+				case "gridBefore":
+					t.gridBefore = D.intAttr(e, "val");
+					break;
+				case "gridAfter":
+					t.gridAfter = D.intAttr(e, "val");
+					break;
+				default: return !1;
+			}
+			return !0;
+		});
+	}
+	parseTableCell(e) {
+		var t = {
+			type: I.Cell,
+			children: []
+		};
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "tbl":
+				t.children.push(this.parseTable(n));
+				break;
+			case "p":
+				t.children.push(this.parseParagraph(n));
+				break;
+			case "tcPr": this.parseTableCellProperties(n, t);
+		}
+		return t;
+	}
+	parseTableCellProperties(e, t) {
+		t.cssStyle = this.parseDefaultProperties(e, {}, null, (e) => {
+			switch (e.localName) {
+				case "gridSpan":
+					t.span = D.intAttr(e, "val", null);
+					break;
+				case "vMerge":
+					t.verticalMerge = D.attr(e, "val") ?? "continue";
+					break;
+				case "cnfStyle":
+					t.className = Y.classNameOfCnfStyle(e);
+					break;
+				default: return !1;
+			}
+			return !0;
+		}), this.parseTableCellVerticalText(e, t);
+	}
+	parseTableCellVerticalText(e, t) {
+		let n = {
+			btLr: {
+				writingMode: "vertical-rl",
+				transform: "rotate(180deg)"
+			},
+			lrTb: {
+				writingMode: "vertical-lr",
+				transform: "none"
+			},
+			tbRl: {
+				writingMode: "vertical-rl",
+				transform: "none"
+			}
+		};
+		for (let r of D.elements(e)) if (r.localName === "textDirection") {
+			let e = n[D.attr(r, "val")] || { writingMode: "horizontal-tb" };
+			t.cssStyle["writing-mode"] = e.writingMode, t.cssStyle.transform = e.transform;
+		}
+	}
+	parseDefaultProperties(e, t = null, n = null, r = null) {
+		t ||= {};
+		for (let i of D.elements(e)) if (!r?.(i)) switch (i.localName) {
+			case "jc":
+				t["text-align"] = Y.valueOfJc(i);
+				break;
+			case "textAlignment":
+				t["vertical-align"] = Y.valueOfTextAlignment(i);
+				break;
+			case "color":
+				t.color = J.colorAttr(i, "val", null, K.color);
+				break;
+			case "sz":
+				t["font-size"] = t["min-height"] = D.lengthAttr(i, "val", C.FontSize);
+				break;
+			case "shd":
+				t["background-color"] = J.colorAttr(i, "fill", null, K.shd);
+				break;
+			case "highlight":
+				t["background-color"] = J.colorAttr(i, "val", null, K.highlight);
+				break;
+			case "vertAlign": break;
+			case "position":
+				t.verticalAlign = D.lengthAttr(i, "val", C.FontSize);
+				break;
+			case "tcW": if (this.options.ignoreWidth) break;
+			case "tblW":
+				t.width = Y.valueOfSize(i, "w");
+				break;
+			case "trHeight":
+				this.parseTrHeight(i, t);
+				break;
+			case "strike":
+				t["text-decoration"] = D.boolAttr(i, "val", !0) ? "line-through" : "none";
+				break;
+			case "b":
+				t["font-weight"] = D.boolAttr(i, "val", !0) ? "bold" : "normal";
+				break;
+			case "i":
+				t["font-style"] = D.boolAttr(i, "val", !0) ? "italic" : "normal";
+				break;
+			case "caps":
+				t["text-transform"] = D.boolAttr(i, "val", !0) ? "uppercase" : "none";
+				break;
+			case "smallCaps":
+				t["font-variant"] = D.boolAttr(i, "val", !0) ? "small-caps" : "none";
+				break;
+			case "u":
+				this.parseUnderline(i, t);
+				break;
+			case "ind":
+			case "tblInd":
+				this.parseIndentation(i, t);
+				break;
+			case "rFonts":
+				this.parseFont(i, t);
+				break;
+			case "tblBorders":
+				this.parseBorderProperties(i, n || t);
+				break;
+			case "tblCellSpacing":
+				t["border-spacing"] = Y.valueOfMargin(i), t["border-collapse"] = "separate";
+				break;
+			case "pBdr":
+				this.parseBorderProperties(i, t);
+				break;
+			case "bdr":
+				t.border = Y.valueOfBorder(i);
+				break;
+			case "tcBorders":
+				this.parseBorderProperties(i, t);
+				break;
+			case "vanish":
+				D.boolAttr(i, "val", !0) && (t.display = "none");
+				break;
+			case "kern": break;
+			case "noWrap": break;
+			case "tblCellMar":
+			case "tcMar":
+				this.parseMarginProperties(i, n || t);
+				break;
+			case "tblLayout":
+				t["table-layout"] = Y.valueOfTblLayout(i);
+				break;
+			case "vAlign":
+				t["vertical-align"] = Y.valueOfTextAlignment(i);
+				break;
+			case "spacing":
+				e.localName == "pPr" && this.parseSpacing(i, t);
+				break;
+			case "wordWrap":
+				D.boolAttr(i, "val") && (t["overflow-wrap"] = "break-word");
+				break;
+			case "suppressAutoHyphens":
+				t.hyphens = D.boolAttr(i, "val", !0) ? "none" : "auto";
+				break;
+			case "lang":
+				t.$lang = D.attr(i, "val");
+				break;
+			case "rtl":
+			case "bidi":
+				D.boolAttr(i, "val", !0) && (t.direction = "rtl");
+				break;
+			case "bCs":
+			case "iCs":
+			case "szCs":
+			case "tabs":
+			case "outlineLvl":
+			case "contextualSpacing":
+			case "tblStyleColBandSize":
+			case "tblStyleRowBandSize":
+			case "webHidden":
+			case "pageBreakBefore":
+			case "suppressLineNumbers":
+			case "keepLines":
+			case "keepNext":
+			case "widowControl":
+			case "noProof": break;
+			default: this.options.debug && console.warn(`DOCX: Unknown document element: ${e.localName}.${i.localName}`);
+		}
+		return t;
+	}
+	parseUnderline(e, t) {
+		var n = D.attr(e, "val");
+		if (n != null) {
+			switch (n) {
+				case "dash":
+				case "dashDotDotHeavy":
+				case "dashDotHeavy":
+				case "dashedHeavy":
+				case "dashLong":
+				case "dashLongHeavy":
+				case "dotDash":
+				case "dotDotDash":
+					t["text-decoration"] = "underline dashed";
+					break;
+				case "dotted":
+				case "dottedHeavy":
+					t["text-decoration"] = "underline dotted";
+					break;
+				case "double":
+					t["text-decoration"] = "underline double";
+					break;
+				case "single":
+				case "thick":
+					t["text-decoration"] = "underline";
+					break;
+				case "wave":
+				case "wavyDouble":
+				case "wavyHeavy":
+					t["text-decoration"] = "underline wavy";
+					break;
+				case "words":
+					t["text-decoration"] = "underline";
+					break;
+				case "none": t["text-decoration"] = "none";
+			}
+			var r = J.colorAttr(e, "color");
+			r && (t["text-decoration-color"] = r);
+		}
+	}
+	parseFont(e, t) {
+		var n = [
+			D.attr(e, "ascii"),
+			Y.themeValue(e, "asciiTheme"),
+			D.attr(e, "eastAsia")
+		].filter((e) => e).map((e) => m(e));
+		n.length > 0 && (t["font-family"] = [...new Set(n)].join(", "));
+	}
+	parseIndentation(e, t) {
+		var n = D.lengthAttr(e, "firstLine"), r = D.lengthAttr(e, "hanging"), i = D.lengthAttr(e, "left"), a = D.lengthAttr(e, "start"), o = D.lengthAttr(e, "right"), s = D.lengthAttr(e, "end");
+		n && (t["text-indent"] = n), r && (t["text-indent"] = `-${r}`), (i || a) && (t["margin-inline-start"] = i || a), (o || s) && (t["margin-inline-end"] = o || s);
+	}
+	parseSpacing(e, t) {
+		var n = D.lengthAttr(e, "before"), r = D.lengthAttr(e, "after"), i = D.intAttr(e, "line", null), a = D.attr(e, "lineRule");
+		if (n && (t["margin-top"] = n), r && (t["margin-bottom"] = r), i !== null) switch (a) {
+			case "auto":
+				t["line-height"] = `${(i / 240).toFixed(2)}`;
+				break;
+			case "atLeast":
+				t["line-height"] = `calc(100% + ${i / 20}pt)`;
+				break;
+			default: t["line-height"] = t["min-height"] = `${i / 20}pt`;
+		}
+	}
+	parseMarginProperties(e, t) {
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "left":
+				t["padding-left"] = Y.valueOfMargin(n);
+				break;
+			case "right":
+				t["padding-right"] = Y.valueOfMargin(n);
+				break;
+			case "top":
+				t["padding-top"] = Y.valueOfMargin(n);
+				break;
+			case "bottom": t["padding-bottom"] = Y.valueOfMargin(n);
+		}
+	}
+	parseTrHeight(e, t) {
+		switch (D.attr(e, "hRule")) {
+			case "exact":
+				t.height = D.lengthAttr(e, "val");
+				break;
+			default: t.height = D.lengthAttr(e, "val");
+		}
+	}
+	parseBorderProperties(e, t) {
+		for (let n of D.elements(e)) switch (n.localName) {
+			case "start":
+			case "left":
+				t["border-left"] = Y.valueOfBorder(n);
+				break;
+			case "end":
+			case "right":
+				t["border-right"] = Y.valueOfBorder(n);
+				break;
+			case "top":
+				t["border-top"] = Y.valueOfBorder(n);
+				break;
+			case "bottom": t["border-bottom"] = Y.valueOfBorder(n);
+		}
+	}
+}, mt = [
+	"black",
+	"blue",
+	"cyan",
+	"darkBlue",
+	"darkCyan",
+	"darkGray",
+	"darkGreen",
+	"darkMagenta",
+	"darkRed",
+	"darkYellow",
+	"green",
+	"lightGray",
+	"magenta",
+	"none",
+	"red",
+	"white",
+	"yellow"
+], J = class {
+	static colorAttr(e, t, n = null, r = "black") {
+		var i = D.attr(e, t);
+		if (i) return i == "auto" ? r : mt.includes(i) ? i : `#${i}`;
+		var a = D.attr(e, "themeColor");
+		return a ? `var(--docx-${a}-color)` : n;
+	}
+}, Y = class e {
+	static themeValue(e, t) {
+		var n = D.attr(e, t);
+		return n ? `var(--docx-${n}-font)` : null;
+	}
+	static valueOfSize(e, t) {
+		var n = C.Dxa;
+		switch (D.attr(e, "type")) {
+			case "dxa": break;
+			case "pct":
+				n = C.Percent;
+				break;
+			case "auto": return "auto";
+		}
+		return D.lengthAttr(e, t, n);
+	}
+	static valueOfMargin(e) {
+		return D.lengthAttr(e, "w");
+	}
+	static valueOfBorder(t) {
+		var n = e.parseBorderType(D.attr(t, "val"));
+		if (n == "none") return "none";
+		var r = J.colorAttr(t, "color");
+		return `${D.lengthAttr(t, "sz", C.Border)} ${n} ${r == "auto" ? K.borderColor : r}`;
+	}
+	static parseBorderType(e) {
+		switch (e) {
+			case "single": return "solid";
+			case "dashDotStroked": return "solid";
+			case "dashed": return "dashed";
+			case "dashSmallGap": return "dashed";
+			case "dotDash": return "dotted";
+			case "dotDotDash": return "dotted";
+			case "dotted": return "dotted";
+			case "double": return "double";
+			case "doubleWave": return "double";
+			case "inset": return "inset";
+			case "nil": return "none";
+			case "none": return "none";
+			case "outset": return "outset";
+			case "thick": return "solid";
+			case "thickThinLargeGap": return "solid";
+			case "thickThinMediumGap": return "solid";
+			case "thickThinSmallGap": return "solid";
+			case "thinThickLargeGap": return "solid";
+			case "thinThickMediumGap": return "solid";
+			case "thinThickSmallGap": return "solid";
+			case "thinThickThinLargeGap": return "solid";
+			case "thinThickThinMediumGap": return "solid";
+			case "thinThickThinSmallGap": return "solid";
+			case "threeDEmboss": return "solid";
+			case "threeDEngrave": return "solid";
+			case "triple": return "double";
+			case "wave": return "solid";
+		}
+		return "solid";
+	}
+	static valueOfTblLayout(e) {
+		return D.attr(e, "val") == "fixed" ? "fixed" : "auto";
+	}
+	static classNameOfCnfStyle(e) {
+		let t = D.attr(e, "val"), n = [
+			"first-row",
+			"last-row",
+			"first-col",
+			"last-col",
+			"odd-col",
+			"even-col",
+			"odd-row",
+			"even-row",
+			"ne-cell",
+			"nw-cell",
+			"se-cell",
+			"sw-cell"
+		];
+		if (t) return n.filter((e, n) => t[n] == "1").join(" ");
+		let r = [
+			"firstRow",
+			"lastRow",
+			"firstColumn",
+			"lastColumn",
+			"oddVBand",
+			"evenVBand",
+			"oddHBand",
+			"evenHBand",
+			"firstRowLastColumn",
+			"firstRowFirstColumn",
+			"lastRowLastColumn",
+			"lastRowFirstColumn"
+		];
+		return n.filter((t, n) => D.boolAttr(e, r[n])).join(" ");
+	}
+	static valueOfJc(e) {
+		var t = D.attr(e, "val");
+		switch (t) {
+			case "start":
+			case "left": return "left";
+			case "center": return "center";
+			case "end":
+			case "right": return "right";
+			case "both": return "justify";
+		}
+		return t;
+	}
+	static valueOfVertAlign(e, t = !1) {
+		var n = D.attr(e, "val");
+		switch (n) {
+			case "subscript": return "sub";
+			case "superscript": return t ? "sup" : "super";
+		}
+		return t ? null : n;
+	}
+	static valueOfTextAlignment(e) {
+		var t = D.attr(e, "val");
+		switch (t) {
+			case "auto":
+			case "baseline": return "baseline";
+			case "top": return "top";
+			case "center": return "middle";
+			case "bottom": return "bottom";
+		}
+		return t;
+	}
+	static addSize(e, t) {
+		return e == null ? t : t == null ? e : `calc(${e} + ${t})`;
+	}
+	static classNameOftblLook(e) {
+		let t = D.hexAttr(e, "val", 0), n = "";
+		return (D.boolAttr(e, "firstRow") || t & 32) && (n += " first-row"), (D.boolAttr(e, "lastRow") || t & 64) && (n += " last-row"), (D.boolAttr(e, "firstColumn") || t & 128) && (n += " first-col"), (D.boolAttr(e, "lastColumn") || t & 256) && (n += " last-col"), (D.boolAttr(e, "noHBand") || t & 512) && (n += " no-hband"), (D.boolAttr(e, "noVBand") || t & 1024) && (n += " no-vband"), n.trim();
+	}
+}, X = {
+	pos: 0,
+	leader: "none",
+	style: "left"
+}, ht = 50;
+function gt(e = document.body) {
+	let t = document.createElement("div");
+	t.style.width = "100pt", e.appendChild(t);
+	let n = 100 / t.offsetWidth;
+	return e.removeChild(t), n;
+}
+function _t(e, t, n, r = 72 / 96) {
+	let i = e.closest("p"), a = e.getBoundingClientRect(), o = i.getBoundingClientRect(), s = getComputedStyle(i), c = t?.length > 0 ? t.map((e) => ({
+		pos: Z(e.position),
+		leader: e.leader,
+		style: e.style
+	})).sort((e, t) => e.pos - t.pos) : [X], l = c[c.length - 1], u = o.width * r, d = Z(n), f = l.pos + d;
+	if (f < u) for (; f < u && c.length < ht; f += d) c.push({
+		...X,
+		pos: f
+	});
+	let p = parseFloat(s.marginLeft), m = o.left + p, h = (a.left - m) * r, g = c.find((e) => e.style != "clear" && e.pos > h);
+	if (g == null) return;
+	let _ = 1;
+	if (g.style == "right" || g.style == "center") {
+		let t = Array.from(i.querySelectorAll(`.${e.className}`)), n = t.indexOf(e) + 1, a = document.createRange();
+		a.setStart(e, 1), n < t.length ? a.setEndBefore(t[n]) : a.setEndAfter(i);
+		let s = g.style == "center" ? .5 : 1, c = a.getBoundingClientRect(), l = c.left + s * c.width - (o.left - p);
+		_ = g.pos - l * r;
+	} else _ = g.pos - h;
+	switch (e.innerHTML = "&nbsp;", e.style.textDecoration = "inherit", e.style.wordSpacing = `${_.toFixed(0)}pt`, g.leader) {
+		case "dot":
+		case "middleDot":
+			e.style.textDecoration = "underline", e.style.textDecorationStyle = "dotted";
+			break;
+		case "hyphen":
+		case "heavy":
+		case "underscore": e.style.textDecoration = "underline";
+	}
+}
+function Z(e) {
+	return parseFloat(e);
+}
+var Q;
+(function(e) {
+	e.html = "http://www.w3.org/1999/xhtml", e.svg = "http://www.w3.org/2000/svg", e.mathML = "http://www.w3.org/1998/Math/MathML";
+})(Q ||= {});
+function $(e) {
+	if (y(e)) return document.createTextNode(e);
+	if (e instanceof Node) return e;
+	let { ns: t, tagName: n, className: r, style: i, children: a, ...o } = e;
+	if (n === "#fragment") {
+		let e = document.createDocumentFragment();
+		return a && a.forEach((t) => e.appendChild($(t))), e;
+	}
+	if (n === "#comment") return document.createComment(a ? a[0] : "");
+	let s = t ? document.createElementNS(t, n) : document.createElement(n);
+	if (r && s.setAttribute("class", r), i && (y(i) ? s.setAttribute("style", i) : Object.assign(s.style, i)), o) for (let [e, t] of Object.entries(o)) t !== void 0 && (s[e] = t);
+	return a && a.forEach((e) => s.appendChild($(e))), s;
+}
+function vt(...e) {
+	return e.filter(Boolean).join(" ");
+}
+var yt = class {
+	constructor() {
+		this.className = "docx", this.styleMap = {}, this.currentPart = null, this.tableVerticalMerges = [], this.currentVerticalMerge = null, this.tableCellPositions = [], this.currentCellPosition = null, this.footnoteMap = {}, this.endnoteMap = {}, this.currentEndnoteIds = [], this.usedHederFooterParts = [], this.currentTabs = [], this.commentMap = {}, this.tasks = [], this.postRenderTasks = [], this.h = $;
+	}
+	async render(e, t) {
+		this.document = e, this.options = t, this.className = t.className, this.rootSelector = t.inWrapper ? `.${this.className}-wrapper` : ":root", this.h = t.h ?? $, this.styleMap = null, this.tasks = [], this.options.renderComments && globalThis.Highlight && (this.commentHighlight = new Highlight());
+		let n = [...this.renderDefaultStyle()];
+		e.themePart && n.push(...this.renderTheme(e.themePart)), e.stylesPart != null && (this.styleMap = this.processStyles(e.stylesPart.styles), n.push(...this.renderStyles(e.stylesPart.styles))), e.numberingPart && (this.prodessNumberings(e.numberingPart.domNumberings), n.push(...await this.renderNumbering(e.numberingPart.domNumberings))), e.footnotesPart && (this.footnoteMap = _(e.footnotesPart.notes, (e) => e.id)), e.endnotesPart && (this.endnoteMap = _(e.endnotesPart.notes, (e) => e.id)), e.settingsPart && (this.defaultTabSize = e.settingsPart.settings?.defaultTabStop), !t.ignoreFonts && e.fontTablePart && n.push(...await this.renderFontTable(e.fontTablePart));
+		var r = this.renderSections(e.documentPart.body);
+		return this.options.inWrapper ? n.push(this.renderWrapper(r)) : n.push(...r), this.commentHighlight && t.renderComments && CSS.highlights.set(`${this.className}-comments`, this.commentHighlight), this.postRenderTasks.forEach((e) => e()), await Promise.allSettled(this.tasks), this.refreshTabStops(), n;
+	}
+	renderTheme(e) {
+		let t = {}, n = e.theme?.fontScheme;
+		n && (n.majorFont && (t["--docx-majorHAnsi-font"] = n.majorFont.latinTypeface), n.minorFont && (t["--docx-minorHAnsi-font"] = n.minorFont.latinTypeface));
+		let r = e.theme?.colorScheme;
+		if (r) for (let [e, n] of Object.entries(r.colors)) t[`--docx-${e}-color`] = `#${n}`;
+		let i = this.styleToString(`.${this.className}`, t);
+		return [this.h({
+			tagName: "#comment",
+			children: ["docxjs document theme values"]
+		}), this.h({
+			tagName: "style",
+			children: [i]
+		})];
+	}
+	async renderFontTable(e) {
+		let t = [];
+		for (let n of e.fonts) for (let e of n.embedFontRefs) try {
+			let r = await this.document.loadFont(e.id, e.key), i = {
+				"font-family": m(n.name),
+				src: `url(${r})`
+			};
+			(e.type == "bold" || e.type == "boldItalic") && (i["font-weight"] = "bold"), (e.type == "italic" || e.type == "boldItalic") && (i["font-style"] = "italic"), t.push(this.h({
+				tagName: "#comment",
+				children: [`docxjs ${n.name} font`]
+			})), t.push(this.h({
+				tagName: "style",
+				children: [this.styleToString("@font-face", i)]
+			}));
+		} catch {
+			this.options.debug && console.warn(`Can't load font with id ${e.id} and key ${e.key}`);
+		}
+		return t;
+	}
+	processStyleName(e) {
+		return e ? `${this.className}_${p(e)}` : this.className;
+	}
+	processStyles(e) {
+		let t = _(e.filter((e) => e.id != null), (e) => e.id);
+		for (let r of e.filter((e) => e.basedOn)) {
+			var n = t[r.basedOn];
+			if (n) {
+				r.paragraphProps = b(r.paragraphProps, n.paragraphProps), r.runProps = b(r.runProps, n.runProps);
+				for (let e of n.styles) {
+					let t = r.styles.find((t) => t.target == e.target);
+					t ? this.copyStyleProperties(e.values, t.values) : r.styles.push({
+						...e,
+						values: { ...e.values }
+					});
+				}
+			} else this.options.debug && console.warn(`Can't find base style ${r.basedOn}`);
+		}
+		for (let t of e) t.cssName = this.processStyleName(t.id);
+		return t;
+	}
+	prodessNumberings(e) {
+		for (let t of e.filter((e) => e.pStyleName)) {
+			let e = this.findStyle(t.pStyleName);
+			e?.paragraphProps?.numbering && (e.paragraphProps.numbering.level = t.level);
+		}
+	}
+	processElement(e) {
+		if (e.children) for (var t of e.children) t.parent = e, t.type == I.Table ? this.processTable(t) : this.processElement(t);
+	}
+	processTable(e) {
+		for (var t of e.children) for (var n of t.children) n.cssStyle = this.copyStyleProperties(e.cellStyle, n.cssStyle, [
+			"border-left",
+			"border-right",
+			"border-top",
+			"border-bottom",
+			"padding-left",
+			"padding-right",
+			"padding-top",
+			"padding-bottom"
+		]), this.processElement(n);
+	}
+	copyStyleProperties(e, t, n = null) {
+		if (!e) return t;
+		t ??= {}, n ??= Object.getOwnPropertyNames(e);
+		for (var r of n) e.hasOwnProperty(r) && !t.hasOwnProperty(r) && (t[r] = e[r]);
+		return t;
+	}
+	createPageElement(e, t, n) {
+		let r = { ...n };
+		return t && (t.pageMargins && (r.paddingLeft = t.pageMargins.left, r.paddingRight = t.pageMargins.right, r.paddingTop = t.pageMargins.top, r.paddingBottom = t.pageMargins.bottom), t.pageSize && (this.options.ignoreWidth || (r.width = t.pageSize.width), this.options.ignoreHeight || (r.minHeight = t.pageSize.height))), this.h({
+			tagName: "section",
+			className: e,
+			style: r
+		});
+	}
+	createSectionContent(e) {
+		let t = {};
+		return e.columns && e.columns.numberOfColumns && (t.columnCount = `${e.columns.numberOfColumns}`, t.columnGap = e.columns.space, e.columns.separator && (t.columnRule = "1px solid black")), this.h({
+			tagName: "article",
+			style: t
+		});
+	}
+	renderSections(e) {
+		let t = [];
+		this.processElement(e);
+		let n = this.splitBySection(e.children, e.props), r = this.groupByPageBreaks(n), i = null;
+		for (let n = 0, o = r.length; n < o; n++) {
+			this.currentFootnoteIds = [];
+			let s = r[n][0].sectProps, c = this.createPageElement(this.className, s, e.cssStyle);
+			this.options.renderHeaders && this.renderHeaderFooter(s.headerRefs, s, t.length, i != s, c);
+			for (let e of r[n]) {
+				var a = this.createSectionContent(e.sectProps);
+				this.renderElements(e.elements, a), c.appendChild(a), s = e.sectProps;
+			}
+			if (this.options.renderFootnotes) {
+				let e = this.renderNotes(this.currentFootnoteIds, this.footnoteMap);
+				e && c.appendChild(e);
+			}
+			if (this.options.renderEndnotes && n == o - 1) {
+				let e = this.renderNotes(this.currentEndnoteIds, this.endnoteMap);
+				e && c.appendChild(e);
+			}
+			this.options.renderFooters && this.renderHeaderFooter(s.footerRefs, s, t.length, i != s, c), t.push(c), i = s;
+		}
+		return t;
+	}
+	renderHeaderFooter(e, t, n, r, i) {
+		if (!e) return;
+		let a = this.document.settingsPart?.settings?.evenAndOddHeaders ?? !1;
+		var o = (t.titlePage && r ? e.find((e) => e.type == "first") : null) ?? (n % 2 == 1 && a ? e.find((e) => e.type == "even") : null) ?? e.find((e) => e.type == "default"), s = o && this.document.findPartByRelId(o.id, this.document.documentPart);
+		if (s) {
+			this.currentPart = s, this.usedHederFooterParts.includes(s.path) || (this.processElement(s.rootElement), this.usedHederFooterParts.push(s.path));
+			let [e] = this.renderElements([s.rootElement], i);
+			t?.pageMargins && (s.rootElement.type === I.Header ? (e.style.marginTop = `calc(${t.pageMargins.header} - ${t.pageMargins.top})`, e.style.minHeight = `calc(${t.pageMargins.top} - ${t.pageMargins.header})`) : s.rootElement.type === I.Footer && (e.style.marginBottom = `calc(${t.pageMargins.footer} - ${t.pageMargins.bottom})`, e.style.minHeight = `calc(${t.pageMargins.bottom} - ${t.pageMargins.footer})`)), this.currentPart = null;
+		}
+	}
+	isPageBreakElement(e) {
+		return e.type == I.Break ? e.break == "lastRenderedPageBreak" ? !this.options.ignoreLastRenderedPageBreak : e.break == "page" : !1;
+	}
+	isPageBreakSection(e, t) {
+		return !e || !t ? !1 : e.pageSize?.orientation != t.pageSize?.orientation || e.pageSize?.width != t.pageSize?.width || e.pageSize?.height != t.pageSize?.height;
+	}
+	splitBySection(e, t) {
+		var n = {
+			sectProps: null,
+			elements: [],
+			pageBreak: !1
+		}, r = [n];
+		for (let t of e) {
+			if (t.type == I.Paragraph) {
+				let e = t, a = this.findStyle(e.styleName);
+				(e.pageBreakBefore || a?.paragraphProps?.pageBreakBefore) && (n.sectProps = i, n.pageBreak = !0, n = {
+					sectProps: null,
+					elements: [],
+					pageBreak: !1
+				}, r.push(n));
+			}
+			if (n.elements.push(t), t.type == I.Paragraph) {
+				let e = t;
+				var i = e.sectionProps, a = -1, o = -1;
+				if (this.options.breakPages && e.children && (a = e.children.findIndex((e) => (o = e.children?.findIndex(this.isPageBreakElement.bind(this)) ?? -1, o != -1))), (i || a != -1) && (n.sectProps = i, n.pageBreak = a != -1, n = {
+					sectProps: null,
+					elements: [],
+					pageBreak: !1
+				}, r.push(n)), a != -1) {
+					let r = e.children[a], i = o < r.children.length - 1;
+					if (a < e.children.length - 1 || i) {
+						var s = t.children, c = {
+							...t,
+							children: s.slice(a)
+						};
+						if (t.children = s.slice(0, a), n.elements.push(c), i) {
+							let e = r.children, n = {
+								...r,
+								children: e.slice(0, o)
+							};
+							t.children.push(n), r.children = e.slice(o);
+						}
+					}
+				}
+			}
+		}
+		let l = null;
+		for (let e = r.length - 1; e >= 0; e--) r[e].sectProps == null ? r[e].sectProps = l ?? t : l = r[e].sectProps;
+		return r;
+	}
+	groupByPageBreaks(e) {
+		let t = [], n, r = [t];
+		for (let i of e) t.push(i), (this.options.ignoreLastRenderedPageBreak || i.pageBreak || this.isPageBreakSection(n, i.sectProps)) && r.push(t = []), n = i.sectProps;
+		return r.filter((e) => e.length > 0);
+	}
+	renderWrapper(e) {
+		return this.h({
+			tagName: "div",
+			className: `${this.className}-wrapper`,
+			children: e
+		});
+	}
+	renderDefaultStyle() {
+		var e = this.className, t = `
+.${e}-wrapper { background: gray; padding: 30px; padding-bottom: 0px; display: flex; flex-flow: column; align-items: center; } 
+.${e}-wrapper>section.${e} { background: white; box-shadow: 0 0 10px rgba(0, 0, 0, 0.5); margin-bottom: 30px; }`;
+		this.options.hideWrapperOnPrint && (t = `@media not print { ${t} }`);
+		var n = `${t}
+.${e} { color: black; hyphens: auto; text-underline-position: from-font; }
+section.${e} { box-sizing: border-box; display: flex; flex-flow: column nowrap; position: relative; overflow: hidden; }
+section.${e}>article { margin-bottom: auto; z-index: 1; }
+section.${e}>footer { z-index: 1; }
+.${e} table { border-collapse: collapse; }
+.${e} table td, .${e} table th { vertical-align: top; }
+.${e} p { margin: 0pt; min-height: 1em; }
+.${e} span { white-space: pre-wrap; overflow-wrap: break-word; }
+.${e} a { color: inherit; text-decoration: inherit; }
+.${e} svg { fill: transparent; }
+`;
+		return this.options.renderComments && (n += `
+.${e}-comment-ref { cursor: default; }
+.${e}-comment-popover { display: none; z-index: 1000; padding: 0.5rem; background: white; position: absolute; box-shadow: 0 0 0.25rem rgba(0, 0, 0, 0.25); width: 30ch; }
+.${e}-comment-ref:hover~.${e}-comment-popover { display: block; }
+.${e}-comment-author,.${e}-comment-date { font-size: 0.875rem; color: #888; }
+`), [this.h({
+			tagName: "#comment",
+			children: ["docxjs library predefined styles"]
+		}), this.h({
+			tagName: "style",
+			children: [n]
+		})];
+	}
+	async renderNumbering(e) {
+		var t = "", n = [];
+		for (var r of e) {
+			var i = `p.${this.numberingClass(r.id, r.level)}`, a = "none";
+			if (r.bullet) {
+				let e = `--${this.className}-${r.bullet.src}`.toLowerCase();
+				t += this.styleToString(`${i}:before`, {
+					content: "' '",
+					display: "inline-block",
+					background: `var(${e})`
+				}, r.bullet.style);
+				try {
+					let n = await this.document.loadNumberingImage(r.bullet.src);
+					t += `${this.rootSelector} { ${e}: url(${n}) }`;
+				} catch {
+					this.options.debug && console.warn(`Can't load numbering image with src ${r.bullet.src}`);
+				}
+			} else if (r.levelText) {
+				let e = this.numberingCounter(r.id, r.level), a = e + " " + (r.start - 1);
+				r.level > 0 && (t += this.styleToString(`p.${this.numberingClass(r.id, r.level - 1)}`, { "counter-set": a })), n.push(a), t += this.styleToString(`${i}:before`, {
+					content: this.levelTextToContent(r.levelText, r.suff, r.id, this.numFormatToCssValue(r.format)),
+					"counter-increment": e,
+					...r.rStyle
+				});
+			} else a = this.numFormatToCssValue(r.format);
+			t += this.styleToString(i, {
+				display: "list-item",
+				"list-style-position": "inside",
+				"list-style-type": a,
+				...r.pStyle
+			});
+		}
+		return n.length > 0 && (t += this.styleToString(this.rootSelector, { "counter-reset": n.join(" ") })), [this.h({
+			tagName: "#comment",
+			children: ["docxjs document numbering styles"]
+		}), this.h({
+			tagName: "style",
+			children: [t]
+		})];
+	}
+	renderStyles(e) {
+		var t = "";
+		let n = this.styleMap, r = _(e.filter((e) => e.isDefault), (e) => e.target);
+		for (let s of e) {
+			var i = s.styles;
+			if (s.linked) {
+				var a = s.linked && n[s.linked];
+				a ? i = i.concat(a.styles) : this.options.debug && console.warn(`Can't find linked style ${s.linked}`);
+			}
+			for (let e of i) {
+				var o = `${s.target ?? ""}.${s.cssName}`;
+				s.target != e.target && (o += ` ${e.target}`), r[s.target] == s && (o = `.${this.className} ${s.target}, ` + o), t += this.styleToString(o, e.values);
+			}
+		}
+		return [this.h({
+			tagName: "#comment",
+			children: ["docxjs document styles"]
+		}), this.h({
+			tagName: "style",
+			children: [t]
+		})];
+	}
+	renderNotes(e, t) {
+		var n = e.map((e) => t[e]).filter((e) => e);
+		if (n.length > 0) return this.h({
+			tagName: "ol",
+			children: this.renderElements(n)
+		});
+	}
+	renderElement(e) {
+		switch (e.type) {
+			case I.Paragraph: return this.renderParagraph(e);
+			case I.BookmarkStart: return this.renderBookmarkStart(e);
+			case I.BookmarkEnd: return null;
+			case I.Run: return this.renderRun(e);
+			case I.Table: return this.renderTable(e);
+			case I.Row: return this.renderTableRow(e);
+			case I.Cell: return this.renderTableCell(e);
+			case I.Hyperlink: return this.renderHyperlink(e);
+			case I.SmartTag: return this.renderSmartTag(e);
+			case I.Drawing: return this.renderDrawing(e);
+			case I.Image: return this.renderImage(e);
+			case I.Text: return this.renderText(e);
+			case I.Text: return this.renderText(e);
+			case I.DeletedText: return this.renderDeletedText(e);
+			case I.Tab: return this.renderTab(e);
+			case I.Symbol: return this.renderSymbol(e);
+			case I.Break: return this.renderBreak(e);
+			case I.Footer: return this.renderContainer(e, "footer");
+			case I.Header: return this.renderContainer(e, "header");
+			case I.Footnote:
+			case I.Endnote: return this.renderContainer(e, "li");
+			case I.FootnoteReference: return this.renderFootnoteReference(e);
+			case I.EndnoteReference: return this.renderEndnoteReference(e);
+			case I.NoBreakHyphen: return this.h({ tagName: "wbr" });
+			case I.VmlPicture: return this.renderVmlPicture(e);
+			case I.VmlElement: return this.renderVmlElement(e);
+			case I.MmlMath: return this.renderContainerNS(e, Q.mathML, "math", { xmlns: Q.mathML });
+			case I.MmlMathParagraph: return this.renderContainer(e, "span");
+			case I.MmlFraction: return this.renderContainerNS(e, Q.mathML, "mfrac");
+			case I.MmlBase: return this.renderContainerNS(e, Q.mathML, e.parent.type == I.MmlMatrixRow ? "mtd" : "mrow");
+			case I.MmlNumerator:
+			case I.MmlDenominator:
+			case I.MmlFunction:
+			case I.MmlLimit:
+			case I.MmlBox: return this.renderContainerNS(e, Q.mathML, "mrow");
+			case I.MmlGroupChar: return this.renderMmlGroupChar(e);
+			case I.MmlLimitLower: return this.renderContainerNS(e, Q.mathML, "munder");
+			case I.MmlMatrix: return this.renderContainerNS(e, Q.mathML, "mtable");
+			case I.MmlMatrixRow: return this.renderContainerNS(e, Q.mathML, "mtr");
+			case I.MmlRadical: return this.renderMmlRadical(e);
+			case I.MmlSuperscript: return this.renderContainerNS(e, Q.mathML, "msup");
+			case I.MmlSubscript: return this.renderContainerNS(e, Q.mathML, "msub");
+			case I.MmlDegree:
+			case I.MmlSuperArgument:
+			case I.MmlSubArgument: return this.renderContainerNS(e, Q.mathML, "mn");
+			case I.MmlFunctionName: return this.renderContainerNS(e, Q.mathML, "ms");
+			case I.MmlDelimiter: return this.renderMmlDelimiter(e);
+			case I.MmlRun: return this.renderMmlRun(e);
+			case I.MmlNary: return this.renderMmlNary(e);
+			case I.MmlPreSubSuper: return this.renderMmlPreSubSuper(e);
+			case I.MmlBar: return this.renderMmlBar(e);
+			case I.MmlEquationArray: return this.renderMllList(e);
+			case I.Inserted: return this.renderInserted(e);
+			case I.Deleted: return this.renderDeleted(e);
+			case I.CommentRangeStart: return this.renderCommentRangeStart(e);
+			case I.CommentRangeEnd: return this.renderCommentRangeEnd(e);
+			case I.CommentReference: return this.renderCommentReference(e);
+			case I.AltChunk: return this.renderAltChunk(e);
+		}
+		return null;
+	}
+	renderElements(e, t) {
+		if (e == null) return null;
+		var n = e.flatMap((e) => this.renderElement(e)).filter((e) => e != null);
+		return t && n.forEach((e) => t.appendChild(y(e) ? document.createTextNode(e) : e)), n;
+	}
+	renderContainer(e, t, n) {
+		return this.h({
+			tagName: t,
+			children: this.renderElements(e.children),
+			...n
+		});
+	}
+	renderContainerNS(e, t, n, r) {
+		return this.h({
+			ns: t,
+			tagName: n,
+			children: this.renderElements(e.children),
+			...r
+		});
+	}
+	renderParagraph(e) {
+		var t = this.toHTML(e, Q.html, "p");
+		let n = this.findStyle(e.styleName);
+		e.tabs ??= n?.paragraphProps?.tabs;
+		let r = e.numbering ?? n?.paragraphProps?.numbering;
+		return r && t.classList.add(this.numberingClass(r.id, r.level)), t;
+	}
+	renderHyperlink(e) {
+		let t = this.toH(e, Q.html, "a");
+		return t.href = "", e.id && (t.href = this.document.documentPart.rels.find((t) => t.id == e.id && t.targetMode === "External")?.target ?? t.href), e.anchor && (t.href += `#${e.anchor}`), this.h(t);
+	}
+	renderSmartTag(e) {
+		return this.renderContainer(e, "span");
+	}
+	renderCommentRangeStart(e) {
+		if (!this.options.renderComments) return null;
+		let t = new Range();
+		this.commentHighlight?.add(t);
+		let n = this.h({
+			tagName: "#comment",
+			children: [`start of comment #${e.id}`]
+		});
+		return this.later(() => t.setStart(n, 0)), this.commentMap[e.id] = t, n;
+	}
+	renderCommentRangeEnd(e) {
+		if (!this.options.renderComments) return null;
+		let t = this.commentMap[e.id], n = this.h({
+			tagName: "#comment",
+			children: [`end of comment #${e.id}`]
+		});
+		return this.later(() => t?.setEnd(n, 0)), n;
+	}
+	renderCommentReference(e) {
+		if (!this.options.renderComments) return null;
+		var t = this.document.commentsPart?.commentMap[e.id];
+		if (!t) return null;
+		let n = this.h({
+			tagName: "span",
+			className: `${this.className}-comment-ref`,
+			children: ["💬"]
+		}), r = this.h({
+			tagName: "div",
+			className: `${this.className}-comment-popover`,
+			children: [
+				this.h({
+					tagName: "div",
+					className: `${this.className}-comment-author`,
+					children: [t.author]
+				}),
+				this.h({
+					tagName: "div",
+					className: `${this.className}-comment-date`,
+					children: [new Date(t.date).toLocaleString()]
+				}),
+				...this.renderElements(t.children)
+			]
+		});
+		return this.h({
+			tagName: "#fragment",
+			children: [
+				this.h({
+					tagName: "#comment",
+					children: [`comment #${t.id} by ${t.author} on ${t.date}`]
+				}),
+				n,
+				r
+			]
+		});
+	}
+	renderAltChunk(e) {
+		if (!this.options.renderAltChunks) return null;
+		var t = this.h({ tagName: "iframe" });
+		return this.tasks.push(this.document.loadAltChunk(e.id, this.currentPart).then((e) => {
+			t.srcdoc = e;
+		})), t;
+	}
+	renderDrawing(e) {
+		var t = this.toHTML(e, Q.html, "div");
+		return t.style.display = "inline-block", t.style.position = "relative", t.style.textIndent = "0px", t;
+	}
+	renderImage(e) {
+		let t = this.toHTML(e, Q.html, "img", []), n = e.cssStyle?.transform;
+		if (e.srcRect && e.srcRect.some((e) => e != 0)) {
+			var [r, i, a, o] = e.srcRect;
+			n = `scale(${1 / (1 - r - a)}, ${1 / (1 - i - o)})`, t.style["clip-path"] = `rect(${(100 * i).toFixed(2)}% ${(100 * (1 - a)).toFixed(2)}% ${(100 * (1 - o)).toFixed(2)}% ${(100 * r).toFixed(2)}%)`;
+		}
+		return e.rotation && (n = `rotate(${e.rotation}deg) ${n ?? ""}`), t.style.transform = n?.trim(), this.document && this.tasks.push(this.document.loadDocumentImage(e.src, this.currentPart).then((e) => {
+			t.src = e;
+		})), t;
+	}
+	renderText(e) {
+		return this.h(e.text);
+	}
+	renderDeletedText(e) {
+		return this.options.renderChanges ? this.renderText(e) : null;
+	}
+	renderBreak(e) {
+		return e.break == "textWrapping" ? this.h({ tagName: "br" }) : null;
+	}
+	renderInserted(e) {
+		return this.options.renderChanges ? this.renderChange(e, "ins") : this.renderElements(e.children);
+	}
+	renderDeleted(e) {
+		return this.options.renderChanges ? this.renderChange(e, "del") : null;
+	}
+	renderChange(e, t) {
+		return this.renderContainer(e, t, { dateTime: e.date });
+	}
+	renderSymbol(e) {
+		return this.h({
+			tagName: "span",
+			children: [String.fromCharCode(e.char)],
+			style: { fontFamily: e.font }
+		});
+	}
+	renderFootnoteReference(e) {
+		return this.currentFootnoteIds.push(e.id), this.h({
+			tagName: "sup",
+			children: [`${this.currentFootnoteIds.length}`]
+		});
+	}
+	renderEndnoteReference(e) {
+		return this.currentEndnoteIds.push(e.id), this.h({
+			tagName: "sup",
+			children: [`${this.currentEndnoteIds.length}`]
+		});
+	}
+	renderTab(e) {
+		var t = this.h({
+			tagName: "span",
+			children: [" "]
+		});
+		if (this.options.experimental) {
+			t.className = this.tabStopClass();
+			var n = bt(e, I.Paragraph)?.tabs;
+			this.currentTabs.push({
+				stops: n,
+				span: t
+			});
+		}
+		return t;
+	}
+	renderBookmarkStart(e) {
+		return this.h({
+			tagName: "span",
+			id: e.name
+		});
+	}
+	renderRun(e) {
+		if (e.fieldRun) return null;
+		let t = this.renderElements(e.children);
+		e.verticalAlign && (t = [this.h({
+			tagName: e.verticalAlign,
+			children: this.renderElements(e.children)
+		})]);
+		let n = this.toHTML(e, Q.html, "span", t);
+		return e.id && (n.id = e.id), n;
+	}
+	renderTable(e) {
+		this.tableCellPositions.push(this.currentCellPosition), this.tableVerticalMerges.push(this.currentVerticalMerge), this.currentVerticalMerge = {}, this.currentCellPosition = {
+			col: 0,
+			row: 0
+		};
+		let t = [];
+		return e.columns && t.push(this.renderTableColumns(e.columns)), t.push(...this.renderElements(e.children)), this.currentVerticalMerge = this.tableVerticalMerges.pop(), this.currentCellPosition = this.tableCellPositions.pop(), this.toHTML(e, Q.html, "table", t);
+	}
+	renderTableColumns(e) {
+		let t = e.map((e) => this.h({
+			tagName: "col",
+			style: { width: e.width }
+		}));
+		return this.h({
+			tagName: "colgroup",
+			children: t
+		});
+	}
+	renderTableRow(e) {
+		this.currentCellPosition.col = 0;
+		let t = [];
+		return e.gridBefore && t.push(this.renderTableCellPlaceholder(e.gridBefore)), t.push(...this.renderElements(e.children)), e.gridAfter && t.push(this.renderTableCellPlaceholder(e.gridAfter)), this.currentCellPosition.row++, this.toHTML(e, Q.html, "tr", t);
+	}
+	renderTableCellPlaceholder(e) {
+		return this.h({
+			tagName: "td",
+			colSpan: e,
+			style: { border: "none" }
+		});
+	}
+	renderTableCell(e) {
+		let t = this.toHTML(e, Q.html, "td"), n = this.currentCellPosition.col;
+		return e.verticalMerge ? e.verticalMerge == "restart" ? (this.currentVerticalMerge[n] = t, t.rowSpan = 1) : this.currentVerticalMerge[n] && (this.currentVerticalMerge[n].rowSpan += 1, t.style.display = "none") : this.currentVerticalMerge[n] = null, e.span && (t.colSpan = e.span), this.currentCellPosition.col += t.colSpan, t;
+	}
+	renderVmlPicture(e) {
+		return this.renderContainer(e, "div");
+	}
+	renderVmlElement(e) {
+		var t = this.h({
+			ns: Q.svg,
+			tagName: "svg",
+			style: e.cssStyleText
+		});
+		let n = this.renderVmlChildElement(e);
+		return e.imageHref?.id && this.tasks.push(this.document?.loadDocumentImage(e.imageHref.id, this.currentPart).then((e) => n.setAttribute("href", e))), t.appendChild(n), requestAnimationFrame(() => {
+			let e = t.firstElementChild.getBBox();
+			t.setAttribute("width", `${Math.ceil(e.x + e.width)}`), t.setAttribute("height", `${Math.ceil(e.y + e.height)}`);
+		}), t;
+	}
+	renderVmlChildElement(e) {
+		let t = this.createSvgElement(e.tagName);
+		Object.entries(e.attrs).forEach(([e, n]) => t.setAttribute(e, n));
+		for (let n of e.children) n.type == I.VmlElement ? t.appendChild(this.renderVmlChildElement(n)) : t.appendChild(...x(this.renderElement(n)));
+		return t;
+	}
+	renderMmlRadical(e) {
+		let t = e.children.find((e) => e.type == I.MmlBase);
+		if (e.props?.hideDegree) return this.createMathMLElement("msqrt", null, this.renderElements([t]));
+		let n = e.children.find((e) => e.type == I.MmlDegree);
+		return this.createMathMLElement("mroot", null, this.renderElements([t, n]));
+	}
+	renderMmlDelimiter(e) {
+		let t = [];
+		return t.push(this.createMathMLElement("mo", null, [e.props.beginChar ?? "("])), t.push(...this.renderElements(e.children)), t.push(this.createMathMLElement("mo", null, [e.props.endChar ?? ")"])), this.createMathMLElement("mrow", null, t);
+	}
+	renderMmlNary(e) {
+		let t = [], n = _(e.children, (e) => e.type), r = n[I.MmlSuperArgument], i = n[I.MmlSubArgument], a = r ? this.createMathMLElement("mo", null, x(this.renderElement(r))) : null, o = i ? this.createMathMLElement("mo", null, x(this.renderElement(i))) : null, s = this.createMathMLElement("mo", null, [e.props?.char ?? "∫"]);
+		return a || o ? t.push(this.createMathMLElement("munderover", null, [
+			s,
+			o,
+			a
+		])) : a ? t.push(this.createMathMLElement("mover", null, [s, a])) : o ? t.push(this.createMathMLElement("munder", null, [s, o])) : t.push(s), t.push(...this.renderElements(n[I.MmlBase].children)), this.createMathMLElement("mrow", null, t);
+	}
+	renderMmlPreSubSuper(e) {
+		let t = [], n = _(e.children, (e) => e.type), r = n[I.MmlSuperArgument], i = n[I.MmlSubArgument], a = r ? this.createMathMLElement("mo", null, x(this.renderElement(r))) : null, o = i ? this.createMathMLElement("mo", null, x(this.renderElement(i))) : null, s = this.createMathMLElement("mo", null);
+		return t.push(this.createMathMLElement("msubsup", null, [
+			s,
+			o,
+			a
+		])), t.push(...this.renderElements(n[I.MmlBase].children)), this.createMathMLElement("mrow", null, t);
+	}
+	renderMmlGroupChar(e) {
+		let t = e.props.verticalJustification === "bot" ? "mover" : "munder", n = this.renderContainerNS(e, Q.mathML, t);
+		return e.props.char && n.appendChild(this.createMathMLElement("mo", null, [e.props.char])), n;
+	}
+	renderMmlBar(e) {
+		let t = {};
+		switch (e.props.position) {
+			case "top":
+				t.textDecoration = "overline";
+				break;
+			case "bottom": t.textDecoration = "underline";
+		}
+		return this.renderContainerNS(e, Q.mathML, "mrow", { style: t });
+	}
+	renderMmlRun(e) {
+		return this.toHTML(e, Q.mathML, "ms");
+	}
+	renderMllList(e) {
+		let t = this.renderElements(e.children).map((e) => this.createMathMLElement("mtr", null, [this.createMathMLElement("mtd", null, [e])]));
+		return this.toHTML(e, Q.mathML, "mtable", t);
+	}
+	toH(e, t, n, r = null) {
+		let { $lang: i, ...a } = e.cssStyle ?? {};
+		return {
+			ns: t,
+			tagName: n,
+			className: vt(e.className, e.styleName && this.processStyleName(e.styleName)),
+			lang: i,
+			style: a,
+			children: r ?? this.renderElements(e.children)
+		};
+	}
+	toHTML(e, t, n, r = null) {
+		return this.h(this.toH(e, t, n, r));
+	}
+	findStyle(e) {
+		return e && this.styleMap?.[e];
+	}
+	numberingClass(e, t) {
+		return `${this.className}-num-${e}-${t}`;
+	}
+	tabStopClass() {
+		return `${this.className}-tab-stop`;
+	}
+	styleToString(e, t, n = null) {
+		let r = `${e} {\r\n`;
+		for (let e in t) e.startsWith("$") || (r += `  ${e}: ${t[e]};\r\n`);
+		return n && (r += n), r + "}\r\n";
+	}
+	numberingCounter(e, t) {
+		return `${this.className}-num-${e}-${t}`;
+	}
+	levelTextToContent(e, t, n, r) {
+		return `"${e.replace(/%\d*/g, (e) => {
+			let t = parseInt(e.substring(1), 10) - 1;
+			return `"counter(${this.numberingCounter(n, t)}, ${r})"`;
+		})}${{
+			tab: "\\9",
+			space: "\\a0"
+		}[t] ?? ""}"`;
+	}
+	numFormatToCssValue(e) {
+		return {
+			none: "none",
+			bullet: "disc",
+			decimal: "decimal",
+			lowerLetter: "lower-alpha",
+			upperLetter: "upper-alpha",
+			lowerRoman: "lower-roman",
+			upperRoman: "upper-roman",
+			decimalZero: "decimal-leading-zero",
+			aiueo: "katakana",
+			aiueoFullWidth: "katakana",
+			chineseCounting: "simp-chinese-informal",
+			chineseCountingThousand: "simp-chinese-informal",
+			chineseLegalSimplified: "simp-chinese-formal",
+			chosung: "hangul-consonant",
+			ideographDigital: "cjk-ideographic",
+			ideographTraditional: "cjk-heavenly-stem",
+			ideographLegalTraditional: "trad-chinese-formal",
+			ideographZodiac: "cjk-earthly-branch",
+			iroha: "katakana-iroha",
+			irohaFullWidth: "katakana-iroha",
+			japaneseCounting: "japanese-informal",
+			japaneseDigitalTenThousand: "cjk-decimal",
+			japaneseLegal: "japanese-formal",
+			thaiNumbers: "thai",
+			koreanCounting: "korean-hangul-formal",
+			koreanDigital: "korean-hangul-formal",
+			koreanDigital2: "korean-hanja-informal",
+			hebrew1: "hebrew",
+			hebrew2: "hebrew",
+			hindiNumbers: "devanagari",
+			ganada: "hangul",
+			taiwaneseCounting: "cjk-ideographic",
+			taiwaneseCountingThousand: "cjk-ideographic",
+			taiwaneseDigital: "cjk-decimal"
+		}[e] ?? e;
+	}
+	refreshTabStops() {
+		this.options.experimental && setTimeout(() => {
+			let e = gt();
+			for (let t of this.currentTabs) _t(t.span, t.stops, this.defaultTabSize, e);
+		}, 500);
+	}
+	createElementNS(e, t, n, r) {
+		return this.h({
+			ns: e,
+			tagName: t,
+			children: r,
+			...n
+		});
+	}
+	createElement(e, t, n) {
+		return this.createElementNS(Q.html, e, t, n);
+	}
+	createMathMLElement(e, t, n) {
+		return this.createElementNS(Q.mathML, e, t, n);
+	}
+	createSvgElement(e, t, n) {
+		return this.createElementNS(Q.svg, e, t, n);
+	}
+	later(e) {
+		this.postRenderTasks.push(e);
+	}
+};
+function bt(e, t) {
+	for (var n = e.parent; n != null && n.type != t;) n = n.parent;
+	return n;
+}
+var xt = {
+	ignoreHeight: !1,
+	ignoreWidth: !1,
+	ignoreFonts: !1,
+	breakPages: !0,
+	debug: !1,
+	experimental: !1,
+	className: "docx",
+	inWrapper: !0,
+	hideWrapperOnPrint: !1,
+	trimXmlDeclaration: !0,
+	ignoreLastRenderedPageBreak: !0,
+	renderHeaders: !0,
+	renderFooters: !0,
+	renderFootnotes: !0,
+	renderEndnotes: !0,
+	useBase64URL: !1,
+	renderChanges: !1,
+	renderComments: !1,
+	renderAltChunks: !0,
+	h: $
+};
+function St(e, t) {
+	let n = {
+		...xt,
+		...t
+	};
+	return tt.load(e, new pt(n), n);
+}
+async function Ct(e, t) {
+	let n = {
+		...xt,
+		...t
+	};
+	return await new yt().render(e, n);
+}
+async function wt(e, t, n, r) {
+	let i = await St(e, r), a = await Ct(i, r);
+	n ??= t, n.innerHTML = "", t.innerHTML = "";
+	for (let e of a) (e.nodeName === "STYLE" ? n : t).appendChild(e);
+	return i;
+}
+// src/components/file-viewer/renderers/DocxRenderer.vue?vue&type=script&setup=true&lang.ts
+var Tt = { class: "fv-docx" }, Et = /*#__PURE__*/ n(/* @__PURE__ */ a({
+	__name: "DocxRenderer",
+	props: {
+		source: {},
+		options: {},
+		viewportWidth: {},
+		viewportHeight: {}
+	},
+	emits: ["ready", "error"],
+	setup(e, { emit: t }) {
+		let n = e, a = t, u = l(null), d = l(null), f = !1;
+		return s(async () => {
+			try {
+				let e = await n.source.getBlob();
+				if (f || !u.value || !d.value || (await wt(e, u.value, d.value, {
+					inWrapper: !0,
+					breakPages: !0,
+					renderHeaders: !0,
+					renderFooters: !0,
+					renderFootnotes: !0,
+					renderEndnotes: !0,
+					useBase64URL: !0,
+					ignoreLastRenderedPageBreak: !1
+				}), f)) return;
+				a("ready");
+			} catch (e) {
+				if (f) return;
+				a("error", e instanceof Error ? e.message : "Word 文档解析失败");
+			}
+		}), o(() => {
+			f = !0, u.value && (u.value.innerHTML = ""), d.value && (d.value.innerHTML = "");
+		}), (e, t) => (c(), r("div", Tt, [i("div", {
+			ref_key: "styles",
+			ref: d,
+			class: "fv-docx-styles"
+		}, null, 512), i("div", {
+			ref_key: "body",
+			ref: u,
+			class: "fv-docx-body"
+		}, null, 512)]));
+	}
+}), [["__scopeId", "data-v-4f61d703"]]);
+export { Et as default };