docx-plus 0.0.3 → 0.0.4

package/dist/index.umd.js

@@ -1,15 +1,14 @@
 (function(global, factory) {
-	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("xml-js"), require("hash.js"), require("nanoid/non-secure"), require("undio"), require("stream"), require("fflate"), require("xml")) : typeof define === "function" && define.amd ? define([
+	typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("xml-js"), require("hash.js"), require("nanoid/non-secure"), require("undio"), require("fflate"), require("xml")) : typeof define === "function" && define.amd ? define([
 		"exports",
 		"xml-js",
 		"hash.js",
 		"nanoid/non-secure",
 		"undio",
-		"stream",
 		"fflate",
 		"xml"
-	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.docxPlus = {}, global.xml_js, global.hash_js, global.nanoid_non_secure, global.undio, global.stream, global.fflate, global.xml));
-})(this, function(exports, xml_js, hash_js, nanoid_non_secure, undio, stream, fflate, xml) {
+	], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.docx = {}, global.xml_js, global.hash_js, global.nanoid_non_secure, global.undio, global.fflate, global.xml));
+})(this, function(exports, xml_js, hash_js, nanoid_non_secure, undio, fflate, xml) {
 	Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 	//#region \0rolldown/runtime.js
 	var __create = Object.create;
@@ -33,9 +32,9 @@
 		enumerable: true
 	}) : target, mod));
 	//#endregion
-	hash_js = __toESM(hash_js);
-	xml = __toESM(xml);
-	//#region \0@oxc-project+runtime@0.123.0/helpers/typeof.js
+	hash_js = __toESM(hash_js, 1);
+	xml = __toESM(xml, 1);
+	//#region \0@oxc-project+runtime@0.124.0/helpers/typeof.js
 	function _typeof(o) {
 		"@babel/helpers - typeof";
 		return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
@@ -45,7 +44,7 @@
 		}, _typeof(o);
 	}
 	//#endregion
-	//#region \0@oxc-project+runtime@0.123.0/helpers/toPrimitive.js
+	//#region \0@oxc-project+runtime@0.124.0/helpers/toPrimitive.js
 	function toPrimitive(t, r) {
 		if ("object" != _typeof(t) || !t) return t;
 		var e = t[Symbol.toPrimitive];
@@ -57,13 +56,13 @@
 		return ("string" === r ? String : Number)(t);
 	}
 	//#endregion
-	//#region \0@oxc-project+runtime@0.123.0/helpers/toPropertyKey.js
+	//#region \0@oxc-project+runtime@0.124.0/helpers/toPropertyKey.js
 	function toPropertyKey(t) {
 		var i = toPrimitive(t, "string");
 		return "symbol" == _typeof(i) ? i : i + "";
 	}
 	//#endregion
-	//#region \0@oxc-project+runtime@0.123.0/helpers/defineProperty.js
+	//#region \0@oxc-project+runtime@0.124.0/helpers/defineProperty.js
 	function _defineProperty(e, r, t) {
 		return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
 			value: t,
@@ -248,29 +247,6 @@
 		}
 	};
 	//#endregion
-	//#region \0@oxc-project+runtime@0.123.0/helpers/objectSpread2.js
-	function ownKeys(e, r) {
-		var t = Object.keys(e);
-		if (Object.getOwnPropertySymbols) {
-			var o = Object.getOwnPropertySymbols(e);
-			r && (o = o.filter(function(r) {
-				return Object.getOwnPropertyDescriptor(e, r).enumerable;
-			})), t.push.apply(t, o);
-		}
-		return t;
-	}
-	function _objectSpread2(e) {
-		for (var r = 1; r < arguments.length; r++) {
-			var t = null != arguments[r] ? arguments[r] : {};
-			r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
-				_defineProperty(e, r, t[r]);
-			}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
-				Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
-			});
-		}
-		return e;
-	}
-	//#endregion
 	//#region src/file/xml-components/default-attributes.ts
 	/**
 	* XML attribute components for the docx library.
@@ -364,7 +340,10 @@
 		* @returns Object with _attr key containing the attributes
 		*/
 		prepForXml(_) {
-			return { _attr: Object.values(this.root).filter(({ value }) => value !== void 0).reduce((acc, { key, value }) => _objectSpread2(_objectSpread2({}, acc), {}, { [key]: value }), {}) };
+			return { _attr: Object.values(this.root).filter(({ value }) => value !== void 0).reduce((acc, { key, value }) => ({
+				...acc,
+				[key]: value
+			}), {}) };
 		}
 	};
 	//#endregion
@@ -4738,13 +4717,16 @@
 	* @returns An XML component representing the click hyperlink
 	*/
 	const createHyperlinkClick = (linkId, hasXmlNs) => new BuilderElement({
-		attributes: _objectSpread2(_objectSpread2({}, hasXmlNs ? { xmlns: {
-			key: "xmlns:a",
-			value: "http://schemas.openxmlformats.org/drawingml/2006/main"
-		} } : {}), {}, { id: {
-			key: "r:id",
-			value: `rId${linkId}`
-		} }),
+		attributes: {
+			...hasXmlNs ? { xmlns: {
+				key: "xmlns:a",
+				value: "http://schemas.openxmlformats.org/drawingml/2006/main"
+			} } : {},
+			id: {
+				key: "r:id",
+				value: `rId${linkId}`
+			}
+		},
 		name: "a:hlinkClick"
 	});
 	//#endregion
@@ -4992,21 +4974,23 @@
 			super("a:graphicData");
 			if (mediaData.type === "wps") {
 				this.root.push(new GraphicDataAttributes({ uri: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape" }));
-				const wps = createWpsShape(_objectSpread2(_objectSpread2({}, mediaData.data), {}, {
+				const wps = createWpsShape({
+					...mediaData.data,
 					outline,
 					solidFill,
 					transformation: transform
-				}));
+				});
 				this.root.push(wps);
 			} else if (mediaData.type === "wpg") {
 				this.root.push(new GraphicDataAttributes({ uri: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup" }));
 				const wpg = createWpgGroup({
 					children: mediaData.children.map((child) => {
-						if (child.type === "wps") return createWpsShape(_objectSpread2(_objectSpread2({}, child.data), {}, {
+						if (child.type === "wps") return createWpsShape({
+							...child.data,
 							outline: child.outline,
 							solidFill: child.solidFill,
 							transformation: child.transformation
-						}));
+						});
 						else return new Pic({
 							mediaData: child,
 							outline: child.outline,
@@ -5635,14 +5619,15 @@
 	var Anchor = class extends XmlComponent {
 		constructor({ mediaData, transform, drawingOptions }) {
 			super("wp:anchor");
-			const floating = _objectSpread2({
+			const floating = {
 				allowOverlap: true,
 				behindDocument: false,
 				horizontalPosition: {},
 				layoutInCell: true,
 				lockAnchor: false,
-				verticalPosition: {}
-			}, drawingOptions.floating);
+				verticalPosition: {},
+				...drawingOptions.floating
+			};
 			this.root.push(new AnchorAttributes({
 				distT: floating.margins ? floating.margins.top || 0 : 0,
 				distB: floating.margins ? floating.margins.bottom || 0 : 0,
@@ -5828,8 +5813,18 @@
 			const key = `${hashedId(rawData)}.${options.type}`;
 			if (options.type === "svg") {
 				const fallbackData = (0, undio.toUint8Array)(options.fallback.data);
-				this.imageData = _objectSpread2(_objectSpread2({ type: options.type }, createImageData(rawData, options.transformation, key)), {}, { fallback: _objectSpread2({ type: options.fallback.type }, createImageData(fallbackData, options.transformation, `${hashedId(fallbackData)}.${options.fallback.type}`)) });
-			} else this.imageData = _objectSpread2({ type: options.type }, createImageData(rawData, options.transformation, key));
+				this.imageData = {
+					type: options.type,
+					...createImageData(rawData, options.transformation, key),
+					fallback: {
+						type: options.fallback.type,
+						...createImageData(fallbackData, options.transformation, `${hashedId(fallbackData)}.${options.fallback.type}`)
+					}
+				};
+			} else this.imageData = {
+				type: options.type,
+				...createImageData(rawData, options.transformation, key)
+			};
 			const drawing = new Drawing(this.imageData, {
 				docProperties: options.altText,
 				floating: options.floating,
@@ -5878,7 +5873,7 @@
 			super({});
 			_defineProperty(this, "wpsShapeData", void 0);
 			this.wpsShapeData = {
-				data: _objectSpread2({}, options),
+				data: { ...options },
 				transformation: createTransformation(options.transformation),
 				type: options.type
 			};
@@ -7905,13 +7900,16 @@
 	* Creates a font relationship element for embedding fonts.
 	*/
 	const createFontRelationship = ({ id, fontKey, subsetted }, name) => new BuilderElement({
-		attributes: _objectSpread2({ id: {
-			key: "r:id",
-			value: id
-		} }, fontKey ? { fontKey: {
-			key: "w:fontKey",
-			value: `{${fontKey}}`
-		} } : {}),
+		attributes: {
+			id: {
+				key: "r:id",
+				value: id
+			},
+			...fontKey ? { fontKey: {
+				key: "w:fontKey",
+				value: `{${fontKey}}`
+			} } : {}
+		},
 		children: subsetted ? [new OnOffElement("w:subsetted", subsetted)] : [],
 		name
 	});
@@ -8149,7 +8147,10 @@
 			_defineProperty(this, "fontTable", void 0);
 			_defineProperty(this, "relationships", void 0);
 			_defineProperty(this, "fontOptionsWithKey", []);
-			this.fontOptionsWithKey = options.map((o) => _objectSpread2(_objectSpread2({}, o), {}, { fontKey: uniqueUuid() }));
+			this.fontOptionsWithKey = options.map((o) => ({
+				...o,
+				fontKey: uniqueUuid()
+			}));
 			this.fontTable = createFontTable(this.fontOptionsWithKey);
 			this.relationships = new Relationships();
 			for (let i = 0; i < options.length; i++) this.relationships.addRelationship(i + 1, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/font", `fonts/${options[i].name}.odttf`);
@@ -8567,7 +8568,10 @@
 				date: options.date,
 				id: options.id
 			}));
-			this.root.push(new ParagraphProperties(_objectSpread2(_objectSpread2({}, options), {}, { includeIfEmpty: true })));
+			this.root.push(new ParagraphProperties({
+				...options,
+				includeIfEmpty: true
+			}));
 		}
 	};
 	//#endregion
@@ -10782,7 +10786,10 @@
 	*
 	* @publicApi
 	*/
-	const VerticalAlignSection = _objectSpread2(_objectSpread2({}, VerticalAlignTable), {}, { BOTH: "both" });
+	const VerticalAlignSection = {
+		...VerticalAlignTable,
+		BOTH: "both"
+	};
 	/**
 	* @deprecated Use {@link VerticalAlignTable} for table cells or
 	* {@link VerticalAlignSection} for section properties. This alias remains for
@@ -11299,7 +11306,10 @@
 				date: options.date,
 				id: options.id
 			}));
-			this.root.push(new TableCellProperties(_objectSpread2(_objectSpread2({}, options), {}, { includeIfEmpty: true })));
+			this.root.push(new TableCellProperties({
+				...options,
+				includeIfEmpty: true
+			}));
 		}
 	};
 	//#endregion
@@ -11843,7 +11853,10 @@
 				date: options.date,
 				id: options.id
 			}));
-			this.root.push(new TableProperties(_objectSpread2(_objectSpread2({}, options), {}, { includeIfEmpty: true })));
+			this.root.push(new TableProperties({
+				...options,
+				includeIfEmpty: true
+			}));
 		}
 	};
 	//#endregion
@@ -12088,7 +12101,10 @@
 				date: options.date,
 				id: options.id
 			}));
-			this.root.push(new TableRowProperties(_objectSpread2(_objectSpread2({}, options), {}, { includeIfEmpty: true })));
+			this.root.push(new TableRowProperties({
+				...options,
+				includeIfEmpty: true
+			}));
 		}
 	};
 	//#endregion
@@ -12487,8 +12503,14 @@
 	*/
 	var DocumentAttributes = class extends XmlAttributeComponent {
 		constructor(ns, Ignorable) {
-			super(_objectSpread2({ Ignorable }, Object.fromEntries(ns.map((n) => [n, DocumentAttributeNamespaces[n]]))));
-			_defineProperty(this, "xmlKeys", _objectSpread2({ Ignorable: "mc:Ignorable" }, Object.fromEntries(Object.keys(DocumentAttributeNamespaces).map((key) => [key, `xmlns:${key}`]))));
+			super({
+				Ignorable,
+				...Object.fromEntries(ns.map((n) => [n, DocumentAttributeNamespaces[n]]))
+			});
+			_defineProperty(this, "xmlKeys", {
+				Ignorable: "mc:Ignorable",
+				...Object.fromEntries(Object.keys(DocumentAttributeNamespaces).map((key) => [key, `xmlns:${key}`]))
+			});
 		}
 	};
 	//#endregion
@@ -16168,7 +16190,10 @@
 			if (((_options$hyphenation2 = options.hyphenation) === null || _options$hyphenation2 === void 0 ? void 0 : _options$hyphenation2.hyphenationZone) !== void 0) this.root.push(new NumberValueElement("w:hyphenationZone", options.hyphenation.hyphenationZone));
 			if (((_options$hyphenation3 = options.hyphenation) === null || _options$hyphenation3 === void 0 ? void 0 : _options$hyphenation3.consecutiveHyphenLimit) !== void 0) this.root.push(new NumberValueElement("w:consecutiveHyphenLimit", options.hyphenation.consecutiveHyphenLimit));
 			if (((_options$hyphenation4 = options.hyphenation) === null || _options$hyphenation4 === void 0 ? void 0 : _options$hyphenation4.doNotHyphenateCaps) !== void 0) this.root.push(new OnOffElement("w:doNotHyphenateCaps", options.hyphenation.doNotHyphenateCaps));
-			this.root.push(new Compatibility(_objectSpread2(_objectSpread2({}, options.compatibility), {}, { version: (_ref = (_options$compatibilit = (_options$compatibilit2 = options.compatibility) === null || _options$compatibilit2 === void 0 ? void 0 : _options$compatibilit2.version) !== null && _options$compatibilit !== void 0 ? _options$compatibilit : options.compatibilityModeVersion) !== null && _ref !== void 0 ? _ref : 15 })));
+			this.root.push(new Compatibility({
+				...options.compatibility,
+				version: (_ref = (_options$compatibilit = (_options$compatibilit2 = options.compatibility) === null || _options$compatibilit2 === void 0 ? void 0 : _options$compatibilit2.version) !== null && _options$compatibilit !== void 0 ? _options$compatibilit : options.compatibilityModeVersion) !== null && _ref !== void 0 ? _ref : 15
+			}));
 		}
 	};
 	//#endregion
@@ -16437,10 +16462,11 @@
 			super({
 				styleId: options.id,
 				type: "character"
-			}, _objectSpread2({
+			}, {
 				uiPriority: 99,
-				unhideWhenUsed: true
-			}, options));
+				unhideWhenUsed: true,
+				...options
+			});
 			_defineProperty(this, "runProperties", void 0);
 			this.runProperties = new RunProperties(options.run);
 			this.root.push(this.runProperties);
@@ -16476,11 +16502,12 @@
 	*/
 	var HeadingStyle = class extends StyleForParagraph {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "Normal",
 				next: "Normal",
-				quickFormat: true
-			}, options));
+				quickFormat: true,
+				...options
+			});
 		}
 	};
 	/**
@@ -16497,10 +16524,11 @@
 	*/
 	var TitleStyle = class extends HeadingStyle {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				id: "Title",
-				name: "Title"
-			}, options));
+				name: "Title",
+				...options
+			});
 		}
 	};
 	/**
@@ -16517,10 +16545,11 @@
 	*/
 	var Heading1Style = class extends HeadingStyle {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				id: "Heading1",
-				name: "Heading 1"
-			}, options));
+				name: "Heading 1",
+				...options
+			});
 		}
 	};
 	/**
@@ -16530,10 +16559,11 @@
 	*/
 	var Heading2Style = class extends HeadingStyle {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				id: "Heading2",
-				name: "Heading 2"
-			}, options));
+				name: "Heading 2",
+				...options
+			});
 		}
 	};
 	/**
@@ -16543,10 +16573,11 @@
 	*/
 	var Heading3Style = class extends HeadingStyle {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				id: "Heading3",
-				name: "Heading 3"
-			}, options));
+				name: "Heading 3",
+				...options
+			});
 		}
 	};
 	/**
@@ -16556,10 +16587,11 @@
 	*/
 	var Heading4Style = class extends HeadingStyle {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				id: "Heading4",
-				name: "Heading 4"
-			}, options));
+				name: "Heading 4",
+				...options
+			});
 		}
 	};
 	/**
@@ -16569,10 +16601,11 @@
 	*/
 	var Heading5Style = class extends HeadingStyle {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				id: "Heading5",
-				name: "Heading 5"
-			}, options));
+				name: "Heading 5",
+				...options
+			});
 		}
 	};
 	/**
@@ -16582,10 +16615,11 @@
 	*/
 	var Heading6Style = class extends HeadingStyle {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				id: "Heading6",
-				name: "Heading 6"
-			}, options));
+				name: "Heading 6",
+				...options
+			});
 		}
 	};
 	/**
@@ -16595,10 +16629,11 @@
 	*/
 	var StrongStyle = class extends HeadingStyle {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				id: "Strong",
-				name: "Strong"
-			}, options));
+				name: "Strong",
+				...options
+			});
 		}
 	};
 	/**
@@ -16608,12 +16643,13 @@
 	*/
 	var ListParagraph = class extends StyleForParagraph {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "Normal",
 				id: "ListParagraph",
 				name: "List Paragraph",
-				quickFormat: true
-			}, options));
+				quickFormat: true,
+				...options
+			});
 		}
 	};
 	/**
@@ -16623,7 +16659,7 @@
 	*/
 	var FootnoteText = class extends StyleForParagraph {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "Normal",
 				id: "FootnoteText",
 				link: "FootnoteTextChar",
@@ -16636,8 +16672,9 @@
 				run: { size: 20 },
 				semiHidden: true,
 				uiPriority: 99,
-				unhideWhenUsed: true
-			}, options));
+				unhideWhenUsed: true,
+				...options
+			});
 		}
 	};
 	/**
@@ -16647,13 +16684,14 @@
 	*/
 	var FootnoteReferenceStyle = class extends StyleForCharacter {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "DefaultParagraphFont",
 				id: "FootnoteReference",
 				name: "footnote reference",
 				run: { superScript: true },
-				semiHidden: true
-			}, options));
+				semiHidden: true,
+				...options
+			});
 		}
 	};
 	/**
@@ -16663,14 +16701,15 @@
 	*/
 	var FootnoteTextChar = class extends StyleForCharacter {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "DefaultParagraphFont",
 				id: "FootnoteTextChar",
 				link: "FootnoteText",
 				name: "Footnote Text Char",
 				run: { size: 20 },
-				semiHidden: true
-			}, options));
+				semiHidden: true,
+				...options
+			});
 		}
 	};
 	/**
@@ -16680,7 +16719,7 @@
 	*/
 	var EndnoteText = class extends StyleForParagraph {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "Normal",
 				id: "EndnoteText",
 				link: "EndnoteTextChar",
@@ -16693,8 +16732,9 @@
 				run: { size: 20 },
 				semiHidden: true,
 				uiPriority: 99,
-				unhideWhenUsed: true
-			}, options));
+				unhideWhenUsed: true,
+				...options
+			});
 		}
 	};
 	/**
@@ -16704,13 +16744,14 @@
 	*/
 	var EndnoteReferenceStyle = class extends StyleForCharacter {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "DefaultParagraphFont",
 				id: "EndnoteReference",
 				name: "endnote reference",
 				run: { superScript: true },
-				semiHidden: true
-			}, options));
+				semiHidden: true,
+				...options
+			});
 		}
 	};
 	/**
@@ -16720,14 +16761,15 @@
 	*/
 	var EndnoteTextChar = class extends StyleForCharacter {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "DefaultParagraphFont",
 				id: "EndnoteTextChar",
 				link: "EndnoteText",
 				name: "Endnote Text Char",
 				run: { size: 20 },
-				semiHidden: true
-			}, options));
+				semiHidden: true,
+				...options
+			});
 		}
 	};
 	/**
@@ -16737,15 +16779,16 @@
 	*/
 	var HyperlinkStyle = class extends StyleForCharacter {
 		constructor(options) {
-			super(_objectSpread2({
+			super({
 				basedOn: "DefaultParagraphFont",
 				id: "Hyperlink",
 				name: "Hyperlink",
 				run: {
 					color: "0563C1",
 					underline: { type: UnderlineType.SINGLE }
-				}
-			}, options));
+				},
+				...options
+			});
 		}
 	};
 	//#endregion
@@ -17015,26 +17058,50 @@
 			return {
 				importedStyles: [
 					new DocumentDefaults((_options$document = options.document) !== null && _options$document !== void 0 ? _options$document : {}),
-					new TitleStyle(_objectSpread2({ run: { size: 56 } }, options.title)),
-					new Heading1Style(_objectSpread2({ run: {
-						color: "2E74B5",
-						size: 32
-					} }, options.heading1)),
-					new Heading2Style(_objectSpread2({ run: {
-						color: "2E74B5",
-						size: 26
-					} }, options.heading2)),
-					new Heading3Style(_objectSpread2({ run: {
-						color: "1F4D78",
-						size: 24
-					} }, options.heading3)),
-					new Heading4Style(_objectSpread2({ run: {
-						color: "2E74B5",
-						italics: true
-					} }, options.heading4)),
-					new Heading5Style(_objectSpread2({ run: { color: "2E74B5" } }, options.heading5)),
-					new Heading6Style(_objectSpread2({ run: { color: "1F4D78" } }, options.heading6)),
-					new StrongStyle(_objectSpread2({ run: { bold: true } }, options.strong)),
+					new TitleStyle({
+						run: { size: 56 },
+						...options.title
+					}),
+					new Heading1Style({
+						run: {
+							color: "2E74B5",
+							size: 32
+						},
+						...options.heading1
+					}),
+					new Heading2Style({
+						run: {
+							color: "2E74B5",
+							size: 26
+						},
+						...options.heading2
+					}),
+					new Heading3Style({
+						run: {
+							color: "1F4D78",
+							size: 24
+						},
+						...options.heading3
+					}),
+					new Heading4Style({
+						run: {
+							color: "2E74B5",
+							italics: true
+						},
+						...options.heading4
+					}),
+					new Heading5Style({
+						run: { color: "2E74B5" },
+						...options.heading5
+					}),
+					new Heading6Style({
+						run: { color: "1F4D78" },
+						...options.heading6
+					}),
+					new StrongStyle({
+						run: { bold: true },
+						...options.strong
+					}),
 					new ListParagraph(options.listParagraph || {}),
 					new HyperlinkStyle(options.hyperlink || {}),
 					new FootnoteReferenceStyle(options.footnoteReference || {}),
@@ -17152,11 +17219,12 @@
 			_defineProperty(this, "styles", void 0);
 			_defineProperty(this, "comments", void 0);
 			_defineProperty(this, "fontWrapper", void 0);
-			this.coreProperties = new CoreProperties(_objectSpread2(_objectSpread2({}, options), {}, {
+			this.coreProperties = new CoreProperties({
+				...options,
 				creator: (_options$creator = options.creator) !== null && _options$creator !== void 0 ? _options$creator : "Un-named",
 				lastModifiedBy: (_options$lastModified = options.lastModifiedBy) !== null && _options$lastModified !== void 0 ? _options$lastModified : "Un-named",
 				revision: (_options$revision = options.revision) !== null && _options$revision !== void 0 ? _options$revision : 1
-			}));
+			});
 			this.numbering = new Numbering(options.numbering ? options.numbering : { config: [] });
 			this.comments = new Comments((_options$comments = options.comments) !== null && _options$comments !== void 0 ? _options$comments : { children: [] });
 			this.fileRelationships = new Relationships();
@@ -17185,8 +17253,14 @@
 				var _options$styles;
 				const defaultStyles = new DefaultStylesFactory().newInstance((_options$styles = options.styles) === null || _options$styles === void 0 ? void 0 : _options$styles.default);
 				const externalStyles = new ExternalStylesFactory().newInstance(options.externalStyles);
-				this.styles = new Styles(_objectSpread2(_objectSpread2({}, externalStyles), {}, { importedStyles: [...defaultStyles.importedStyles, ...externalStyles.importedStyles] }));
-			} else if (options.styles) this.styles = new Styles(_objectSpread2(_objectSpread2({}, new DefaultStylesFactory().newInstance(options.styles.default)), options.styles));
+				this.styles = new Styles({
+					...externalStyles,
+					importedStyles: [...defaultStyles.importedStyles, ...externalStyles.importedStyles]
+				});
+			} else if (options.styles) this.styles = new Styles({
+				...new DefaultStylesFactory().newInstance(options.styles.default),
+				...options.styles
+			});
 			else this.styles = new Styles(new DefaultStylesFactory().newInstance());
 			this.addDefaultRelationships();
 			for (const section of options.sections) this.addSection(section);
@@ -17195,7 +17269,8 @@
 			this.fontWrapper = new FontWrapper((_options$fonts = options.fonts) !== null && _options$fonts !== void 0 ? _options$fonts : []);
 		}
 		addSection({ headers = {}, footers = {}, children, properties }) {
-			this.documentWrapper.View.Body.addSection(_objectSpread2(_objectSpread2({}, properties), {}, {
+			this.documentWrapper.View.Body.addSection({
+				...properties,
 				footerWrapperGroup: {
 					default: footers.default ? this.createFooter(footers.default) : void 0,
 					even: footers.even ? this.createFooter(footers.even) : void 0,
@@ -17206,7 +17281,7 @@
 					even: headers.even ? this.createHeader(headers.even) : void 0,
 					first: headers.first ? this.createHeader(headers.first) : void 0
 				}
-			}));
+			});
 			for (const child of children) this.documentWrapper.View.add(child);
 		}
 		createHeader(header) {
@@ -17463,28 +17538,6 @@
 		}
 	};
 	//#endregion
-	//#region \0@oxc-project+runtime@0.123.0/helpers/objectWithoutPropertiesLoose.js
-	function _objectWithoutPropertiesLoose(r, e) {
-		if (null == r) return {};
-		var t = {};
-		for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
-			if (e.includes(n)) continue;
-			t[n] = r[n];
-		}
-		return t;
-	}
-	//#endregion
-	//#region \0@oxc-project+runtime@0.123.0/helpers/objectWithoutProperties.js
-	function _objectWithoutProperties(e, t) {
-		if (null == e) return {};
-		var o, r, i = _objectWithoutPropertiesLoose(e, t);
-		if (Object.getOwnPropertySymbols) {
-			var s = Object.getOwnPropertySymbols(e);
-			for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
-		}
-		return i;
-	}
-	//#endregion
 	//#region src/file/table-of-contents/table-of-contents.ts
 	/**
 	* Table of Contents module for WordprocessingML documents.
@@ -17496,11 +17549,6 @@
 	*
 	* @module
 	*/
-	const _excluded$1 = [
-		"contentChildren",
-		"cachedEntries",
-		"beginDirty"
-	];
 	/**
 	* Represents a Table of Contents in a WordprocessingML document.
 	*
@@ -17531,8 +17579,7 @@
 	* ```
 	*/
 	var TableOfContents = class extends FileChild {
-		constructor(alias = "Table of Contents", _ref = {}) {
-			let { contentChildren = [], cachedEntries = [], beginDirty = true } = _ref, properties = _objectWithoutProperties(_ref, _excluded$1);
+		constructor(alias = "Table of Contents", { contentChildren = [], cachedEntries = [], beginDirty = true, ...properties } = {}) {
 			super("w:sdt");
 			this.root.push(new StructuredDocumentTagProperties(alias));
 			const content = new StructuredDocumentTagContent();
@@ -18228,7 +18275,6 @@
 	*
 	* @module
 	*/
-	const _excluded = ["style", "children"];
 	/**
 	* Represents a textbox in a WordprocessingML document.
 	*
@@ -18278,8 +18324,7 @@
 	* ```
 	*/
 	var Textbox = class extends FileChild {
-		constructor(_ref) {
-			let { style, children } = _ref, rest = _objectWithoutProperties(_ref, _excluded);
+		constructor({ style, children, ...rest }) {
 			super("w:p");
 			this.root.push(new ParagraphProperties(rest));
 			this.root.push(createPictElement({ shape: createShape({
@@ -18290,118 +18335,3254 @@
 		}
 	};
 	//#endregion
-	//#region src/util/output-type.ts
-	/**
-	* Output type definitions for document generation.
-	*
-	* This module defines the various output formats supported when generating
-	* .docx files. These types correspond to fflate's output formats.
-	*
-	* @module
-	*/
-	/**
-	* Converts a Uint8Array to the specified output type.
-	*
-	* This is used by both the Packer and patchDocument to convert fflate's
-	* raw Uint8Array output into the user's requested format.
-	*/
-	const convertOutput = (data, type) => {
-		switch (type) {
-			case "nodebuffer": return Buffer.from(data);
-			case "blob": return new Blob([data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)], { type: "application/vnd.openxmlformats-officedocument.wordprocessingml.document" });
-			case "arraybuffer": return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-			case "uint8array": return data;
-			case "base64": return btoa((0, fflate.strFromU8)(data, true));
-			case "string":
-			case "text":
-			case "binarystring": return (0, fflate.strFromU8)(data, true);
-			case "array": return [...data];
-			default: return data;
+	//#region \0polyfill-node.events.js
+	var domain;
+	function EventHandlers() {}
+	EventHandlers.prototype = Object.create(null);
+	function EventEmitter() {
+		EventEmitter.init.call(this);
+	}
+	EventEmitter.EventEmitter = EventEmitter;
+	EventEmitter.usingDomains = false;
+	EventEmitter.prototype.domain = void 0;
+	EventEmitter.prototype._events = void 0;
+	EventEmitter.prototype._maxListeners = void 0;
+	EventEmitter.defaultMaxListeners = 10;
+	EventEmitter.init = function() {
+		this.domain = null;
+		if (EventEmitter.usingDomains) {
+			if (domain.active && !(this instanceof domain.Domain)) this.domain = domain.active;
+		}
+		if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
+			this._events = new EventHandlers();
+			this._eventsCount = 0;
+		}
+		this._maxListeners = this._maxListeners || void 0;
+	};
+	EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+		if (typeof n !== "number" || n < 0 || isNaN(n)) throw new TypeError("\"n\" argument must be a positive number");
+		this._maxListeners = n;
+		return this;
+	};
+	function $getMaxListeners(that) {
+		if (that._maxListeners === void 0) return EventEmitter.defaultMaxListeners;
+		return that._maxListeners;
+	}
+	EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+		return $getMaxListeners(this);
+	};
+	function emitNone(handler, isFn, self) {
+		if (isFn) handler.call(self);
+		else {
+			var len = handler.length;
+			var listeners = arrayClone(handler, len);
+			for (var i = 0; i < len; ++i) listeners[i].call(self);
+		}
+	}
+	function emitOne(handler, isFn, self, arg1) {
+		if (isFn) handler.call(self, arg1);
+		else {
+			var len = handler.length;
+			var listeners = arrayClone(handler, len);
+			for (var i = 0; i < len; ++i) listeners[i].call(self, arg1);
+		}
+	}
+	function emitTwo(handler, isFn, self, arg1, arg2) {
+		if (isFn) handler.call(self, arg1, arg2);
+		else {
+			var len = handler.length;
+			var listeners = arrayClone(handler, len);
+			for (var i = 0; i < len; ++i) listeners[i].call(self, arg1, arg2);
+		}
+	}
+	function emitThree(handler, isFn, self, arg1, arg2, arg3) {
+		if (isFn) handler.call(self, arg1, arg2, arg3);
+		else {
+			var len = handler.length;
+			var listeners = arrayClone(handler, len);
+			for (var i = 0; i < len; ++i) listeners[i].call(self, arg1, arg2, arg3);
+		}
+	}
+	function emitMany(handler, isFn, self, args) {
+		if (isFn) handler.apply(self, args);
+		else {
+			var len = handler.length;
+			var listeners = arrayClone(handler, len);
+			for (var i = 0; i < len; ++i) listeners[i].apply(self, args);
+		}
+	}
+	EventEmitter.prototype.emit = function emit(type) {
+		var er, handler, len, args, i, events, domain;
+		var needDomainExit = false;
+		var doError = type === "error";
+		events = this._events;
+		if (events) doError = doError && events.error == null;
+		else if (!doError) return false;
+		domain = this.domain;
+		if (doError) {
+			er = arguments[1];
+			if (domain) {
+				if (!er) er = /* @__PURE__ */ new Error("Uncaught, unspecified \"error\" event");
+				er.domainEmitter = this;
+				er.domain = domain;
+				er.domainThrown = false;
+				domain.emit("error", er);
+			} else if (er instanceof Error) throw er;
+			else {
+				var err = /* @__PURE__ */ new Error("Uncaught, unspecified \"error\" event. (" + er + ")");
+				err.context = er;
+				throw err;
+			}
+			return false;
+		}
+		handler = events[type];
+		if (!handler) return false;
+		var isFn = typeof handler === "function";
+		len = arguments.length;
+		switch (len) {
+			case 1:
+				emitNone(handler, isFn, this);
+				break;
+			case 2:
+				emitOne(handler, isFn, this, arguments[1]);
+				break;
+			case 3:
+				emitTwo(handler, isFn, this, arguments[1], arguments[2]);
+				break;
+			case 4:
+				emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
+				break;
+			default:
+				args = new Array(len - 1);
+				for (i = 1; i < len; i++) args[i - 1] = arguments[i];
+				emitMany(handler, isFn, this, args);
+		}
+		if (needDomainExit) domain.exit();
+		return true;
+	};
+	function _addListener(target, type, listener, prepend) {
+		var m;
+		var events;
+		var existing;
+		if (typeof listener !== "function") throw new TypeError("\"listener\" argument must be a function");
+		events = target._events;
+		if (!events) {
+			events = target._events = new EventHandlers();
+			target._eventsCount = 0;
+		} else {
+			if (events.newListener) {
+				target.emit("newListener", type, listener.listener ? listener.listener : listener);
+				events = target._events;
+			}
+			existing = events[type];
+		}
+		if (!existing) {
+			existing = events[type] = listener;
+			++target._eventsCount;
+		} else {
+			if (typeof existing === "function") existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+			else if (prepend) existing.unshift(listener);
+			else existing.push(listener);
+			if (!existing.warned) {
+				m = $getMaxListeners(target);
+				if (m && m > 0 && existing.length > m) {
+					existing.warned = true;
+					var w = /* @__PURE__ */ new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + type + " listeners added. Use emitter.setMaxListeners() to increase limit");
+					w.name = "MaxListenersExceededWarning";
+					w.emitter = target;
+					w.type = type;
+					w.count = existing.length;
+					emitWarning(w);
+				}
+			}
+		}
+		return target;
+	}
+	function emitWarning(e) {
+		typeof console.warn === "function" ? console.warn(e) : console.log(e);
+	}
+	EventEmitter.prototype.addListener = function addListener(type, listener) {
+		return _addListener(this, type, listener, false);
+	};
+	EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+	EventEmitter.prototype.prependListener = function prependListener(type, listener) {
+		return _addListener(this, type, listener, true);
+	};
+	function _onceWrap(target, type, listener) {
+		var fired = false;
+		function g() {
+			target.removeListener(type, g);
+			if (!fired) {
+				fired = true;
+				listener.apply(target, arguments);
+			}
+		}
+		g.listener = listener;
+		return g;
+	}
+	EventEmitter.prototype.once = function once(type, listener) {
+		if (typeof listener !== "function") throw new TypeError("\"listener\" argument must be a function");
+		this.on(type, _onceWrap(this, type, listener));
+		return this;
+	};
+	EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+		if (typeof listener !== "function") throw new TypeError("\"listener\" argument must be a function");
+		this.prependListener(type, _onceWrap(this, type, listener));
+		return this;
+	};
+	EventEmitter.prototype.removeListener = function removeListener(type, listener) {
+		var list, events, position, i, originalListener;
+		if (typeof listener !== "function") throw new TypeError("\"listener\" argument must be a function");
+		events = this._events;
+		if (!events) return this;
+		list = events[type];
+		if (!list) return this;
+		if (list === listener || list.listener && list.listener === listener) if (--this._eventsCount === 0) this._events = new EventHandlers();
+		else {
+			delete events[type];
+			if (events.removeListener) this.emit("removeListener", type, list.listener || listener);
+		}
+		else if (typeof list !== "function") {
+			position = -1;
+			for (i = list.length; i-- > 0;) if (list[i] === listener || list[i].listener && list[i].listener === listener) {
+				originalListener = list[i].listener;
+				position = i;
+				break;
+			}
+			if (position < 0) return this;
+			if (list.length === 1) {
+				list[0] = void 0;
+				if (--this._eventsCount === 0) {
+					this._events = new EventHandlers();
+					return this;
+				} else delete events[type];
+			} else spliceOne(list, position);
+			if (events.removeListener) this.emit("removeListener", type, originalListener || listener);
+		}
+		return this;
+	};
+	EventEmitter.prototype.off = function(type, listener) {
+		return this.removeListener(type, listener);
+	};
+	EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+		var listeners, events = this._events;
+		if (!events) return this;
+		if (!events.removeListener) {
+			if (arguments.length === 0) {
+				this._events = new EventHandlers();
+				this._eventsCount = 0;
+			} else if (events[type]) if (--this._eventsCount === 0) this._events = new EventHandlers();
+			else delete events[type];
+			return this;
 		}
+		if (arguments.length === 0) {
+			var keys = Object.keys(events);
+			for (var i = 0, key; i < keys.length; ++i) {
+				key = keys[i];
+				if (key === "removeListener") continue;
+				this.removeAllListeners(key);
+			}
+			this.removeAllListeners("removeListener");
+			this._events = new EventHandlers();
+			this._eventsCount = 0;
+			return this;
+		}
+		listeners = events[type];
+		if (typeof listeners === "function") this.removeListener(type, listeners);
+		else if (listeners) do
+			this.removeListener(type, listeners[listeners.length - 1]);
+		while (listeners[0]);
+		return this;
+	};
+	EventEmitter.prototype.listeners = function listeners(type) {
+		var evlistener;
+		var ret;
+		var events = this._events;
+		if (!events) ret = [];
+		else {
+			evlistener = events[type];
+			if (!evlistener) ret = [];
+			else if (typeof evlistener === "function") ret = [evlistener.listener || evlistener];
+			else ret = unwrapListeners(evlistener);
+		}
+		return ret;
+	};
+	EventEmitter.listenerCount = function(emitter, type) {
+		if (typeof emitter.listenerCount === "function") return emitter.listenerCount(type);
+		else return listenerCount$1.call(emitter, type);
+	};
+	EventEmitter.prototype.listenerCount = listenerCount$1;
+	function listenerCount$1(type) {
+		var events = this._events;
+		if (events) {
+			var evlistener = events[type];
+			if (typeof evlistener === "function") return 1;
+			else if (evlistener) return evlistener.length;
+		}
+		return 0;
+	}
+	EventEmitter.prototype.eventNames = function eventNames() {
+		return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
 	};
+	function spliceOne(list, index) {
+		for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) list[i] = list[k];
+		list.pop();
+	}
+	function arrayClone(arr, i) {
+		var copy = new Array(i);
+		while (i--) copy[i] = arr[i];
+		return copy;
+	}
+	function unwrapListeners(arr) {
+		var ret = new Array(arr.length);
+		for (var i = 0; i < ret.length; ++i) ret[i] = arr[i].listener || arr[i];
+		return ret;
+	}
 	//#endregion
-	//#region src/file/fonts/obfuscate-ttf-to-odttf.ts
+	//#region \0polyfill-node.global.js
+	var _polyfill_node_global_default = typeof _polyfill_node_global_default !== "undefined" ? _polyfill_node_global_default : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
+	//#endregion
+	//#region \0polyfill-node.buffer.js
+	var lookup = [];
+	var revLookup = [];
+	var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+	var inited = false;
+	function init() {
+		inited = true;
+		var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+		for (var i = 0, len = code.length; i < len; ++i) {
+			lookup[i] = code[i];
+			revLookup[code.charCodeAt(i)] = i;
+		}
+		revLookup["-".charCodeAt(0)] = 62;
+		revLookup["_".charCodeAt(0)] = 63;
+	}
+	function toByteArray(b64) {
+		if (!inited) init();
+		var i, j, l, tmp, placeHolders, arr;
+		var len = b64.length;
+		if (len % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
+		placeHolders = b64[len - 2] === "=" ? 2 : b64[len - 1] === "=" ? 1 : 0;
+		arr = new Arr(len * 3 / 4 - placeHolders);
+		l = placeHolders > 0 ? len - 4 : len;
+		var L = 0;
+		for (i = 0, j = 0; i < l; i += 4, j += 3) {
+			tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+			arr[L++] = tmp >> 16 & 255;
+			arr[L++] = tmp >> 8 & 255;
+			arr[L++] = tmp & 255;
+		}
+		if (placeHolders === 2) {
+			tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+			arr[L++] = tmp & 255;
+		} else if (placeHolders === 1) {
+			tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+			arr[L++] = tmp >> 8 & 255;
+			arr[L++] = tmp & 255;
+		}
+		return arr;
+	}
+	function tripletToBase64(num) {
+		return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+	}
+	function encodeChunk(uint8, start, end) {
+		var tmp;
+		var output = [];
+		for (var i = start; i < end; i += 3) {
+			tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
+			output.push(tripletToBase64(tmp));
+		}
+		return output.join("");
+	}
+	function fromByteArray(uint8) {
+		if (!inited) init();
+		var tmp;
+		var len = uint8.length;
+		var extraBytes = len % 3;
+		var output = "";
+		var parts = [];
+		var maxChunkLength = 16383;
+		for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
+		if (extraBytes === 1) {
+			tmp = uint8[len - 1];
+			output += lookup[tmp >> 2];
+			output += lookup[tmp << 4 & 63];
+			output += "==";
+		} else if (extraBytes === 2) {
+			tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+			output += lookup[tmp >> 10];
+			output += lookup[tmp >> 4 & 63];
+			output += lookup[tmp << 2 & 63];
+			output += "=";
+		}
+		parts.push(output);
+		return parts.join("");
+	}
+	function read(buffer, offset, isLE, mLen, nBytes) {
+		var e, m;
+		var eLen = nBytes * 8 - mLen - 1;
+		var eMax = (1 << eLen) - 1;
+		var eBias = eMax >> 1;
+		var nBits = -7;
+		var i = isLE ? nBytes - 1 : 0;
+		var d = isLE ? -1 : 1;
+		var s = buffer[offset + i];
+		i += d;
+		e = s & (1 << -nBits) - 1;
+		s >>= -nBits;
+		nBits += eLen;
+		for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
+		m = e & (1 << -nBits) - 1;
+		e >>= -nBits;
+		nBits += mLen;
+		for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
+		if (e === 0) e = 1 - eBias;
+		else if (e === eMax) return m ? NaN : (s ? -1 : 1) * Infinity;
+		else {
+			m = m + Math.pow(2, mLen);
+			e = e - eBias;
+		}
+		return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+	}
+	function write(buffer, value, offset, isLE, mLen, nBytes) {
+		var e, m, c;
+		var eLen = nBytes * 8 - mLen - 1;
+		var eMax = (1 << eLen) - 1;
+		var eBias = eMax >> 1;
+		var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+		var i = isLE ? 0 : nBytes - 1;
+		var d = isLE ? 1 : -1;
+		var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+		value = Math.abs(value);
+		if (isNaN(value) || value === Infinity) {
+			m = isNaN(value) ? 1 : 0;
+			e = eMax;
+		} else {
+			e = Math.floor(Math.log(value) / Math.LN2);
+			if (value * (c = Math.pow(2, -e)) < 1) {
+				e--;
+				c *= 2;
+			}
+			if (e + eBias >= 1) value += rt / c;
+			else value += rt * Math.pow(2, 1 - eBias);
+			if (value * c >= 2) {
+				e++;
+				c /= 2;
+			}
+			if (e + eBias >= eMax) {
+				m = 0;
+				e = eMax;
+			} else if (e + eBias >= 1) {
+				m = (value * c - 1) * Math.pow(2, mLen);
+				e = e + eBias;
+			} else {
+				m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+				e = 0;
+			}
+		}
+		for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8);
+		e = e << mLen | m;
+		eLen += mLen;
+		for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8);
+		buffer[offset + i - d] |= s * 128;
+	}
+	var toString = {}.toString;
+	var isArray$1 = Array.isArray || function(arr) {
+		return toString.call(arr) == "[object Array]";
+	};
 	/**
-	* Font obfuscation module for embedding fonts in WordprocessingML documents.
-	*
-	* This module implements the OOXML font obfuscation algorithm used to embed
-	* fonts in DOCX documents. Obfuscation is required by the OOXML specification
-	* to prevent simple extraction of embedded font files.
+	* If `Buffer.TYPED_ARRAY_SUPPORT`:
+	*   === true    Use Uint8Array implementation (fastest)
+	*   === false   Use Object implementation (most compatible, even IE6)
 	*
-	* Reference: ECMA-376 Part 2, Section 11.1 (Font Embedding)
+	* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+	* Opera 11.6+, iOS 4.2+.
 	*
-	* @module
-	*/
-	/** Start offset for obfuscation in the font file */
-	const obfuscatedStartOffset = 0;
-	/** End offset for obfuscation (first 32 bytes are obfuscated) */
-	const obfuscatedEndOffset = 32;
-	/** Expected GUID size (32 hex characters without dashes) */
-	const guidSize = 32;
-	/**
-	* Obfuscates a TrueType font file for embedding in OOXML documents.
+	* Due to various browser bugs, sometimes the Object implementation will be used even
+	* when the browser supports typed arrays.
 	*
-	* The obfuscation algorithm XORs the first 32 bytes of the font file
-	* with a reversed byte sequence derived from the font's GUID key.
-	* This prevents simple extraction while maintaining font functionality.
+	* Note:
 	*
-	* @param buf - The original font file as a byte array
-	* @param fontKey - The GUID key for the font (with or without dashes)
-	* @returns The obfuscated font data
-	* @throws Error if the fontKey is not a valid 32-character GUID
+	*   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
+	*     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
 	*
-	* @example
-	* ```typescript
-	* const fontData = readFileSync("font.ttf");
-	* const fontKey = "00000000-0000-0000-0000-000000000000";
-	* const obfuscatedData = obfuscate(fontData, fontKey);
-	* ```
+	*   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
 	*
-	* @internal
+	*   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
+	*     incorrect length in some situations.
+	
+	* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
+	* get the Object implementation, which is slower but behaves correctly.
 	*/
-	const obfuscate = (buf, fontKey) => {
-		const guid = fontKey.replace(/-/g, "");
-		if (guid.length !== guidSize) throw new Error(`Error: Cannot extract GUID from font filename: ${fontKey}`);
-		const hexNumbers = guid.replace(/(..)/g, "$1 ").trim().split(" ").map((hexString) => parseInt(hexString, 16));
-		hexNumbers.reverse();
-		const obfuscatedBytes = buf.slice(obfuscatedStartOffset, obfuscatedEndOffset).map((byte, i) => byte ^ hexNumbers[i % hexNumbers.length]);
-		const out = new Uint8Array(obfuscatedStartOffset + obfuscatedBytes.length + Math.max(0, buf.length - obfuscatedEndOffset));
-		out.set(buf.slice(0, obfuscatedStartOffset));
-		out.set(obfuscatedBytes, obfuscatedStartOffset);
-		out.set(buf.slice(obfuscatedEndOffset), obfuscatedStartOffset + obfuscatedBytes.length);
-		return out;
-	};
-	//#endregion
-	//#region src/export/formatter.ts
+	Buffer$1.TYPED_ARRAY_SUPPORT = _polyfill_node_global_default.TYPED_ARRAY_SUPPORT !== void 0 ? _polyfill_node_global_default.TYPED_ARRAY_SUPPORT : true;
+	kMaxLength();
+	function kMaxLength() {
+		return Buffer$1.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823;
+	}
+	function createBuffer(that, length) {
+		if (kMaxLength() < length) throw new RangeError("Invalid typed array length");
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			that = new Uint8Array(length);
+			that.__proto__ = Buffer$1.prototype;
+		} else {
+			if (that === null) that = new Buffer$1(length);
+			that.length = length;
+		}
+		return that;
+	}
 	/**
-	* Converts XML components into serializable objects ready for XML generation.
+	* The Buffer constructor returns instances of `Uint8Array` that have their
+	* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+	* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+	* and the `Uint8Array` methods. Square bracket notation works as expected -- it
+	* returns a single octet.
 	*
-	* The Formatter is responsible for preparing XML components for serialization by calling
-	* their prepForXml method with the appropriate context. This is a critical step in the
-	* export pipeline that transforms the declarative API objects into XML-compatible structures.
-	*
-	* @example
-	* ```typescript
-	* const formatter = new Formatter();
-	* const paragraph = new Paragraph("Hello World");
-	* const xmlObject = formatter.format(paragraph, context);
-	* ```
+	* The `Uint8Array` prototype remains unmodified.
 	*/
-	var Formatter = class {
-		/**
-		* Formats an XML component into a serializable object.
-		*
-		* @param input - The XML component to format
-		* @param context - The context containing file state and relationships
-		* @returns A serializable XML object structure
-		* @throws Error if the component cannot be formatted correctly
-		*/
-		format(input, context = { stack: [] }) {
-			const output = input.prepForXml(context);
-			if (output) return output;
-			else throw new Error("XMLComponent did not format correctly");
+	function Buffer$1(arg, encodingOrOffset, length) {
+		if (!Buffer$1.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer$1)) return new Buffer$1(arg, encodingOrOffset, length);
+		if (typeof arg === "number") {
+			if (typeof encodingOrOffset === "string") throw new Error("If encoding is specified then the first argument must be a string");
+			return allocUnsafe(this, arg);
 		}
-	};
+		return from(this, arg, encodingOrOffset, length);
+	}
+	Buffer$1.poolSize = 8192;
+	Buffer$1._augment = function(arr) {
+		arr.__proto__ = Buffer$1.prototype;
+		return arr;
+	};
+	function from(that, value, encodingOrOffset, length) {
+		if (typeof value === "number") throw new TypeError("\"value\" argument must not be a number");
+		if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) return fromArrayBuffer(that, value, encodingOrOffset, length);
+		if (typeof value === "string") return fromString(that, value, encodingOrOffset);
+		return fromObject(that, value);
+	}
+	/**
+	* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+	* if value is a number.
+	* Buffer.from(str[, encoding])
+	* Buffer.from(array)
+	* Buffer.from(buffer)
+	* Buffer.from(arrayBuffer[, byteOffset[, length]])
+	**/
+	Buffer$1.from = function(value, encodingOrOffset, length) {
+		return from(null, value, encodingOrOffset, length);
+	};
+	if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+		Buffer$1.prototype.__proto__ = Uint8Array.prototype;
+		Buffer$1.__proto__ = Uint8Array;
+		if (typeof Symbol !== "undefined" && Symbol.species && Buffer$1[Symbol.species] === Buffer$1);
+	}
+	function assertSize(size) {
+		if (typeof size !== "number") throw new TypeError("\"size\" argument must be a number");
+		else if (size < 0) throw new RangeError("\"size\" argument must not be negative");
+	}
+	function alloc(that, size, fill, encoding) {
+		assertSize(size);
+		if (size <= 0) return createBuffer(that, size);
+		if (fill !== void 0) return typeof encoding === "string" ? createBuffer(that, size).fill(fill, encoding) : createBuffer(that, size).fill(fill);
+		return createBuffer(that, size);
+	}
+	/**
+	* Creates a new filled Buffer instance.
+	* alloc(size[, fill[, encoding]])
+	**/
+	Buffer$1.alloc = function(size, fill, encoding) {
+		return alloc(null, size, fill, encoding);
+	};
+	function allocUnsafe(that, size) {
+		assertSize(size);
+		that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
+		if (!Buffer$1.TYPED_ARRAY_SUPPORT) for (var i = 0; i < size; ++i) that[i] = 0;
+		return that;
+	}
+	/**
+	* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+	* */
+	Buffer$1.allocUnsafe = function(size) {
+		return allocUnsafe(null, size);
+	};
+	/**
+	* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+	*/
+	Buffer$1.allocUnsafeSlow = function(size) {
+		return allocUnsafe(null, size);
+	};
+	function fromString(that, string, encoding) {
+		if (typeof encoding !== "string" || encoding === "") encoding = "utf8";
+		if (!Buffer$1.isEncoding(encoding)) throw new TypeError("\"encoding\" must be a valid string encoding");
+		var length = byteLength(string, encoding) | 0;
+		that = createBuffer(that, length);
+		var actual = that.write(string, encoding);
+		if (actual !== length) that = that.slice(0, actual);
+		return that;
+	}
+	function fromArrayLike(that, array) {
+		var length = array.length < 0 ? 0 : checked(array.length) | 0;
+		that = createBuffer(that, length);
+		for (var i = 0; i < length; i += 1) that[i] = array[i] & 255;
+		return that;
+	}
+	function fromArrayBuffer(that, array, byteOffset, length) {
+		array.byteLength;
+		if (byteOffset < 0 || array.byteLength < byteOffset) throw new RangeError("'offset' is out of bounds");
+		if (array.byteLength < byteOffset + (length || 0)) throw new RangeError("'length' is out of bounds");
+		if (byteOffset === void 0 && length === void 0) array = new Uint8Array(array);
+		else if (length === void 0) array = new Uint8Array(array, byteOffset);
+		else array = new Uint8Array(array, byteOffset, length);
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			that = array;
+			that.__proto__ = Buffer$1.prototype;
+		} else that = fromArrayLike(that, array);
+		return that;
+	}
+	function fromObject(that, obj) {
+		if (internalIsBuffer(obj)) {
+			var len = checked(obj.length) | 0;
+			that = createBuffer(that, len);
+			if (that.length === 0) return that;
+			obj.copy(that, 0, 0, len);
+			return that;
+		}
+		if (obj) {
+			if (typeof ArrayBuffer !== "undefined" && obj.buffer instanceof ArrayBuffer || "length" in obj) {
+				if (typeof obj.length !== "number" || isnan(obj.length)) return createBuffer(that, 0);
+				return fromArrayLike(that, obj);
+			}
+			if (obj.type === "Buffer" && isArray$1(obj.data)) return fromArrayLike(that, obj.data);
+		}
+		throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.");
+	}
+	function checked(length) {
+		if (length >= kMaxLength()) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + kMaxLength().toString(16) + " bytes");
+		return length | 0;
+	}
+	Buffer$1.isBuffer = isBuffer;
+	function internalIsBuffer(b) {
+		return !!(b != null && b._isBuffer);
+	}
+	Buffer$1.compare = function compare(a, b) {
+		if (!internalIsBuffer(a) || !internalIsBuffer(b)) throw new TypeError("Arguments must be Buffers");
+		if (a === b) return 0;
+		var x = a.length;
+		var y = b.length;
+		for (var i = 0, len = Math.min(x, y); i < len; ++i) if (a[i] !== b[i]) {
+			x = a[i];
+			y = b[i];
+			break;
+		}
+		if (x < y) return -1;
+		if (y < x) return 1;
+		return 0;
+	};
+	Buffer$1.isEncoding = function isEncoding(encoding) {
+		switch (String(encoding).toLowerCase()) {
+			case "hex":
+			case "utf8":
+			case "utf-8":
+			case "ascii":
+			case "latin1":
+			case "binary":
+			case "base64":
+			case "ucs2":
+			case "ucs-2":
+			case "utf16le":
+			case "utf-16le": return true;
+			default: return false;
+		}
+	};
+	Buffer$1.concat = function concat(list, length) {
+		if (!isArray$1(list)) throw new TypeError("\"list\" argument must be an Array of Buffers");
+		if (list.length === 0) return Buffer$1.alloc(0);
+		var i;
+		if (length === void 0) {
+			length = 0;
+			for (i = 0; i < list.length; ++i) length += list[i].length;
+		}
+		var buffer = Buffer$1.allocUnsafe(length);
+		var pos = 0;
+		for (i = 0; i < list.length; ++i) {
+			var buf = list[i];
+			if (!internalIsBuffer(buf)) throw new TypeError("\"list\" argument must be an Array of Buffers");
+			buf.copy(buffer, pos);
+			pos += buf.length;
+		}
+		return buffer;
+	};
+	function byteLength(string, encoding) {
+		if (internalIsBuffer(string)) return string.length;
+		if (typeof ArrayBuffer !== "undefined" && typeof ArrayBuffer.isView === "function" && (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) return string.byteLength;
+		if (typeof string !== "string") string = "" + string;
+		var len = string.length;
+		if (len === 0) return 0;
+		var loweredCase = false;
+		for (;;) switch (encoding) {
+			case "ascii":
+			case "latin1":
+			case "binary": return len;
+			case "utf8":
+			case "utf-8":
+			case void 0: return utf8ToBytes(string).length;
+			case "ucs2":
+			case "ucs-2":
+			case "utf16le":
+			case "utf-16le": return len * 2;
+			case "hex": return len >>> 1;
+			case "base64": return base64ToBytes(string).length;
+			default:
+				if (loweredCase) return utf8ToBytes(string).length;
+				encoding = ("" + encoding).toLowerCase();
+				loweredCase = true;
+		}
+	}
+	Buffer$1.byteLength = byteLength;
+	function slowToString(encoding, start, end) {
+		var loweredCase = false;
+		if (start === void 0 || start < 0) start = 0;
+		if (start > this.length) return "";
+		if (end === void 0 || end > this.length) end = this.length;
+		if (end <= 0) return "";
+		end >>>= 0;
+		start >>>= 0;
+		if (end <= start) return "";
+		if (!encoding) encoding = "utf8";
+		while (true) switch (encoding) {
+			case "hex": return hexSlice(this, start, end);
+			case "utf8":
+			case "utf-8": return utf8Slice(this, start, end);
+			case "ascii": return asciiSlice(this, start, end);
+			case "latin1":
+			case "binary": return latin1Slice(this, start, end);
+			case "base64": return base64Slice(this, start, end);
+			case "ucs2":
+			case "ucs-2":
+			case "utf16le":
+			case "utf-16le": return utf16leSlice(this, start, end);
+			default:
+				if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+				encoding = (encoding + "").toLowerCase();
+				loweredCase = true;
+		}
+	}
+	Buffer$1.prototype._isBuffer = true;
+	function swap(b, n, m) {
+		var i = b[n];
+		b[n] = b[m];
+		b[m] = i;
+	}
+	Buffer$1.prototype.swap16 = function swap16() {
+		var len = this.length;
+		if (len % 2 !== 0) throw new RangeError("Buffer size must be a multiple of 16-bits");
+		for (var i = 0; i < len; i += 2) swap(this, i, i + 1);
+		return this;
+	};
+	Buffer$1.prototype.swap32 = function swap32() {
+		var len = this.length;
+		if (len % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
+		for (var i = 0; i < len; i += 4) {
+			swap(this, i, i + 3);
+			swap(this, i + 1, i + 2);
+		}
+		return this;
+	};
+	Buffer$1.prototype.swap64 = function swap64() {
+		var len = this.length;
+		if (len % 8 !== 0) throw new RangeError("Buffer size must be a multiple of 64-bits");
+		for (var i = 0; i < len; i += 8) {
+			swap(this, i, i + 7);
+			swap(this, i + 1, i + 6);
+			swap(this, i + 2, i + 5);
+			swap(this, i + 3, i + 4);
+		}
+		return this;
+	};
+	Buffer$1.prototype.toString = function toString() {
+		var length = this.length | 0;
+		if (length === 0) return "";
+		if (arguments.length === 0) return utf8Slice(this, 0, length);
+		return slowToString.apply(this, arguments);
+	};
+	Buffer$1.prototype.equals = function equals(b) {
+		if (!internalIsBuffer(b)) throw new TypeError("Argument must be a Buffer");
+		if (this === b) return true;
+		return Buffer$1.compare(this, b) === 0;
+	};
+	Buffer$1.prototype.inspect = function inspect() {
+		var str = "";
+		var max = 50;
+		if (this.length > 0) {
+			str = this.toString("hex", 0, max).match(/.{2}/g).join(" ");
+			if (this.length > max) str += " ... ";
+		}
+		return "<Buffer " + str + ">";
+	};
+	Buffer$1.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+		if (!internalIsBuffer(target)) throw new TypeError("Argument must be a Buffer");
+		if (start === void 0) start = 0;
+		if (end === void 0) end = target ? target.length : 0;
+		if (thisStart === void 0) thisStart = 0;
+		if (thisEnd === void 0) thisEnd = this.length;
+		if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) throw new RangeError("out of range index");
+		if (thisStart >= thisEnd && start >= end) return 0;
+		if (thisStart >= thisEnd) return -1;
+		if (start >= end) return 1;
+		start >>>= 0;
+		end >>>= 0;
+		thisStart >>>= 0;
+		thisEnd >>>= 0;
+		if (this === target) return 0;
+		var x = thisEnd - thisStart;
+		var y = end - start;
+		var len = Math.min(x, y);
+		var thisCopy = this.slice(thisStart, thisEnd);
+		var targetCopy = target.slice(start, end);
+		for (var i = 0; i < len; ++i) if (thisCopy[i] !== targetCopy[i]) {
+			x = thisCopy[i];
+			y = targetCopy[i];
+			break;
+		}
+		if (x < y) return -1;
+		if (y < x) return 1;
+		return 0;
+	};
+	function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+		if (buffer.length === 0) return -1;
+		if (typeof byteOffset === "string") {
+			encoding = byteOffset;
+			byteOffset = 0;
+		} else if (byteOffset > 2147483647) byteOffset = 2147483647;
+		else if (byteOffset < -2147483648) byteOffset = -2147483648;
+		byteOffset = +byteOffset;
+		if (isNaN(byteOffset)) byteOffset = dir ? 0 : buffer.length - 1;
+		if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+		if (byteOffset >= buffer.length) if (dir) return -1;
+		else byteOffset = buffer.length - 1;
+		else if (byteOffset < 0) if (dir) byteOffset = 0;
+		else return -1;
+		if (typeof val === "string") val = Buffer$1.from(val, encoding);
+		if (internalIsBuffer(val)) {
+			if (val.length === 0) return -1;
+			return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+		} else if (typeof val === "number") {
+			val = val & 255;
+			if (Buffer$1.TYPED_ARRAY_SUPPORT && typeof Uint8Array.prototype.indexOf === "function") if (dir) return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+			else return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+			return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+		}
+		throw new TypeError("val must be string, number or Buffer");
+	}
+	function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+		var indexSize = 1;
+		var arrLength = arr.length;
+		var valLength = val.length;
+		if (encoding !== void 0) {
+			encoding = String(encoding).toLowerCase();
+			if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+				if (arr.length < 2 || val.length < 2) return -1;
+				indexSize = 2;
+				arrLength /= 2;
+				valLength /= 2;
+				byteOffset /= 2;
+			}
+		}
+		function read(buf, i) {
+			if (indexSize === 1) return buf[i];
+			else return buf.readUInt16BE(i * indexSize);
+		}
+		var i;
+		if (dir) {
+			var foundIndex = -1;
+			for (i = byteOffset; i < arrLength; i++) if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+				if (foundIndex === -1) foundIndex = i;
+				if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+			} else {
+				if (foundIndex !== -1) i -= i - foundIndex;
+				foundIndex = -1;
+			}
+		} else {
+			if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+			for (i = byteOffset; i >= 0; i--) {
+				var found = true;
+				for (var j = 0; j < valLength; j++) if (read(arr, i + j) !== read(val, j)) {
+					found = false;
+					break;
+				}
+				if (found) return i;
+			}
+		}
+		return -1;
+	}
+	Buffer$1.prototype.includes = function includes(val, byteOffset, encoding) {
+		return this.indexOf(val, byteOffset, encoding) !== -1;
+	};
+	Buffer$1.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+		return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+	};
+	Buffer$1.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+		return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+	};
+	function hexWrite(buf, string, offset, length) {
+		offset = Number(offset) || 0;
+		var remaining = buf.length - offset;
+		if (!length) length = remaining;
+		else {
+			length = Number(length);
+			if (length > remaining) length = remaining;
+		}
+		var strLen = string.length;
+		if (strLen % 2 !== 0) throw new TypeError("Invalid hex string");
+		if (length > strLen / 2) length = strLen / 2;
+		for (var i = 0; i < length; ++i) {
+			var parsed = parseInt(string.substr(i * 2, 2), 16);
+			if (isNaN(parsed)) return i;
+			buf[offset + i] = parsed;
+		}
+		return i;
+	}
+	function utf8Write(buf, string, offset, length) {
+		return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+	}
+	function asciiWrite(buf, string, offset, length) {
+		return blitBuffer(asciiToBytes(string), buf, offset, length);
+	}
+	function latin1Write(buf, string, offset, length) {
+		return asciiWrite(buf, string, offset, length);
+	}
+	function base64Write(buf, string, offset, length) {
+		return blitBuffer(base64ToBytes(string), buf, offset, length);
+	}
+	function ucs2Write(buf, string, offset, length) {
+		return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+	}
+	Buffer$1.prototype.write = function write(string, offset, length, encoding) {
+		if (offset === void 0) {
+			encoding = "utf8";
+			length = this.length;
+			offset = 0;
+		} else if (length === void 0 && typeof offset === "string") {
+			encoding = offset;
+			length = this.length;
+			offset = 0;
+		} else if (isFinite(offset)) {
+			offset = offset | 0;
+			if (isFinite(length)) {
+				length = length | 0;
+				if (encoding === void 0) encoding = "utf8";
+			} else {
+				encoding = length;
+				length = void 0;
+			}
+		} else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
+		var remaining = this.length - offset;
+		if (length === void 0 || length > remaining) length = remaining;
+		if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) throw new RangeError("Attempt to write outside buffer bounds");
+		if (!encoding) encoding = "utf8";
+		var loweredCase = false;
+		for (;;) switch (encoding) {
+			case "hex": return hexWrite(this, string, offset, length);
+			case "utf8":
+			case "utf-8": return utf8Write(this, string, offset, length);
+			case "ascii": return asciiWrite(this, string, offset, length);
+			case "latin1":
+			case "binary": return latin1Write(this, string, offset, length);
+			case "base64": return base64Write(this, string, offset, length);
+			case "ucs2":
+			case "ucs-2":
+			case "utf16le":
+			case "utf-16le": return ucs2Write(this, string, offset, length);
+			default:
+				if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+				encoding = ("" + encoding).toLowerCase();
+				loweredCase = true;
+		}
+	};
+	Buffer$1.prototype.toJSON = function toJSON() {
+		return {
+			type: "Buffer",
+			data: Array.prototype.slice.call(this._arr || this, 0)
+		};
+	};
+	function base64Slice(buf, start, end) {
+		if (start === 0 && end === buf.length) return fromByteArray(buf);
+		else return fromByteArray(buf.slice(start, end));
+	}
+	function utf8Slice(buf, start, end) {
+		end = Math.min(buf.length, end);
+		var res = [];
+		var i = start;
+		while (i < end) {
+			var firstByte = buf[i];
+			var codePoint = null;
+			var bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+			if (i + bytesPerSequence <= end) {
+				var secondByte, thirdByte, fourthByte, tempCodePoint;
+				switch (bytesPerSequence) {
+					case 1:
+						if (firstByte < 128) codePoint = firstByte;
+						break;
+					case 2:
+						secondByte = buf[i + 1];
+						if ((secondByte & 192) === 128) {
+							tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+							if (tempCodePoint > 127) codePoint = tempCodePoint;
+						}
+						break;
+					case 3:
+						secondByte = buf[i + 1];
+						thirdByte = buf[i + 2];
+						if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+							tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+							if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) codePoint = tempCodePoint;
+						}
+						break;
+					case 4:
+						secondByte = buf[i + 1];
+						thirdByte = buf[i + 2];
+						fourthByte = buf[i + 3];
+						if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+							tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+							if (tempCodePoint > 65535 && tempCodePoint < 1114112) codePoint = tempCodePoint;
+						}
+				}
+			}
+			if (codePoint === null) {
+				codePoint = 65533;
+				bytesPerSequence = 1;
+			} else if (codePoint > 65535) {
+				codePoint -= 65536;
+				res.push(codePoint >>> 10 & 1023 | 55296);
+				codePoint = 56320 | codePoint & 1023;
+			}
+			res.push(codePoint);
+			i += bytesPerSequence;
+		}
+		return decodeCodePointsArray(res);
+	}
+	var MAX_ARGUMENTS_LENGTH = 4096;
+	function decodeCodePointsArray(codePoints) {
+		var len = codePoints.length;
+		if (len <= MAX_ARGUMENTS_LENGTH) return String.fromCharCode.apply(String, codePoints);
+		var res = "";
+		var i = 0;
+		while (i < len) res += String.fromCharCode.apply(String, codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH));
+		return res;
+	}
+	function asciiSlice(buf, start, end) {
+		var ret = "";
+		end = Math.min(buf.length, end);
+		for (var i = start; i < end; ++i) ret += String.fromCharCode(buf[i] & 127);
+		return ret;
+	}
+	function latin1Slice(buf, start, end) {
+		var ret = "";
+		end = Math.min(buf.length, end);
+		for (var i = start; i < end; ++i) ret += String.fromCharCode(buf[i]);
+		return ret;
+	}
+	function hexSlice(buf, start, end) {
+		var len = buf.length;
+		if (!start || start < 0) start = 0;
+		if (!end || end < 0 || end > len) end = len;
+		var out = "";
+		for (var i = start; i < end; ++i) out += toHex(buf[i]);
+		return out;
+	}
+	function utf16leSlice(buf, start, end) {
+		var bytes = buf.slice(start, end);
+		var res = "";
+		for (var i = 0; i < bytes.length; i += 2) res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+		return res;
+	}
+	Buffer$1.prototype.slice = function slice(start, end) {
+		var len = this.length;
+		start = ~~start;
+		end = end === void 0 ? len : ~~end;
+		if (start < 0) {
+			start += len;
+			if (start < 0) start = 0;
+		} else if (start > len) start = len;
+		if (end < 0) {
+			end += len;
+			if (end < 0) end = 0;
+		} else if (end > len) end = len;
+		if (end < start) end = start;
+		var newBuf;
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			newBuf = this.subarray(start, end);
+			newBuf.__proto__ = Buffer$1.prototype;
+		} else {
+			var sliceLen = end - start;
+			newBuf = new Buffer$1(sliceLen, void 0);
+			for (var i = 0; i < sliceLen; ++i) newBuf[i] = this[i + start];
+		}
+		return newBuf;
+	};
+	function checkOffset(offset, ext, length) {
+		if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
+		if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
+	}
+	Buffer$1.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
+		offset = offset | 0;
+		byteLength = byteLength | 0;
+		if (!noAssert) checkOffset(offset, byteLength, this.length);
+		var val = this[offset];
+		var mul = 1;
+		var i = 0;
+		while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
+		return val;
+	};
+	Buffer$1.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
+		offset = offset | 0;
+		byteLength = byteLength | 0;
+		if (!noAssert) checkOffset(offset, byteLength, this.length);
+		var val = this[offset + --byteLength];
+		var mul = 1;
+		while (byteLength > 0 && (mul *= 256)) val += this[offset + --byteLength] * mul;
+		return val;
+	};
+	Buffer$1.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 1, this.length);
+		return this[offset];
+	};
+	Buffer$1.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 2, this.length);
+		return this[offset] | this[offset + 1] << 8;
+	};
+	Buffer$1.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 2, this.length);
+		return this[offset] << 8 | this[offset + 1];
+	};
+	Buffer$1.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 4, this.length);
+		return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+	};
+	Buffer$1.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 4, this.length);
+		return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+	};
+	Buffer$1.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
+		offset = offset | 0;
+		byteLength = byteLength | 0;
+		if (!noAssert) checkOffset(offset, byteLength, this.length);
+		var val = this[offset];
+		var mul = 1;
+		var i = 0;
+		while (++i < byteLength && (mul *= 256)) val += this[offset + i] * mul;
+		mul *= 128;
+		if (val >= mul) val -= Math.pow(2, 8 * byteLength);
+		return val;
+	};
+	Buffer$1.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
+		offset = offset | 0;
+		byteLength = byteLength | 0;
+		if (!noAssert) checkOffset(offset, byteLength, this.length);
+		var i = byteLength;
+		var mul = 1;
+		var val = this[offset + --i];
+		while (i > 0 && (mul *= 256)) val += this[offset + --i] * mul;
+		mul *= 128;
+		if (val >= mul) val -= Math.pow(2, 8 * byteLength);
+		return val;
+	};
+	Buffer$1.prototype.readInt8 = function readInt8(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 1, this.length);
+		if (!(this[offset] & 128)) return this[offset];
+		return (255 - this[offset] + 1) * -1;
+	};
+	Buffer$1.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 2, this.length);
+		var val = this[offset] | this[offset + 1] << 8;
+		return val & 32768 ? val | 4294901760 : val;
+	};
+	Buffer$1.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 2, this.length);
+		var val = this[offset + 1] | this[offset] << 8;
+		return val & 32768 ? val | 4294901760 : val;
+	};
+	Buffer$1.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 4, this.length);
+		return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+	};
+	Buffer$1.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 4, this.length);
+		return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+	};
+	Buffer$1.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 4, this.length);
+		return read(this, offset, true, 23, 4);
+	};
+	Buffer$1.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 4, this.length);
+		return read(this, offset, false, 23, 4);
+	};
+	Buffer$1.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 8, this.length);
+		return read(this, offset, true, 52, 8);
+	};
+	Buffer$1.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+		if (!noAssert) checkOffset(offset, 8, this.length);
+		return read(this, offset, false, 52, 8);
+	};
+	function checkInt(buf, value, offset, ext, max, min) {
+		if (!internalIsBuffer(buf)) throw new TypeError("\"buffer\" argument must be a Buffer instance");
+		if (value > max || value < min) throw new RangeError("\"value\" argument is out of bounds");
+		if (offset + ext > buf.length) throw new RangeError("Index out of range");
+	}
+	Buffer$1.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		byteLength = byteLength | 0;
+		if (!noAssert) {
+			var maxBytes = Math.pow(2, 8 * byteLength) - 1;
+			checkInt(this, value, offset, byteLength, maxBytes, 0);
+		}
+		var mul = 1;
+		var i = 0;
+		this[offset] = value & 255;
+		while (++i < byteLength && (mul *= 256)) this[offset + i] = value / mul & 255;
+		return offset + byteLength;
+	};
+	Buffer$1.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		byteLength = byteLength | 0;
+		if (!noAssert) {
+			var maxBytes = Math.pow(2, 8 * byteLength) - 1;
+			checkInt(this, value, offset, byteLength, maxBytes, 0);
+		}
+		var i = byteLength - 1;
+		var mul = 1;
+		this[offset + i] = value & 255;
+		while (--i >= 0 && (mul *= 256)) this[offset + i] = value / mul & 255;
+		return offset + byteLength;
+	};
+	Buffer$1.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
+		if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
+		this[offset] = value & 255;
+		return offset + 1;
+	};
+	function objectWriteUInt16(buf, value, offset, littleEndian) {
+		if (value < 0) value = 65535 + value + 1;
+		for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) buf[offset + i] = (value & 255 << 8 * (littleEndian ? i : 1 - i)) >>> (littleEndian ? i : 1 - i) * 8;
+	}
+	Buffer$1.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			this[offset] = value & 255;
+			this[offset + 1] = value >>> 8;
+		} else objectWriteUInt16(this, value, offset, true);
+		return offset + 2;
+	};
+	Buffer$1.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			this[offset] = value >>> 8;
+			this[offset + 1] = value & 255;
+		} else objectWriteUInt16(this, value, offset, false);
+		return offset + 2;
+	};
+	function objectWriteUInt32(buf, value, offset, littleEndian) {
+		if (value < 0) value = 4294967295 + value + 1;
+		for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) buf[offset + i] = value >>> (littleEndian ? i : 3 - i) * 8 & 255;
+	}
+	Buffer$1.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			this[offset + 3] = value >>> 24;
+			this[offset + 2] = value >>> 16;
+			this[offset + 1] = value >>> 8;
+			this[offset] = value & 255;
+		} else objectWriteUInt32(this, value, offset, true);
+		return offset + 4;
+	};
+	Buffer$1.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			this[offset] = value >>> 24;
+			this[offset + 1] = value >>> 16;
+			this[offset + 2] = value >>> 8;
+			this[offset + 3] = value & 255;
+		} else objectWriteUInt32(this, value, offset, false);
+		return offset + 4;
+	};
+	Buffer$1.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) {
+			var limit = Math.pow(2, 8 * byteLength - 1);
+			checkInt(this, value, offset, byteLength, limit - 1, -limit);
+		}
+		var i = 0;
+		var mul = 1;
+		var sub = 0;
+		this[offset] = value & 255;
+		while (++i < byteLength && (mul *= 256)) {
+			if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) sub = 1;
+			this[offset + i] = (value / mul >> 0) - sub & 255;
+		}
+		return offset + byteLength;
+	};
+	Buffer$1.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) {
+			var limit = Math.pow(2, 8 * byteLength - 1);
+			checkInt(this, value, offset, byteLength, limit - 1, -limit);
+		}
+		var i = byteLength - 1;
+		var mul = 1;
+		var sub = 0;
+		this[offset + i] = value & 255;
+		while (--i >= 0 && (mul *= 256)) {
+			if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) sub = 1;
+			this[offset + i] = (value / mul >> 0) - sub & 255;
+		}
+		return offset + byteLength;
+	};
+	Buffer$1.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
+		if (!Buffer$1.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
+		if (value < 0) value = 255 + value + 1;
+		this[offset] = value & 255;
+		return offset + 1;
+	};
+	Buffer$1.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			this[offset] = value & 255;
+			this[offset + 1] = value >>> 8;
+		} else objectWriteUInt16(this, value, offset, true);
+		return offset + 2;
+	};
+	Buffer$1.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			this[offset] = value >>> 8;
+			this[offset + 1] = value & 255;
+		} else objectWriteUInt16(this, value, offset, false);
+		return offset + 2;
+	};
+	Buffer$1.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			this[offset] = value & 255;
+			this[offset + 1] = value >>> 8;
+			this[offset + 2] = value >>> 16;
+			this[offset + 3] = value >>> 24;
+		} else objectWriteUInt32(this, value, offset, true);
+		return offset + 4;
+	};
+	Buffer$1.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+		value = +value;
+		offset = offset | 0;
+		if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+		if (value < 0) value = 4294967295 + value + 1;
+		if (Buffer$1.TYPED_ARRAY_SUPPORT) {
+			this[offset] = value >>> 24;
+			this[offset + 1] = value >>> 16;
+			this[offset + 2] = value >>> 8;
+			this[offset + 3] = value & 255;
+		} else objectWriteUInt32(this, value, offset, false);
+		return offset + 4;
+	};
+	function checkIEEE754(buf, value, offset, ext, max, min) {
+		if (offset + ext > buf.length) throw new RangeError("Index out of range");
+		if (offset < 0) throw new RangeError("Index out of range");
+	}
+	function writeFloat(buf, value, offset, littleEndian, noAssert) {
+		if (!noAssert) checkIEEE754(buf, value, offset, 4);
+		write(buf, value, offset, littleEndian, 23, 4);
+		return offset + 4;
+	}
+	Buffer$1.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+		return writeFloat(this, value, offset, true, noAssert);
+	};
+	Buffer$1.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+		return writeFloat(this, value, offset, false, noAssert);
+	};
+	function writeDouble(buf, value, offset, littleEndian, noAssert) {
+		if (!noAssert) checkIEEE754(buf, value, offset, 8);
+		write(buf, value, offset, littleEndian, 52, 8);
+		return offset + 8;
+	}
+	Buffer$1.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+		return writeDouble(this, value, offset, true, noAssert);
+	};
+	Buffer$1.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+		return writeDouble(this, value, offset, false, noAssert);
+	};
+	Buffer$1.prototype.copy = function copy(target, targetStart, start, end) {
+		if (!start) start = 0;
+		if (!end && end !== 0) end = this.length;
+		if (targetStart >= target.length) targetStart = target.length;
+		if (!targetStart) targetStart = 0;
+		if (end > 0 && end < start) end = start;
+		if (end === start) return 0;
+		if (target.length === 0 || this.length === 0) return 0;
+		if (targetStart < 0) throw new RangeError("targetStart out of bounds");
+		if (start < 0 || start >= this.length) throw new RangeError("sourceStart out of bounds");
+		if (end < 0) throw new RangeError("sourceEnd out of bounds");
+		if (end > this.length) end = this.length;
+		if (target.length - targetStart < end - start) end = target.length - targetStart + start;
+		var len = end - start;
+		var i;
+		if (this === target && start < targetStart && targetStart < end) for (i = len - 1; i >= 0; --i) target[i + targetStart] = this[i + start];
+		else if (len < 1e3 || !Buffer$1.TYPED_ARRAY_SUPPORT) for (i = 0; i < len; ++i) target[i + targetStart] = this[i + start];
+		else Uint8Array.prototype.set.call(target, this.subarray(start, start + len), targetStart);
+		return len;
+	};
+	Buffer$1.prototype.fill = function fill(val, start, end, encoding) {
+		if (typeof val === "string") {
+			if (typeof start === "string") {
+				encoding = start;
+				start = 0;
+				end = this.length;
+			} else if (typeof end === "string") {
+				encoding = end;
+				end = this.length;
+			}
+			if (val.length === 1) {
+				var code = val.charCodeAt(0);
+				if (code < 256) val = code;
+			}
+			if (encoding !== void 0 && typeof encoding !== "string") throw new TypeError("encoding must be a string");
+			if (typeof encoding === "string" && !Buffer$1.isEncoding(encoding)) throw new TypeError("Unknown encoding: " + encoding);
+		} else if (typeof val === "number") val = val & 255;
+		if (start < 0 || this.length < start || this.length < end) throw new RangeError("Out of range index");
+		if (end <= start) return this;
+		start = start >>> 0;
+		end = end === void 0 ? this.length : end >>> 0;
+		if (!val) val = 0;
+		var i;
+		if (typeof val === "number") for (i = start; i < end; ++i) this[i] = val;
+		else {
+			var bytes = internalIsBuffer(val) ? val : utf8ToBytes(new Buffer$1(val, encoding).toString());
+			var len = bytes.length;
+			for (i = 0; i < end - start; ++i) this[i + start] = bytes[i % len];
+		}
+		return this;
+	};
+	var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;
+	function base64clean(str) {
+		str = stringtrim(str).replace(INVALID_BASE64_RE, "");
+		if (str.length < 2) return "";
+		while (str.length % 4 !== 0) str = str + "=";
+		return str;
+	}
+	function stringtrim(str) {
+		if (str.trim) return str.trim();
+		return str.replace(/^\s+|\s+$/g, "");
+	}
+	function toHex(n) {
+		if (n < 16) return "0" + n.toString(16);
+		return n.toString(16);
+	}
+	function utf8ToBytes(string, units) {
+		units = units || Infinity;
+		var codePoint;
+		var length = string.length;
+		var leadSurrogate = null;
+		var bytes = [];
+		for (var i = 0; i < length; ++i) {
+			codePoint = string.charCodeAt(i);
+			if (codePoint > 55295 && codePoint < 57344) {
+				if (!leadSurrogate) {
+					if (codePoint > 56319) {
+						if ((units -= 3) > -1) bytes.push(239, 191, 189);
+						continue;
+					} else if (i + 1 === length) {
+						if ((units -= 3) > -1) bytes.push(239, 191, 189);
+						continue;
+					}
+					leadSurrogate = codePoint;
+					continue;
+				}
+				if (codePoint < 56320) {
+					if ((units -= 3) > -1) bytes.push(239, 191, 189);
+					leadSurrogate = codePoint;
+					continue;
+				}
+				codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+			} else if (leadSurrogate) {
+				if ((units -= 3) > -1) bytes.push(239, 191, 189);
+			}
+			leadSurrogate = null;
+			if (codePoint < 128) {
+				if ((units -= 1) < 0) break;
+				bytes.push(codePoint);
+			} else if (codePoint < 2048) {
+				if ((units -= 2) < 0) break;
+				bytes.push(codePoint >> 6 | 192, codePoint & 63 | 128);
+			} else if (codePoint < 65536) {
+				if ((units -= 3) < 0) break;
+				bytes.push(codePoint >> 12 | 224, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+			} else if (codePoint < 1114112) {
+				if ((units -= 4) < 0) break;
+				bytes.push(codePoint >> 18 | 240, codePoint >> 12 & 63 | 128, codePoint >> 6 & 63 | 128, codePoint & 63 | 128);
+			} else throw new Error("Invalid code point");
+		}
+		return bytes;
+	}
+	function asciiToBytes(str) {
+		var byteArray = [];
+		for (var i = 0; i < str.length; ++i) byteArray.push(str.charCodeAt(i) & 255);
+		return byteArray;
+	}
+	function utf16leToBytes(str, units) {
+		var c, hi, lo;
+		var byteArray = [];
+		for (var i = 0; i < str.length; ++i) {
+			if ((units -= 2) < 0) break;
+			c = str.charCodeAt(i);
+			hi = c >> 8;
+			lo = c % 256;
+			byteArray.push(lo);
+			byteArray.push(hi);
+		}
+		return byteArray;
+	}
+	function base64ToBytes(str) {
+		return toByteArray(base64clean(str));
+	}
+	function blitBuffer(src, dst, offset, length) {
+		for (var i = 0; i < length; ++i) {
+			if (i + offset >= dst.length || i >= src.length) break;
+			dst[i + offset] = src[i];
+		}
+		return i;
+	}
+	function isnan(val) {
+		return val !== val;
+	}
+	function isBuffer(obj) {
+		return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj));
+	}
+	function isFastBuffer(obj) {
+		return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+	}
+	function isSlowBuffer(obj) {
+		return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isFastBuffer(obj.slice(0, 0));
+	}
+	//#endregion
+	//#region \0polyfill-node.process.js
+	function defaultSetTimout() {
+		throw new Error("setTimeout has not been defined");
+	}
+	function defaultClearTimeout() {
+		throw new Error("clearTimeout has not been defined");
+	}
+	var cachedSetTimeout = defaultSetTimout;
+	var cachedClearTimeout = defaultClearTimeout;
+	if (typeof _polyfill_node_global_default.setTimeout === "function") cachedSetTimeout = setTimeout;
+	if (typeof _polyfill_node_global_default.clearTimeout === "function") cachedClearTimeout = clearTimeout;
+	function runTimeout(fun) {
+		if (cachedSetTimeout === setTimeout) return setTimeout(fun, 0);
+		if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+			cachedSetTimeout = setTimeout;
+			return setTimeout(fun, 0);
+		}
+		try {
+			return cachedSetTimeout(fun, 0);
+		} catch (e) {
+			try {
+				return cachedSetTimeout.call(null, fun, 0);
+			} catch (e) {
+				return cachedSetTimeout.call(this, fun, 0);
+			}
+		}
+	}
+	function runClearTimeout(marker) {
+		if (cachedClearTimeout === clearTimeout) return clearTimeout(marker);
+		if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+			cachedClearTimeout = clearTimeout;
+			return clearTimeout(marker);
+		}
+		try {
+			return cachedClearTimeout(marker);
+		} catch (e) {
+			try {
+				return cachedClearTimeout.call(null, marker);
+			} catch (e) {
+				return cachedClearTimeout.call(this, marker);
+			}
+		}
+	}
+	var queue = [];
+	var draining = false;
+	var currentQueue;
+	var queueIndex = -1;
+	function cleanUpNextTick() {
+		if (!draining || !currentQueue) return;
+		draining = false;
+		if (currentQueue.length) queue = currentQueue.concat(queue);
+		else queueIndex = -1;
+		if (queue.length) drainQueue();
+	}
+	function drainQueue() {
+		if (draining) return;
+		var timeout = runTimeout(cleanUpNextTick);
+		draining = true;
+		var len = queue.length;
+		while (len) {
+			currentQueue = queue;
+			queue = [];
+			while (++queueIndex < len) if (currentQueue) currentQueue[queueIndex].run();
+			queueIndex = -1;
+			len = queue.length;
+		}
+		currentQueue = null;
+		draining = false;
+		runClearTimeout(timeout);
+	}
+	function nextTick(fun) {
+		var args = new Array(arguments.length - 1);
+		if (arguments.length > 1) for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i];
+		queue.push(new Item(fun, args));
+		if (queue.length === 1 && !draining) runTimeout(drainQueue);
+	}
+	function Item(fun, array) {
+		this.fun = fun;
+		this.array = array;
+	}
+	Item.prototype.run = function() {
+		this.fun.apply(null, this.array);
+	};
+	var title = "browser";
+	var platform = "browser";
+	var env = {};
+	var argv = [];
+	var versions = {};
+	var release = {};
+	var config = {};
+	function noop() {}
+	var on = noop;
+	var addListener = noop;
+	var once = noop;
+	var off = noop;
+	var removeListener = noop;
+	var removeAllListeners = noop;
+	var emit = noop;
+	function binding(name) {
+		throw new Error("process.binding is not supported");
+	}
+	function cwd() {
+		return "/";
+	}
+	function chdir(dir) {
+		throw new Error("process.chdir is not supported");
+	}
+	function umask() {
+		return 0;
+	}
+	var performance = _polyfill_node_global_default.performance || {};
+	var performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || function() {
+		return (/* @__PURE__ */ new Date()).getTime();
+	};
+	function hrtime(previousTimestamp) {
+		var clocktime = performanceNow.call(performance) * .001;
+		var seconds = Math.floor(clocktime);
+		var nanoseconds = Math.floor(clocktime % 1 * 1e9);
+		if (previousTimestamp) {
+			seconds = seconds - previousTimestamp[0];
+			nanoseconds = nanoseconds - previousTimestamp[1];
+			if (nanoseconds < 0) {
+				seconds--;
+				nanoseconds += 1e9;
+			}
+		}
+		return [seconds, nanoseconds];
+	}
+	var startTime = /* @__PURE__ */ new Date();
+	function uptime() {
+		return (/* @__PURE__ */ new Date() - startTime) / 1e3;
+	}
+	var browser$1 = {
+		nextTick,
+		title,
+		browser: true,
+		env,
+		argv,
+		version: "",
+		versions,
+		on,
+		addListener,
+		once,
+		off,
+		removeListener,
+		removeAllListeners,
+		emit,
+		binding,
+		cwd,
+		chdir,
+		umask,
+		hrtime,
+		platform,
+		release,
+		config,
+		uptime
+	};
+	//#endregion
+	//#region \0polyfill-node._inherits.js
+	var inherits;
+	if (typeof Object.create === "function") inherits = function inherits(ctor, superCtor) {
+		ctor.super_ = superCtor;
+		ctor.prototype = Object.create(superCtor.prototype, { constructor: {
+			value: ctor,
+			enumerable: false,
+			writable: true,
+			configurable: true
+		} });
+	};
+	else inherits = function inherits(ctor, superCtor) {
+		ctor.super_ = superCtor;
+		var TempCtor = function() {};
+		TempCtor.prototype = superCtor.prototype;
+		ctor.prototype = new TempCtor();
+		ctor.prototype.constructor = ctor;
+	};
+	var _polyfill_node__inherits_default = inherits;
+	//#endregion
+	//#region \0polyfill-node.util.js
+	/**
+	* Inherit the prototype methods from one constructor into another.
+	*
+	* The Function.prototype.inherits from lang.js rewritten as a standalone
+	* function (not on Function.prototype). NOTE: If this file is to be loaded
+	* during bootstrapping this function needs to be rewritten using some native
+	* functions as prototype setup using normal JavaScript does not work as
+	* expected during bootstrapping (see mirror.js in r114903).
+	*
+	* @param {function} ctor Constructor function which needs to inherit the
+	*     prototype.
+	* @param {function} superCtor Constructor function to inherit prototype from.
+	*/
+	var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || function getOwnPropertyDescriptors(obj) {
+		var keys = Object.keys(obj);
+		var descriptors = {};
+		for (var i = 0; i < keys.length; i++) descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
+		return descriptors;
+	};
+	var formatRegExp = /%[sdj%]/g;
+	function format(f) {
+		if (!isString(f)) {
+			var objects = [];
+			for (var i = 0; i < arguments.length; i++) objects.push(inspect(arguments[i]));
+			return objects.join(" ");
+		}
+		var i = 1;
+		var args = arguments;
+		var len = args.length;
+		var str = String(f).replace(formatRegExp, function(x) {
+			if (x === "%%") return "%";
+			if (i >= len) return x;
+			switch (x) {
+				case "%s": return String(args[i++]);
+				case "%d": return Number(args[i++]);
+				case "%j": try {
+					return JSON.stringify(args[i++]);
+				} catch (_) {
+					return "[Circular]";
+				}
+				default: return x;
+			}
+		});
+		for (var x = args[i]; i < len; x = args[++i]) if (isNull(x) || !isObject(x)) str += " " + x;
+		else str += " " + inspect(x);
+		return str;
+	}
+	function deprecate(fn, msg) {
+		if (isUndefined(_polyfill_node_global_default.process)) return function() {
+			return deprecate(fn, msg).apply(this, arguments);
+		};
+		if (browser$1.noDeprecation === true) return fn;
+		var warned = false;
+		function deprecated() {
+			if (!warned) {
+				if (browser$1.throwDeprecation) throw new Error(msg);
+				else if (browser$1.traceDeprecation) console.trace(msg);
+				else console.error(msg);
+				warned = true;
+			}
+			return fn.apply(this, arguments);
+		}
+		return deprecated;
+	}
+	var debugs = {};
+	var debugEnviron;
+	function debuglog(set) {
+		if (isUndefined(debugEnviron)) debugEnviron = browser$1.env.NODE_DEBUG || "";
+		set = set.toUpperCase();
+		if (!debugs[set]) if (new RegExp("\\b" + set + "\\b", "i").test(debugEnviron)) {
+			var pid = 0;
+			debugs[set] = function() {
+				var msg = format.apply(null, arguments);
+				console.error("%s %d: %s", set, pid, msg);
+			};
+		} else debugs[set] = function() {};
+		return debugs[set];
+	}
+	/**
+	* Echos the value of a value. Trys to print the value out
+	* in the best way possible given the different types.
+	*
+	* @param {Object} obj The object to print out.
+	* @param {Object} opts Optional options object that alters the output.
+	*/
+	function inspect(obj, opts) {
+		var ctx = {
+			seen: [],
+			stylize: stylizeNoColor
+		};
+		if (arguments.length >= 3) ctx.depth = arguments[2];
+		if (arguments.length >= 4) ctx.colors = arguments[3];
+		if (isBoolean(opts)) ctx.showHidden = opts;
+		else if (opts) _extend(ctx, opts);
+		if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+		if (isUndefined(ctx.depth)) ctx.depth = 2;
+		if (isUndefined(ctx.colors)) ctx.colors = false;
+		if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+		if (ctx.colors) ctx.stylize = stylizeWithColor;
+		return formatValue(ctx, obj, ctx.depth);
+	}
+	inspect.colors = {
+		"bold": [1, 22],
+		"italic": [3, 23],
+		"underline": [4, 24],
+		"inverse": [7, 27],
+		"white": [37, 39],
+		"grey": [90, 39],
+		"black": [30, 39],
+		"blue": [34, 39],
+		"cyan": [36, 39],
+		"green": [32, 39],
+		"magenta": [35, 39],
+		"red": [31, 39],
+		"yellow": [33, 39]
+	};
+	inspect.styles = {
+		"special": "cyan",
+		"number": "yellow",
+		"boolean": "yellow",
+		"undefined": "grey",
+		"null": "bold",
+		"string": "green",
+		"date": "magenta",
+		"regexp": "red"
+	};
+	function stylizeWithColor(str, styleType) {
+		var style = inspect.styles[styleType];
+		if (style) return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
+		else return str;
+	}
+	function stylizeNoColor(str, styleType) {
+		return str;
+	}
+	function arrayToHash(array) {
+		var hash = {};
+		array.forEach(function(val, idx) {
+			hash[val] = true;
+		});
+		return hash;
+	}
+	function formatValue(ctx, value, recurseTimes) {
+		if (ctx.customInspect && value && isFunction(value.inspect) && value.inspect !== inspect && !(value.constructor && value.constructor.prototype === value)) {
+			var ret = value.inspect(recurseTimes, ctx);
+			if (!isString(ret)) ret = formatValue(ctx, ret, recurseTimes);
+			return ret;
+		}
+		var primitive = formatPrimitive(ctx, value);
+		if (primitive) return primitive;
+		var keys = Object.keys(value);
+		var visibleKeys = arrayToHash(keys);
+		if (ctx.showHidden) keys = Object.getOwnPropertyNames(value);
+		if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0)) return formatError(value);
+		if (keys.length === 0) {
+			if (isFunction(value)) {
+				var name = value.name ? ": " + value.name : "";
+				return ctx.stylize("[Function" + name + "]", "special");
+			}
+			if (isRegExp(value)) return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+			if (isDate(value)) return ctx.stylize(Date.prototype.toString.call(value), "date");
+			if (isError(value)) return formatError(value);
+		}
+		var base = "", array = false, braces = ["{", "}"];
+		if (isArray(value)) {
+			array = true;
+			braces = ["[", "]"];
+		}
+		if (isFunction(value)) base = " [Function" + (value.name ? ": " + value.name : "") + "]";
+		if (isRegExp(value)) base = " " + RegExp.prototype.toString.call(value);
+		if (isDate(value)) base = " " + Date.prototype.toUTCString.call(value);
+		if (isError(value)) base = " " + formatError(value);
+		if (keys.length === 0 && (!array || value.length == 0)) return braces[0] + base + braces[1];
+		if (recurseTimes < 0) if (isRegExp(value)) return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+		else return ctx.stylize("[Object]", "special");
+		ctx.seen.push(value);
+		var output;
+		if (array) output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+		else output = keys.map(function(key) {
+			return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+		});
+		ctx.seen.pop();
+		return reduceToSingleString(output, base, braces);
+	}
+	function formatPrimitive(ctx, value) {
+		if (isUndefined(value)) return ctx.stylize("undefined", "undefined");
+		if (isString(value)) {
+			var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, "\"") + "'";
+			return ctx.stylize(simple, "string");
+		}
+		if (isNumber(value)) return ctx.stylize("" + value, "number");
+		if (isBoolean(value)) return ctx.stylize("" + value, "boolean");
+		if (isNull(value)) return ctx.stylize("null", "null");
+	}
+	function formatError(value) {
+		return "[" + Error.prototype.toString.call(value) + "]";
+	}
+	function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+		var output = [];
+		for (var i = 0, l = value.length; i < l; ++i) if (hasOwnProperty(value, String(i))) output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+		else output.push("");
+		keys.forEach(function(key) {
+			if (!key.match(/^\d+$/)) output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
+		});
+		return output;
+	}
+	function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+		var name, str, desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+		if (desc.get) if (desc.set) str = ctx.stylize("[Getter/Setter]", "special");
+		else str = ctx.stylize("[Getter]", "special");
+		else if (desc.set) str = ctx.stylize("[Setter]", "special");
+		if (!hasOwnProperty(visibleKeys, key)) name = "[" + key + "]";
+		if (!str) if (ctx.seen.indexOf(desc.value) < 0) {
+			if (isNull(recurseTimes)) str = formatValue(ctx, desc.value, null);
+			else str = formatValue(ctx, desc.value, recurseTimes - 1);
+			if (str.indexOf("\n") > -1) if (array) str = str.split("\n").map(function(line) {
+				return "  " + line;
+			}).join("\n").substr(2);
+			else str = "\n" + str.split("\n").map(function(line) {
+				return "   " + line;
+			}).join("\n");
+		} else str = ctx.stylize("[Circular]", "special");
+		if (isUndefined(name)) {
+			if (array && key.match(/^\d+$/)) return str;
+			name = JSON.stringify("" + key);
+			if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+				name = name.substr(1, name.length - 2);
+				name = ctx.stylize(name, "name");
+			} else {
+				name = name.replace(/'/g, "\\'").replace(/\\"/g, "\"").replace(/(^"|"$)/g, "'");
+				name = ctx.stylize(name, "string");
+			}
+		}
+		return name + ": " + str;
+	}
+	function reduceToSingleString(output, base, braces) {
+		var numLinesEst = 0;
+		if (output.reduce(function(prev, cur) {
+			numLinesEst++;
+			if (cur.indexOf("\n") >= 0) numLinesEst++;
+			return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+		}, 0) > 60) return braces[0] + (base === "" ? "" : base + "\n ") + " " + output.join(",\n  ") + " " + braces[1];
+		return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+	}
+	function isArray(ar) {
+		return Array.isArray(ar);
+	}
+	function isBoolean(arg) {
+		return typeof arg === "boolean";
+	}
+	function isNull(arg) {
+		return arg === null;
+	}
+	function isNumber(arg) {
+		return typeof arg === "number";
+	}
+	function isString(arg) {
+		return typeof arg === "string";
+	}
+	function isUndefined(arg) {
+		return arg === void 0;
+	}
+	function isRegExp(re) {
+		return isObject(re) && objectToString(re) === "[object RegExp]";
+	}
+	function isObject(arg) {
+		return typeof arg === "object" && arg !== null;
+	}
+	function isDate(d) {
+		return isObject(d) && objectToString(d) === "[object Date]";
+	}
+	function isError(e) {
+		return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
+	}
+	function isFunction(arg) {
+		return typeof arg === "function";
+	}
+	function objectToString(o) {
+		return Object.prototype.toString.call(o);
+	}
+	function _extend(origin, add) {
+		if (!add || !isObject(add)) return origin;
+		var keys = Object.keys(add);
+		var i = keys.length;
+		while (i--) origin[keys[i]] = add[keys[i]];
+		return origin;
+	}
+	function hasOwnProperty(obj, prop) {
+		return Object.prototype.hasOwnProperty.call(obj, prop);
+	}
+	var kCustomPromisifiedSymbol = typeof Symbol !== "undefined" ? Symbol("util.promisify.custom") : void 0;
+	function promisify(original) {
+		if (typeof original !== "function") throw new TypeError("The \"original\" argument must be of type Function");
+		if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+			var fn = original[kCustomPromisifiedSymbol];
+			if (typeof fn !== "function") throw new TypeError("The \"util.promisify.custom\" argument must be of type Function");
+			Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+				value: fn,
+				enumerable: false,
+				writable: false,
+				configurable: true
+			});
+			return fn;
+		}
+		function fn() {
+			var promiseResolve, promiseReject;
+			var promise = new Promise(function(resolve, reject) {
+				promiseResolve = resolve;
+				promiseReject = reject;
+			});
+			var args = [];
+			for (var i = 0; i < arguments.length; i++) args.push(arguments[i]);
+			args.push(function(err, value) {
+				if (err) promiseReject(err);
+				else promiseResolve(value);
+			});
+			try {
+				original.apply(this, args);
+			} catch (err) {
+				promiseReject(err);
+			}
+			return promise;
+		}
+		Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
+		if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
+			value: fn,
+			enumerable: false,
+			writable: false,
+			configurable: true
+		});
+		return Object.defineProperties(fn, getOwnPropertyDescriptors(original));
+	}
+	promisify.custom = kCustomPromisifiedSymbol;
+	//#endregion
+	//#region \0polyfill-node._buffer_list.js
+	var _polyfill_node__buffer_list_default = BufferList;
+	function BufferList() {
+		this.head = null;
+		this.tail = null;
+		this.length = 0;
+	}
+	BufferList.prototype.push = function(v) {
+		var entry = {
+			data: v,
+			next: null
+		};
+		if (this.length > 0) this.tail.next = entry;
+		else this.head = entry;
+		this.tail = entry;
+		++this.length;
+	};
+	BufferList.prototype.unshift = function(v) {
+		var entry = {
+			data: v,
+			next: this.head
+		};
+		if (this.length === 0) this.tail = entry;
+		this.head = entry;
+		++this.length;
+	};
+	BufferList.prototype.shift = function() {
+		if (this.length === 0) return;
+		var ret = this.head.data;
+		if (this.length === 1) this.head = this.tail = null;
+		else this.head = this.head.next;
+		--this.length;
+		return ret;
+	};
+	BufferList.prototype.clear = function() {
+		this.head = this.tail = null;
+		this.length = 0;
+	};
+	BufferList.prototype.join = function(s) {
+		if (this.length === 0) return "";
+		var p = this.head;
+		var ret = "" + p.data;
+		while (p = p.next) ret += s + p.data;
+		return ret;
+	};
+	BufferList.prototype.concat = function(n) {
+		if (this.length === 0) return Buffer$1.alloc(0);
+		if (this.length === 1) return this.head.data;
+		var ret = Buffer$1.allocUnsafe(n >>> 0);
+		var p = this.head;
+		var i = 0;
+		while (p) {
+			p.data.copy(ret, i);
+			i += p.data.length;
+			p = p.next;
+		}
+		return ret;
+	};
+	//#endregion
+	//#region \0polyfill-node.string_decoder.js
+	var isBufferEncoding = Buffer$1.isEncoding || function(encoding) {
+		switch (encoding && encoding.toLowerCase()) {
+			case "hex":
+			case "utf8":
+			case "utf-8":
+			case "ascii":
+			case "binary":
+			case "base64":
+			case "ucs2":
+			case "ucs-2":
+			case "utf16le":
+			case "utf-16le":
+			case "raw": return true;
+			default: return false;
+		}
+	};
+	function assertEncoding(encoding) {
+		if (encoding && !isBufferEncoding(encoding)) throw new Error("Unknown encoding: " + encoding);
+	}
+	function StringDecoder(encoding) {
+		this.encoding = (encoding || "utf8").toLowerCase().replace(/[-_]/, "");
+		assertEncoding(encoding);
+		switch (this.encoding) {
+			case "utf8":
+				this.surrogateSize = 3;
+				break;
+			case "ucs2":
+			case "utf16le":
+				this.surrogateSize = 2;
+				this.detectIncompleteChar = utf16DetectIncompleteChar;
+				break;
+			case "base64":
+				this.surrogateSize = 3;
+				this.detectIncompleteChar = base64DetectIncompleteChar;
+				break;
+			default:
+				this.write = passThroughWrite;
+				return;
+		}
+		this.charBuffer = new Buffer$1(6);
+		this.charReceived = 0;
+		this.charLength = 0;
+	}
+	StringDecoder.prototype.write = function(buffer) {
+		var charStr = "";
+		while (this.charLength) {
+			var available = buffer.length >= this.charLength - this.charReceived ? this.charLength - this.charReceived : buffer.length;
+			buffer.copy(this.charBuffer, this.charReceived, 0, available);
+			this.charReceived += available;
+			if (this.charReceived < this.charLength) return "";
+			buffer = buffer.slice(available, buffer.length);
+			charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+			var charCode = charStr.charCodeAt(charStr.length - 1);
+			if (charCode >= 55296 && charCode <= 56319) {
+				this.charLength += this.surrogateSize;
+				charStr = "";
+				continue;
+			}
+			this.charReceived = this.charLength = 0;
+			if (buffer.length === 0) return charStr;
+			break;
+		}
+		this.detectIncompleteChar(buffer);
+		var end = buffer.length;
+		if (this.charLength) {
+			buffer.copy(this.charBuffer, 0, buffer.length - this.charReceived, end);
+			end -= this.charReceived;
+		}
+		charStr += buffer.toString(this.encoding, 0, end);
+		var end = charStr.length - 1;
+		var charCode = charStr.charCodeAt(end);
+		if (charCode >= 55296 && charCode <= 56319) {
+			var size = this.surrogateSize;
+			this.charLength += size;
+			this.charReceived += size;
+			this.charBuffer.copy(this.charBuffer, size, 0, size);
+			buffer.copy(this.charBuffer, 0, 0, size);
+			return charStr.substring(0, end);
+		}
+		return charStr;
+	};
+	StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+		var i = buffer.length >= 3 ? 3 : buffer.length;
+		for (; i > 0; i--) {
+			var c = buffer[buffer.length - i];
+			if (i == 1 && c >> 5 == 6) {
+				this.charLength = 2;
+				break;
+			}
+			if (i <= 2 && c >> 4 == 14) {
+				this.charLength = 3;
+				break;
+			}
+			if (i <= 3 && c >> 3 == 30) {
+				this.charLength = 4;
+				break;
+			}
+		}
+		this.charReceived = i;
+	};
+	StringDecoder.prototype.end = function(buffer) {
+		var res = "";
+		if (buffer && buffer.length) res = this.write(buffer);
+		if (this.charReceived) {
+			var cr = this.charReceived;
+			var buf = this.charBuffer;
+			var enc = this.encoding;
+			res += buf.slice(0, cr).toString(enc);
+		}
+		return res;
+	};
+	function passThroughWrite(buffer) {
+		return buffer.toString(this.encoding);
+	}
+	function utf16DetectIncompleteChar(buffer) {
+		this.charReceived = buffer.length % 2;
+		this.charLength = this.charReceived ? 2 : 0;
+	}
+	function base64DetectIncompleteChar(buffer) {
+		this.charReceived = buffer.length % 3;
+		this.charLength = this.charReceived ? 3 : 0;
+	}
+	//#endregion
+	//#region \0polyfill-node._stream_readable.js
+	Readable.ReadableState = ReadableState;
+	var debug = debuglog("stream");
+	_polyfill_node__inherits_default(Readable, EventEmitter);
+	function prependListener(emitter, event, fn) {
+		if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
+		else if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);
+		else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);
+		else emitter._events[event] = [fn, emitter._events[event]];
+	}
+	function listenerCount(emitter, type) {
+		return emitter.listeners(type).length;
+	}
+	function ReadableState(options, stream) {
+		options = options || {};
+		this.objectMode = !!options.objectMode;
+		if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
+		var hwm = options.highWaterMark;
+		var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+		this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
+		this.highWaterMark = ~~this.highWaterMark;
+		this.buffer = new _polyfill_node__buffer_list_default();
+		this.length = 0;
+		this.pipes = null;
+		this.pipesCount = 0;
+		this.flowing = null;
+		this.ended = false;
+		this.endEmitted = false;
+		this.reading = false;
+		this.sync = true;
+		this.needReadable = false;
+		this.emittedReadable = false;
+		this.readableListening = false;
+		this.resumeScheduled = false;
+		this.defaultEncoding = options.defaultEncoding || "utf8";
+		this.ranOut = false;
+		this.awaitDrain = 0;
+		this.readingMore = false;
+		this.decoder = null;
+		this.encoding = null;
+		if (options.encoding) {
+			this.decoder = new StringDecoder(options.encoding);
+			this.encoding = options.encoding;
+		}
+	}
+	function Readable(options) {
+		if (!(this instanceof Readable)) return new Readable(options);
+		this._readableState = new ReadableState(options, this);
+		this.readable = true;
+		if (options && typeof options.read === "function") this._read = options.read;
+		EventEmitter.call(this);
+	}
+	Readable.prototype.push = function(chunk, encoding) {
+		var state = this._readableState;
+		if (!state.objectMode && typeof chunk === "string") {
+			encoding = encoding || state.defaultEncoding;
+			if (encoding !== state.encoding) {
+				chunk = Buffer$1.from(chunk, encoding);
+				encoding = "";
+			}
+		}
+		return readableAddChunk(this, state, chunk, encoding, false);
+	};
+	Readable.prototype.unshift = function(chunk) {
+		var state = this._readableState;
+		return readableAddChunk(this, state, chunk, "", true);
+	};
+	Readable.prototype.isPaused = function() {
+		return this._readableState.flowing === false;
+	};
+	function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+		var er = chunkInvalid(state, chunk);
+		if (er) stream.emit("error", er);
+		else if (chunk === null) {
+			state.reading = false;
+			onEofChunk(stream, state);
+		} else if (state.objectMode || chunk && chunk.length > 0) if (state.ended && !addToFront) {
+			var e = /* @__PURE__ */ new Error("stream.push() after EOF");
+			stream.emit("error", e);
+		} else if (state.endEmitted && addToFront) {
+			var _e = /* @__PURE__ */ new Error("stream.unshift() after end event");
+			stream.emit("error", _e);
+		} else {
+			var skipAdd;
+			if (state.decoder && !addToFront && !encoding) {
+				chunk = state.decoder.write(chunk);
+				skipAdd = !state.objectMode && chunk.length === 0;
+			}
+			if (!addToFront) state.reading = false;
+			if (!skipAdd) if (state.flowing && state.length === 0 && !state.sync) {
+				stream.emit("data", chunk);
+				stream.read(0);
+			} else {
+				state.length += state.objectMode ? 1 : chunk.length;
+				if (addToFront) state.buffer.unshift(chunk);
+				else state.buffer.push(chunk);
+				if (state.needReadable) emitReadable(stream);
+			}
+			maybeReadMore(stream, state);
+		}
+		else if (!addToFront) state.reading = false;
+		return needMoreData(state);
+	}
+	function needMoreData(state) {
+		return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+	}
+	Readable.prototype.setEncoding = function(enc) {
+		this._readableState.decoder = new StringDecoder(enc);
+		this._readableState.encoding = enc;
+		return this;
+	};
+	var MAX_HWM = 8388608;
+	function computeNewHighWaterMark(n) {
+		if (n >= MAX_HWM) n = MAX_HWM;
+		else {
+			n--;
+			n |= n >>> 1;
+			n |= n >>> 2;
+			n |= n >>> 4;
+			n |= n >>> 8;
+			n |= n >>> 16;
+			n++;
+		}
+		return n;
+	}
+	function howMuchToRead(n, state) {
+		if (n <= 0 || state.length === 0 && state.ended) return 0;
+		if (state.objectMode) return 1;
+		if (n !== n) if (state.flowing && state.length) return state.buffer.head.data.length;
+		else return state.length;
+		if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+		if (n <= state.length) return n;
+		if (!state.ended) {
+			state.needReadable = true;
+			return 0;
+		}
+		return state.length;
+	}
+	Readable.prototype.read = function(n) {
+		debug("read", n);
+		n = parseInt(n, 10);
+		var state = this._readableState;
+		var nOrig = n;
+		if (n !== 0) state.emittedReadable = false;
+		if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
+			debug("read: emitReadable", state.length, state.ended);
+			if (state.length === 0 && state.ended) endReadable(this);
+			else emitReadable(this);
+			return null;
+		}
+		n = howMuchToRead(n, state);
+		if (n === 0 && state.ended) {
+			if (state.length === 0) endReadable(this);
+			return null;
+		}
+		var doRead = state.needReadable;
+		debug("need readable", doRead);
+		if (state.length === 0 || state.length - n < state.highWaterMark) {
+			doRead = true;
+			debug("length less than watermark", doRead);
+		}
+		if (state.ended || state.reading) {
+			doRead = false;
+			debug("reading or ended", doRead);
+		} else if (doRead) {
+			debug("do read");
+			state.reading = true;
+			state.sync = true;
+			if (state.length === 0) state.needReadable = true;
+			this._read(state.highWaterMark);
+			state.sync = false;
+			if (!state.reading) n = howMuchToRead(nOrig, state);
+		}
+		var ret;
+		if (n > 0) ret = fromList(n, state);
+		else ret = null;
+		if (ret === null) {
+			state.needReadable = true;
+			n = 0;
+		} else state.length -= n;
+		if (state.length === 0) {
+			if (!state.ended) state.needReadable = true;
+			if (nOrig !== n && state.ended) endReadable(this);
+		}
+		if (ret !== null) this.emit("data", ret);
+		return ret;
+	};
+	function chunkInvalid(state, chunk) {
+		var er = null;
+		if (!Buffer$1.isBuffer(chunk) && typeof chunk !== "string" && chunk !== null && chunk !== void 0 && !state.objectMode) er = /* @__PURE__ */ new TypeError("Invalid non-string/buffer chunk");
+		return er;
+	}
+	function onEofChunk(stream, state) {
+		if (state.ended) return;
+		if (state.decoder) {
+			var chunk = state.decoder.end();
+			if (chunk && chunk.length) {
+				state.buffer.push(chunk);
+				state.length += state.objectMode ? 1 : chunk.length;
+			}
+		}
+		state.ended = true;
+		emitReadable(stream);
+	}
+	function emitReadable(stream) {
+		var state = stream._readableState;
+		state.needReadable = false;
+		if (!state.emittedReadable) {
+			debug("emitReadable", state.flowing);
+			state.emittedReadable = true;
+			if (state.sync) nextTick(emitReadable_, stream);
+			else emitReadable_(stream);
+		}
+	}
+	function emitReadable_(stream) {
+		debug("emit readable");
+		stream.emit("readable");
+		flow(stream);
+	}
+	function maybeReadMore(stream, state) {
+		if (!state.readingMore) {
+			state.readingMore = true;
+			nextTick(maybeReadMore_, stream, state);
+		}
+	}
+	function maybeReadMore_(stream, state) {
+		var len = state.length;
+		while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
+			debug("maybeReadMore read 0");
+			stream.read(0);
+			if (len === state.length) break;
+			else len = state.length;
+		}
+		state.readingMore = false;
+	}
+	Readable.prototype._read = function(n) {
+		this.emit("error", /* @__PURE__ */ new Error("not implemented"));
+	};
+	Readable.prototype.pipe = function(dest, pipeOpts) {
+		var src = this;
+		var state = this._readableState;
+		switch (state.pipesCount) {
+			case 0:
+				state.pipes = dest;
+				break;
+			case 1:
+				state.pipes = [state.pipes, dest];
+				break;
+			default:
+				state.pipes.push(dest);
+				break;
+		}
+		state.pipesCount += 1;
+		debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
+		var endFn = !pipeOpts || pipeOpts.end !== false ? onend : cleanup;
+		if (state.endEmitted) nextTick(endFn);
+		else src.once("end", endFn);
+		dest.on("unpipe", onunpipe);
+		function onunpipe(readable) {
+			debug("onunpipe");
+			if (readable === src) cleanup();
+		}
+		function onend() {
+			debug("onend");
+			dest.end();
+		}
+		var ondrain = pipeOnDrain(src);
+		dest.on("drain", ondrain);
+		var cleanedUp = false;
+		function cleanup() {
+			debug("cleanup");
+			dest.removeListener("close", onclose);
+			dest.removeListener("finish", onfinish);
+			dest.removeListener("drain", ondrain);
+			dest.removeListener("error", onerror);
+			dest.removeListener("unpipe", onunpipe);
+			src.removeListener("end", onend);
+			src.removeListener("end", cleanup);
+			src.removeListener("data", ondata);
+			cleanedUp = true;
+			if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+		}
+		var increasedAwaitDrain = false;
+		src.on("data", ondata);
+		function ondata(chunk) {
+			debug("ondata");
+			increasedAwaitDrain = false;
+			if (false === dest.write(chunk) && !increasedAwaitDrain) {
+				if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+					debug("false write response, pause", src._readableState.awaitDrain);
+					src._readableState.awaitDrain++;
+					increasedAwaitDrain = true;
+				}
+				src.pause();
+			}
+		}
+		function onerror(er) {
+			debug("onerror", er);
+			unpipe();
+			dest.removeListener("error", onerror);
+			if (listenerCount(dest, "error") === 0) dest.emit("error", er);
+		}
+		prependListener(dest, "error", onerror);
+		function onclose() {
+			dest.removeListener("finish", onfinish);
+			unpipe();
+		}
+		dest.once("close", onclose);
+		function onfinish() {
+			debug("onfinish");
+			dest.removeListener("close", onclose);
+			unpipe();
+		}
+		dest.once("finish", onfinish);
+		function unpipe() {
+			debug("unpipe");
+			src.unpipe(dest);
+		}
+		dest.emit("pipe", src);
+		if (!state.flowing) {
+			debug("pipe resume");
+			src.resume();
+		}
+		return dest;
+	};
+	function pipeOnDrain(src) {
+		return function() {
+			var state = src._readableState;
+			debug("pipeOnDrain", state.awaitDrain);
+			if (state.awaitDrain) state.awaitDrain--;
+			if (state.awaitDrain === 0 && src.listeners("data").length) {
+				state.flowing = true;
+				flow(src);
+			}
+		};
+	}
+	Readable.prototype.unpipe = function(dest) {
+		var state = this._readableState;
+		if (state.pipesCount === 0) return this;
+		if (state.pipesCount === 1) {
+			if (dest && dest !== state.pipes) return this;
+			if (!dest) dest = state.pipes;
+			state.pipes = null;
+			state.pipesCount = 0;
+			state.flowing = false;
+			if (dest) dest.emit("unpipe", this);
+			return this;
+		}
+		if (!dest) {
+			var dests = state.pipes;
+			var len = state.pipesCount;
+			state.pipes = null;
+			state.pipesCount = 0;
+			state.flowing = false;
+			for (var _i = 0; _i < len; _i++) dests[_i].emit("unpipe", this);
+			return this;
+		}
+		var i = indexOf(state.pipes, dest);
+		if (i === -1) return this;
+		state.pipes.splice(i, 1);
+		state.pipesCount -= 1;
+		if (state.pipesCount === 1) state.pipes = state.pipes[0];
+		dest.emit("unpipe", this);
+		return this;
+	};
+	Readable.prototype.on = function(ev, fn) {
+		var res = EventEmitter.prototype.on.call(this, ev, fn);
+		if (ev === "data") {
+			if (this._readableState.flowing !== false) this.resume();
+		} else if (ev === "readable") {
+			var state = this._readableState;
+			if (!state.endEmitted && !state.readableListening) {
+				state.readableListening = state.needReadable = true;
+				state.emittedReadable = false;
+				if (!state.reading) nextTick(nReadingNextTick, this);
+				else if (state.length) emitReadable(this, state);
+			}
+		}
+		return res;
+	};
+	Readable.prototype.addListener = Readable.prototype.on;
+	function nReadingNextTick(self) {
+		debug("readable nexttick read 0");
+		self.read(0);
+	}
+	Readable.prototype.resume = function() {
+		var state = this._readableState;
+		if (!state.flowing) {
+			debug("resume");
+			state.flowing = true;
+			resume(this, state);
+		}
+		return this;
+	};
+	function resume(stream, state) {
+		if (!state.resumeScheduled) {
+			state.resumeScheduled = true;
+			nextTick(resume_, stream, state);
+		}
+	}
+	function resume_(stream, state) {
+		if (!state.reading) {
+			debug("resume read 0");
+			stream.read(0);
+		}
+		state.resumeScheduled = false;
+		state.awaitDrain = 0;
+		stream.emit("resume");
+		flow(stream);
+		if (state.flowing && !state.reading) stream.read(0);
+	}
+	Readable.prototype.pause = function() {
+		debug("call pause flowing=%j", this._readableState.flowing);
+		if (false !== this._readableState.flowing) {
+			debug("pause");
+			this._readableState.flowing = false;
+			this.emit("pause");
+		}
+		return this;
+	};
+	function flow(stream) {
+		var state = stream._readableState;
+		debug("flow", state.flowing);
+		while (state.flowing && stream.read() !== null);
+	}
+	Readable.prototype.wrap = function(stream) {
+		var state = this._readableState;
+		var paused = false;
+		var self = this;
+		stream.on("end", function() {
+			debug("wrapped end");
+			if (state.decoder && !state.ended) {
+				var chunk = state.decoder.end();
+				if (chunk && chunk.length) self.push(chunk);
+			}
+			self.push(null);
+		});
+		stream.on("data", function(chunk) {
+			debug("wrapped data");
+			if (state.decoder) chunk = state.decoder.write(chunk);
+			if (state.objectMode && (chunk === null || chunk === void 0)) return;
+			else if (!state.objectMode && (!chunk || !chunk.length)) return;
+			if (!self.push(chunk)) {
+				paused = true;
+				stream.pause();
+			}
+		});
+		for (var i in stream) if (this[i] === void 0 && typeof stream[i] === "function") this[i] = function(method) {
+			return function() {
+				return stream[method].apply(stream, arguments);
+			};
+		}(i);
+		forEach([
+			"error",
+			"close",
+			"destroy",
+			"pause",
+			"resume"
+		], function(ev) {
+			stream.on(ev, self.emit.bind(self, ev));
+		});
+		self._read = function(n) {
+			debug("wrapped _read", n);
+			if (paused) {
+				paused = false;
+				stream.resume();
+			}
+		};
+		return self;
+	};
+	Readable._fromList = fromList;
+	function fromList(n, state) {
+		if (state.length === 0) return null;
+		var ret;
+		if (state.objectMode) ret = state.buffer.shift();
+		else if (!n || n >= state.length) {
+			if (state.decoder) ret = state.buffer.join("");
+			else if (state.buffer.length === 1) ret = state.buffer.head.data;
+			else ret = state.buffer.concat(state.length);
+			state.buffer.clear();
+		} else ret = fromListPartial(n, state.buffer, state.decoder);
+		return ret;
+	}
+	function fromListPartial(n, list, hasStrings) {
+		var ret;
+		if (n < list.head.data.length) {
+			ret = list.head.data.slice(0, n);
+			list.head.data = list.head.data.slice(n);
+		} else if (n === list.head.data.length) ret = list.shift();
+		else ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+		return ret;
+	}
+	function copyFromBufferString(n, list) {
+		var p = list.head;
+		var c = 1;
+		var ret = p.data;
+		n -= ret.length;
+		while (p = p.next) {
+			var str = p.data;
+			var nb = n > str.length ? str.length : n;
+			if (nb === str.length) ret += str;
+			else ret += str.slice(0, n);
+			n -= nb;
+			if (n === 0) {
+				if (nb === str.length) {
+					++c;
+					if (p.next) list.head = p.next;
+					else list.head = list.tail = null;
+				} else {
+					list.head = p;
+					p.data = str.slice(nb);
+				}
+				break;
+			}
+			++c;
+		}
+		list.length -= c;
+		return ret;
+	}
+	function copyFromBuffer(n, list) {
+		var ret = Buffer$1.allocUnsafe(n);
+		var p = list.head;
+		var c = 1;
+		p.data.copy(ret);
+		n -= p.data.length;
+		while (p = p.next) {
+			var buf = p.data;
+			var nb = n > buf.length ? buf.length : n;
+			buf.copy(ret, ret.length - n, 0, nb);
+			n -= nb;
+			if (n === 0) {
+				if (nb === buf.length) {
+					++c;
+					if (p.next) list.head = p.next;
+					else list.head = list.tail = null;
+				} else {
+					list.head = p;
+					p.data = buf.slice(nb);
+				}
+				break;
+			}
+			++c;
+		}
+		list.length -= c;
+		return ret;
+	}
+	function endReadable(stream) {
+		var state = stream._readableState;
+		if (state.length > 0) throw new Error("\"endReadable()\" called on non-empty stream");
+		if (!state.endEmitted) {
+			state.ended = true;
+			nextTick(endReadableNT, state, stream);
+		}
+	}
+	function endReadableNT(state, stream) {
+		if (!state.endEmitted && state.length === 0) {
+			state.endEmitted = true;
+			stream.readable = false;
+			stream.emit("end");
+		}
+	}
+	function forEach(xs, f) {
+		for (var i = 0, l = xs.length; i < l; i++) f(xs[i], i);
+	}
+	function indexOf(xs, x) {
+		for (var i = 0, l = xs.length; i < l; i++) if (xs[i] === x) return i;
+		return -1;
+	}
+	//#endregion
+	//#region \0polyfill-node._stream_writable.js
+	Writable.WritableState = WritableState;
+	_polyfill_node__inherits_default(Writable, EventEmitter);
+	function nop() {}
+	function WriteReq(chunk, encoding, cb) {
+		this.chunk = chunk;
+		this.encoding = encoding;
+		this.callback = cb;
+		this.next = null;
+	}
+	function WritableState(options, stream) {
+		Object.defineProperty(this, "buffer", { get: deprecate(function() {
+			return this.getBuffer();
+		}, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.") });
+		options = options || {};
+		this.objectMode = !!options.objectMode;
+		if (stream instanceof Duplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+		var hwm = options.highWaterMark;
+		var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+		this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;
+		this.highWaterMark = ~~this.highWaterMark;
+		this.needDrain = false;
+		this.ending = false;
+		this.ended = false;
+		this.finished = false;
+		this.decodeStrings = !(options.decodeStrings === false);
+		this.defaultEncoding = options.defaultEncoding || "utf8";
+		this.length = 0;
+		this.writing = false;
+		this.corked = 0;
+		this.sync = true;
+		this.bufferProcessing = false;
+		this.onwrite = function(er) {
+			onwrite(stream, er);
+		};
+		this.writecb = null;
+		this.writelen = 0;
+		this.bufferedRequest = null;
+		this.lastBufferedRequest = null;
+		this.pendingcb = 0;
+		this.prefinished = false;
+		this.errorEmitted = false;
+		this.bufferedRequestCount = 0;
+		this.corkedRequestsFree = new CorkedRequest(this);
+	}
+	WritableState.prototype.getBuffer = function writableStateGetBuffer() {
+		var current = this.bufferedRequest;
+		var out = [];
+		while (current) {
+			out.push(current);
+			current = current.next;
+		}
+		return out;
+	};
+	function Writable(options) {
+		if (!(this instanceof Writable) && !(this instanceof Duplex)) return new Writable(options);
+		this._writableState = new WritableState(options, this);
+		this.writable = true;
+		if (options) {
+			if (typeof options.write === "function") this._write = options.write;
+			if (typeof options.writev === "function") this._writev = options.writev;
+		}
+		EventEmitter.call(this);
+	}
+	Writable.prototype.pipe = function() {
+		this.emit("error", /* @__PURE__ */ new Error("Cannot pipe, not readable"));
+	};
+	function writeAfterEnd(stream, cb) {
+		var er = /* @__PURE__ */ new Error("write after end");
+		stream.emit("error", er);
+		nextTick(cb, er);
+	}
+	function validChunk(stream, state, chunk, cb) {
+		var valid = true;
+		var er = false;
+		if (chunk === null) er = /* @__PURE__ */ new TypeError("May not write null values to stream");
+		else if (!Buffer$1.isBuffer(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) er = /* @__PURE__ */ new TypeError("Invalid non-string/buffer chunk");
+		if (er) {
+			stream.emit("error", er);
+			nextTick(cb, er);
+			valid = false;
+		}
+		return valid;
+	}
+	Writable.prototype.write = function(chunk, encoding, cb) {
+		var state = this._writableState;
+		var ret = false;
+		if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = null;
+		}
+		if (Buffer$1.isBuffer(chunk)) encoding = "buffer";
+		else if (!encoding) encoding = state.defaultEncoding;
+		if (typeof cb !== "function") cb = nop;
+		if (state.ended) writeAfterEnd(this, cb);
+		else if (validChunk(this, state, chunk, cb)) {
+			state.pendingcb++;
+			ret = writeOrBuffer(this, state, chunk, encoding, cb);
+		}
+		return ret;
+	};
+	Writable.prototype.cork = function() {
+		var state = this._writableState;
+		state.corked++;
+	};
+	Writable.prototype.uncork = function() {
+		var state = this._writableState;
+		if (state.corked) {
+			state.corked--;
+			if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+		}
+	};
+	Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+		if (typeof encoding === "string") encoding = encoding.toLowerCase();
+		if (!([
+			"hex",
+			"utf8",
+			"utf-8",
+			"ascii",
+			"binary",
+			"base64",
+			"ucs2",
+			"ucs-2",
+			"utf16le",
+			"utf-16le",
+			"raw"
+		].indexOf((encoding + "").toLowerCase()) > -1)) throw new TypeError("Unknown encoding: " + encoding);
+		this._writableState.defaultEncoding = encoding;
+		return this;
+	};
+	function decodeChunk(state, chunk, encoding) {
+		if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") chunk = Buffer$1.from(chunk, encoding);
+		return chunk;
+	}
+	function writeOrBuffer(stream, state, chunk, encoding, cb) {
+		chunk = decodeChunk(state, chunk, encoding);
+		if (Buffer$1.isBuffer(chunk)) encoding = "buffer";
+		var len = state.objectMode ? 1 : chunk.length;
+		state.length += len;
+		var ret = state.length < state.highWaterMark;
+		if (!ret) state.needDrain = true;
+		if (state.writing || state.corked) {
+			var last = state.lastBufferedRequest;
+			state.lastBufferedRequest = new WriteReq(chunk, encoding, cb);
+			if (last) last.next = state.lastBufferedRequest;
+			else state.bufferedRequest = state.lastBufferedRequest;
+			state.bufferedRequestCount += 1;
+		} else doWrite(stream, state, false, len, chunk, encoding, cb);
+		return ret;
+	}
+	function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+		state.writelen = len;
+		state.writecb = cb;
+		state.writing = true;
+		state.sync = true;
+		if (writev) stream._writev(chunk, state.onwrite);
+		else stream._write(chunk, encoding, state.onwrite);
+		state.sync = false;
+	}
+	function onwriteError(stream, state, sync, er, cb) {
+		--state.pendingcb;
+		if (sync) nextTick(cb, er);
+		else cb(er);
+		stream._writableState.errorEmitted = true;
+		stream.emit("error", er);
+	}
+	function onwriteStateUpdate(state) {
+		state.writing = false;
+		state.writecb = null;
+		state.length -= state.writelen;
+		state.writelen = 0;
+	}
+	function onwrite(stream, er) {
+		var state = stream._writableState;
+		var sync = state.sync;
+		var cb = state.writecb;
+		onwriteStateUpdate(state);
+		if (er) onwriteError(stream, state, sync, er, cb);
+		else {
+			var finished = needFinish(state);
+			if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(stream, state);
+			if (sync) nextTick(afterWrite, stream, state, finished, cb);
+			else afterWrite(stream, state, finished, cb);
+		}
+	}
+	function afterWrite(stream, state, finished, cb) {
+		if (!finished) onwriteDrain(stream, state);
+		state.pendingcb--;
+		cb();
+		finishMaybe(stream, state);
+	}
+	function onwriteDrain(stream, state) {
+		if (state.length === 0 && state.needDrain) {
+			state.needDrain = false;
+			stream.emit("drain");
+		}
+	}
+	function clearBuffer(stream, state) {
+		state.bufferProcessing = true;
+		var entry = state.bufferedRequest;
+		if (stream._writev && entry && entry.next) {
+			var l = state.bufferedRequestCount;
+			var buffer = new Array(l);
+			var holder = state.corkedRequestsFree;
+			holder.entry = entry;
+			var count = 0;
+			while (entry) {
+				buffer[count] = entry;
+				entry = entry.next;
+				count += 1;
+			}
+			doWrite(stream, state, true, state.length, buffer, "", holder.finish);
+			state.pendingcb++;
+			state.lastBufferedRequest = null;
+			if (holder.next) {
+				state.corkedRequestsFree = holder.next;
+				holder.next = null;
+			} else state.corkedRequestsFree = new CorkedRequest(state);
+		} else {
+			while (entry) {
+				var chunk = entry.chunk;
+				var encoding = entry.encoding;
+				var cb = entry.callback;
+				doWrite(stream, state, false, state.objectMode ? 1 : chunk.length, chunk, encoding, cb);
+				entry = entry.next;
+				if (state.writing) break;
+			}
+			if (entry === null) state.lastBufferedRequest = null;
+		}
+		state.bufferedRequestCount = 0;
+		state.bufferedRequest = entry;
+		state.bufferProcessing = false;
+	}
+	Writable.prototype._write = function(chunk, encoding, cb) {
+		cb(/* @__PURE__ */ new Error("not implemented"));
+	};
+	Writable.prototype._writev = null;
+	Writable.prototype.end = function(chunk, encoding, cb) {
+		var state = this._writableState;
+		if (typeof chunk === "function") {
+			cb = chunk;
+			chunk = null;
+			encoding = null;
+		} else if (typeof encoding === "function") {
+			cb = encoding;
+			encoding = null;
+		}
+		if (chunk !== null && chunk !== void 0) this.write(chunk, encoding);
+		if (state.corked) {
+			state.corked = 1;
+			this.uncork();
+		}
+		if (!state.ending && !state.finished) endWritable(this, state, cb);
+	};
+	function needFinish(state) {
+		return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+	}
+	function prefinish(stream, state) {
+		if (!state.prefinished) {
+			state.prefinished = true;
+			stream.emit("prefinish");
+		}
+	}
+	function finishMaybe(stream, state) {
+		var need = needFinish(state);
+		if (need) if (state.pendingcb === 0) {
+			prefinish(stream, state);
+			state.finished = true;
+			stream.emit("finish");
+		} else prefinish(stream, state);
+		return need;
+	}
+	function endWritable(stream, state, cb) {
+		state.ending = true;
+		finishMaybe(stream, state);
+		if (cb) if (state.finished) nextTick(cb);
+		else stream.once("finish", cb);
+		state.ended = true;
+		stream.writable = false;
+	}
+	function CorkedRequest(state) {
+		var _this = this;
+		this.next = null;
+		this.entry = null;
+		this.finish = function(err) {
+			var entry = _this.entry;
+			_this.entry = null;
+			while (entry) {
+				var cb = entry.callback;
+				state.pendingcb--;
+				cb(err);
+				entry = entry.next;
+			}
+			if (state.corkedRequestsFree) state.corkedRequestsFree.next = _this;
+			else state.corkedRequestsFree = _this;
+		};
+	}
+	//#endregion
+	//#region \0polyfill-node._stream_duplex.js
+	_polyfill_node__inherits_default(Duplex, Readable);
+	var keys = Object.keys(Writable.prototype);
+	for (var v = 0; v < keys.length; v++) {
+		var method = keys[v];
+		if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+	}
+	function Duplex(options) {
+		if (!(this instanceof Duplex)) return new Duplex(options);
+		Readable.call(this, options);
+		Writable.call(this, options);
+		if (options && options.readable === false) this.readable = false;
+		if (options && options.writable === false) this.writable = false;
+		this.allowHalfOpen = true;
+		if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+		this.once("end", onend);
+	}
+	function onend() {
+		if (this.allowHalfOpen || this._writableState.ended) return;
+		nextTick(onEndNT, this);
+	}
+	function onEndNT(self) {
+		self.end();
+	}
+	//#endregion
+	//#region src/util/output-type.ts
+	/**
+	* Output type definitions for document generation.
+	*
+	* This module defines the various output formats supported when generating
+	* .docx files. These types correspond to fflate's output formats.
+	*
+	* @module
+	*/
+	/**
+	* Converts a Uint8Array to the specified output type.
+	*
+	* This is used by both the Packer and patchDocument to convert fflate's
+	* raw Uint8Array output into the user's requested format.
+	*/
+	const convertOutput = (data, type) => {
+		switch (type) {
+			case "nodebuffer": return Buffer$1.from(data);
+			case "blob": return new Blob([data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength)], { type: "application/vnd.openxmlformats-officedocument.wordprocessingml.document" });
+			case "arraybuffer": return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+			case "uint8array": return data;
+			case "base64": return btoa((0, fflate.strFromU8)(data, true));
+			case "string":
+			case "text":
+			case "binarystring": return (0, fflate.strFromU8)(data, true);
+			case "array": return [...data];
+			default: return data;
+		}
+	};
+	//#endregion
+	//#region src/file/fonts/obfuscate-ttf-to-odttf.ts
+	/**
+	* Font obfuscation module for embedding fonts in WordprocessingML documents.
+	*
+	* This module implements the OOXML font obfuscation algorithm used to embed
+	* fonts in DOCX documents. Obfuscation is required by the OOXML specification
+	* to prevent simple extraction of embedded font files.
+	*
+	* Reference: ECMA-376 Part 2, Section 11.1 (Font Embedding)
+	*
+	* @module
+	*/
+	/** Start offset for obfuscation in the font file */
+	const obfuscatedStartOffset = 0;
+	/** End offset for obfuscation (first 32 bytes are obfuscated) */
+	const obfuscatedEndOffset = 32;
+	/** Expected GUID size (32 hex characters without dashes) */
+	const guidSize = 32;
+	/**
+	* Obfuscates a TrueType font file for embedding in OOXML documents.
+	*
+	* The obfuscation algorithm XORs the first 32 bytes of the font file
+	* with a reversed byte sequence derived from the font's GUID key.
+	* This prevents simple extraction while maintaining font functionality.
+	*
+	* @param buf - The original font file as a byte array
+	* @param fontKey - The GUID key for the font (with or without dashes)
+	* @returns The obfuscated font data
+	* @throws Error if the fontKey is not a valid 32-character GUID
+	*
+	* @example
+	* ```typescript
+	* const fontData = readFileSync("font.ttf");
+	* const fontKey = "00000000-0000-0000-0000-000000000000";
+	* const obfuscatedData = obfuscate(fontData, fontKey);
+	* ```
+	*
+	* @internal
+	*/
+	const obfuscate = (buf, fontKey) => {
+		const guid = fontKey.replace(/-/g, "");
+		if (guid.length !== guidSize) throw new Error(`Error: Cannot extract GUID from font filename: ${fontKey}`);
+		const hexNumbers = guid.replace(/(..)/g, "$1 ").trim().split(" ").map((hexString) => parseInt(hexString, 16));
+		hexNumbers.reverse();
+		const obfuscatedBytes = buf.slice(obfuscatedStartOffset, obfuscatedEndOffset).map((byte, i) => byte ^ hexNumbers[i % hexNumbers.length]);
+		const out = new Uint8Array(obfuscatedStartOffset + obfuscatedBytes.length + Math.max(0, buf.length - obfuscatedEndOffset));
+		out.set(buf.slice(0, obfuscatedStartOffset));
+		out.set(obfuscatedBytes, obfuscatedStartOffset);
+		out.set(buf.slice(obfuscatedEndOffset), obfuscatedStartOffset + obfuscatedBytes.length);
+		return out;
+	};
+	//#endregion
+	//#region src/export/formatter.ts
+	/**
+	* Converts XML components into serializable objects ready for XML generation.
+	*
+	* The Formatter is responsible for preparing XML components for serialization by calling
+	* their prepForXml method with the appropriate context. This is a critical step in the
+	* export pipeline that transforms the declarative API objects into XML-compatible structures.
+	*
+	* @example
+	* ```typescript
+	* const formatter = new Formatter();
+	* const paragraph = new Paragraph("Hello World");
+	* const xmlObject = formatter.format(paragraph, context);
+	* ```
+	*/
+	var Formatter = class {
+		/**
+		* Formats an XML component into a serializable object.
+		*
+		* @param input - The XML component to format
+		* @param context - The context containing file state and relationships
+		* @returns A serializable XML object structure
+		* @throws Error if the component cannot be formatted correctly
+		*/
+		format(input, context = { stack: [] }) {
+			const output = input.prepForXml(context);
+			if (output) return output;
+			else throw new Error("XMLComponent did not format correctly");
+		}
+	};
 	//#endregion
 	//#region src/export/packer/image-replacer.ts
 	/**
@@ -18889,32 +22070,6 @@
 		}
 	};
 	//#endregion
-	//#region \0@oxc-project+runtime@0.123.0/helpers/asyncToGenerator.js
-	function asyncGeneratorStep(n, t, e, r, o, a, c) {
-		try {
-			var i = n[a](c), u = i.value;
-		} catch (n) {
-			e(n);
-			return;
-		}
-		i.done ? t(u) : Promise.resolve(u).then(r, o);
-	}
-	function _asyncToGenerator(n) {
-		return function() {
-			var t = this, e = arguments;
-			return new Promise(function(r, o) {
-				var a = n.apply(t, e);
-				function _next(n) {
-					asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
-				}
-				function _throw(n) {
-					asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
-				}
-				_next(void 0);
-			});
-		};
-	}
-	//#endregion
 	//#region src/export/packer/packer.ts
 	/**
 	* Packer module for exporting documents to various output formats.
@@ -18967,11 +22122,8 @@
 		* @param overrides - Optional array of file overrides for custom XML content
 		* @returns A promise resolving to the exported document in the specified format
 		*/
-		static pack(_x, _x2, _x3) {
-			var _this = this;
-			return _asyncToGenerator(function* (file, type, prettify, overrides = []) {
-				return convertOutput((0, fflate.zipSync)(_this.compiler.compile(file, convertPrettifyType(prettify), overrides), { level: 6 }), type);
-			}).apply(this, arguments);
+		static async pack(file, type, prettify, overrides = []) {
+			return convertOutput((0, fflate.zipSync)(this.compiler.compile(file, convertPrettifyType(prettify), overrides), { level: 6 }), type);
 		}
 		/**
 		* Exports a document to a string representation.
@@ -19047,16 +22199,20 @@
 		* ```
 		*/
 		static toStream(file, prettify, overrides = []) {
-			const stream$1 = new stream.Readable({ read() {} });
+			/* v8 ignore start */
+			const stream = new Readable({ read() {} });
+			/* v8 ignore stop */
 			try {
 				const files = this.compiler.compile(file, convertPrettifyType(prettify), overrides);
 				const zip = new fflate.Zip((err, chunk, final) => {
+					/* v8 ignore start */
 					if (err) {
-						stream$1.destroy(err);
+						stream.destroy(err);
 						return;
 					}
-					if (!stream$1.destroyed) stream$1.push(chunk);
-					if (final) stream$1.push(null);
+					/* v8 ignore stop */
+					if (!stream.destroyed) stream.push(chunk);
+					if (final) stream.push(null);
 				});
 				for (const [name, data] of Object.entries(files)) {
 					var _level;
@@ -19068,9 +22224,9 @@
 				}
 				zip.end();
 			} catch (err) {
-				stream$1.destroy(err instanceof Error ? err : new Error(String(err)));
+				stream.destroy(err instanceof Error ? err : new Error(String(err)));
 			}
-			return stream$1;
+			return stream;
 		}
 	};
 	_defineProperty(Packer, "compiler", new Compiler());
@@ -19139,7 +22295,10 @@
 	* // Adds xml:space="preserve" to maintain whitespace
 	* ```
 	*/
-	const patchSpaceAttribute = (element) => _objectSpread2(_objectSpread2({}, element), {}, { attributes: { "xml:space": "preserve" } });
+	const patchSpaceAttribute = (element) => ({
+		...element,
+		attributes: { "xml:space": "preserve" }
+	});
 	/**
 	* Retrieves first-level child elements by parent element name.
 	*
@@ -19331,14 +22490,24 @@
 			if (e.type === "element" && e.name === "w:t") {
 				var _ref, _e$elements;
 				const splitText = ((_ref = (_e$elements = e.elements) === null || _e$elements === void 0 || (_e$elements = _e$elements[0]) === null || _e$elements === void 0 ? void 0 : _e$elements.text) !== null && _ref !== void 0 ? _ref : "").split(token);
-				const newElements = splitText.map((t) => _objectSpread2(_objectSpread2(_objectSpread2({}, e), patchSpaceAttribute(e)), {}, { elements: createTextElementContents(t) }));
+				const newElements = splitText.map((t) => ({
+					...e,
+					...patchSpaceAttribute(e),
+					elements: createTextElementContents(t)
+				}));
 				if (splitText.length > 1) splitIndex = i;
 				return newElements;
 			} else return e;
 		}).flat()) !== null && _runElement$elements$ !== void 0 ? _runElement$elements$ : [];
 		return {
-			left: _objectSpread2(_objectSpread2({}, JSON.parse(JSON.stringify(runElement))), {}, { elements: splitElements.slice(0, splitIndex + 1) }),
-			right: _objectSpread2(_objectSpread2({}, JSON.parse(JSON.stringify(runElement))), {}, { elements: splitElements.slice(splitIndex + 1) })
+			left: {
+				...JSON.parse(JSON.stringify(runElement)),
+				elements: splitElements.slice(0, splitIndex + 1)
+			},
+			right: {
+				...JSON.parse(JSON.stringify(runElement)),
+				elements: splitElements.slice(splitIndex + 1)
+			}
 		};
 	};
 	//#endregion
@@ -19598,9 +22767,15 @@
 						const runElementNonTextualElements = runElementToBeReplaced.elements.filter((e) => e.type === "element" && e.name === "w:rPr");
 						newRunElements = textJson.map((e) => {
 							var _e$elements;
-							return _objectSpread2(_objectSpread2({}, e), {}, { elements: [...runElementNonTextualElements, ...(_e$elements = e.elements) !== null && _e$elements !== void 0 ? _e$elements : []] });
+							return {
+								...e,
+								elements: [...runElementNonTextualElements, ...(_e$elements = e.elements) !== null && _e$elements !== void 0 ? _e$elements : []]
+							};
 						});
-						patchedRightElement = _objectSpread2(_objectSpread2({}, right), {}, { elements: [...runElementNonTextualElements, ...right.elements] });
+						patchedRightElement = {
+							...right,
+							elements: [...runElementNonTextualElements, ...right.elements]
+						};
 					}
 					paragraphElement.elements.splice(index, 1, left, ...newRunElements, patchedRightElement);
 					break;
@@ -19686,69 +22861,70 @@
 	*
 	* @publicApi
 	*/
-	const patchDocument = function() {
-		var _ref = _asyncToGenerator(function* ({ outputType, data, patches, keepOriginalStyles, placeholderDelimiters = {
-			end: "}}",
-			start: "{{"
-		}, recursive = true }) {
-			const zipContent = (0, fflate.unzipSync)((0, undio.toUint8Array)(data));
-			const contexts = /* @__PURE__ */ new Map();
-			const file = { Media: new Media() };
-			const map = /* @__PURE__ */ new Map();
-			const imageRelationshipAdditions = [];
-			const hyperlinkRelationshipAdditions = [];
-			let hasMedia = false;
-			const binaryContentMap = /* @__PURE__ */ new Map();
-			for (const [key, value] of Object.entries(zipContent)) {
-				const startBytes = value.slice(0, 2);
-				if (compareByteArrays(startBytes, UTF16LE) || compareByteArrays(startBytes, UTF16BE)) {
-					binaryContentMap.set(key, value);
-					continue;
-				}
-				if (!key.endsWith(".xml") && !key.endsWith(".rels")) {
-					binaryContentMap.set(key, value);
-					continue;
-				}
-				const json = toJson((0, fflate.strFromU8)(value));
-				if (key === "word/document.xml") {
-					var _json$elements;
-					const document = (_json$elements = json.elements) === null || _json$elements === void 0 ? void 0 : _json$elements.find((i) => i.name === "w:document");
-					if (document && document.attributes) {
-						for (const ns of [
-							"mc",
-							"wp",
-							"r",
-							"w15",
-							"m"
-						]) document.attributes[`xmlns:${ns}`] = DocumentAttributeNamespaces[ns];
-						document.attributes["mc:Ignorable"] = `${document.attributes["mc:Ignorable"] || ""} w15`.trim();
-					}
+	const patchDocument = async ({ outputType, data, patches, keepOriginalStyles, placeholderDelimiters = {
+		end: "}}",
+		start: "{{"
+	}, recursive = true }) => {
+		const zipContent = (0, fflate.unzipSync)((0, undio.toUint8Array)(data));
+		const contexts = /* @__PURE__ */ new Map();
+		const file = { Media: new Media() };
+		const map = /* @__PURE__ */ new Map();
+		const imageRelationshipAdditions = [];
+		const hyperlinkRelationshipAdditions = [];
+		let hasMedia = false;
+		const binaryContentMap = /* @__PURE__ */ new Map();
+		for (const [key, value] of Object.entries(zipContent)) {
+			const startBytes = value.slice(0, 2);
+			if (compareByteArrays(startBytes, UTF16LE) || compareByteArrays(startBytes, UTF16BE)) {
+				binaryContentMap.set(key, value);
+				continue;
+			}
+			if (!key.endsWith(".xml") && !key.endsWith(".rels")) {
+				binaryContentMap.set(key, value);
+				continue;
+			}
+			const json = toJson((0, fflate.strFromU8)(value));
+			if (key === "word/document.xml") {
+				var _json$elements;
+				const document = (_json$elements = json.elements) === null || _json$elements === void 0 ? void 0 : _json$elements.find((i) => i.name === "w:document");
+				if (document && document.attributes) {
+					for (const ns of [
+						"mc",
+						"wp",
+						"r",
+						"w15",
+						"m"
+					]) document.attributes[`xmlns:${ns}`] = DocumentAttributeNamespaces[ns];
+					document.attributes["mc:Ignorable"] = `${document.attributes["mc:Ignorable"] || ""} w15`.trim();
 				}
-				if (key.startsWith("word/") && !key.endsWith(".xml.rels")) {
-					const context = {
-						file,
-						stack: [],
-						viewWrapper: { Relationships: { addRelationship: (linkId, _, target, __) => {
-							hyperlinkRelationshipAdditions.push({
-								hyperlink: {
-									id: linkId,
-									link: target
-								},
-								key
-							});
-						} } }
-					};
-					contexts.set(key, context);
-					if (!(placeholderDelimiters === null || placeholderDelimiters === void 0 ? void 0 : placeholderDelimiters.start.trim()) || !(placeholderDelimiters === null || placeholderDelimiters === void 0 ? void 0 : placeholderDelimiters.end.trim())) throw new Error("Both start and end delimiters must be non-empty strings.");
-					const { start, end } = placeholderDelimiters;
-					for (const [patchKey, patchValue] of Object.entries(patches)) {
-						const patchText = `${start}${patchKey}${end}`;
-						while (true) {
-							const { didFindOccurrence } = replacer({
-								context,
-								json,
-								keepOriginalStyles,
-								patch: _objectSpread2(_objectSpread2({}, patchValue), {}, { children: patchValue.children.map((element) => {
+			}
+			if (key.startsWith("word/") && !key.endsWith(".xml.rels")) {
+				const context = {
+					file,
+					stack: [],
+					viewWrapper: { Relationships: { addRelationship: (linkId, _, target, __) => {
+						hyperlinkRelationshipAdditions.push({
+							hyperlink: {
+								id: linkId,
+								link: target
+							},
+							key
+						});
+					} } }
+				};
+				contexts.set(key, context);
+				if (!(placeholderDelimiters === null || placeholderDelimiters === void 0 ? void 0 : placeholderDelimiters.start.trim()) || !(placeholderDelimiters === null || placeholderDelimiters === void 0 ? void 0 : placeholderDelimiters.end.trim())) throw new Error("Both start and end delimiters must be non-empty strings.");
+				const { start, end } = placeholderDelimiters;
+				for (const [patchKey, patchValue] of Object.entries(patches)) {
+					const patchText = `${start}${patchKey}${end}`;
+					while (true) {
+						const { didFindOccurrence } = replacer({
+							context,
+							json,
+							keepOriginalStyles,
+							patch: {
+								...patchValue,
+								children: patchValue.children.map((element) => {
 									if (element instanceof ExternalHyperlink) {
 										const concreteHyperlink = new ConcreteHyperlink(element.options.children, uniqueId());
 										hyperlinkRelationshipAdditions.push({
@@ -19760,63 +22936,60 @@
 										});
 										return concreteHyperlink;
 									} else return element;
-								}) }),
-								patchText
-							});
-							if (!recursive || !didFindOccurrence) break;
-						}
-					}
-					const mediaDatas = imageReplacer.getMediaData(JSON.stringify(json), context.file.Media);
-					if (mediaDatas.length > 0) {
-						hasMedia = true;
-						imageRelationshipAdditions.push({
-							key,
-							mediaDatas
+								})
+							},
+							patchText
 						});
+						if (!recursive || !didFindOccurrence) break;
 					}
 				}
-				map.set(key, json);
-			}
-			for (const { key, mediaDatas } of imageRelationshipAdditions) {
-				var _map$get;
-				const relationshipKey = `word/_rels/${key.split("/").pop()}.rels`;
-				const relationshipsJson = (_map$get = map.get(relationshipKey)) !== null && _map$get !== void 0 ? _map$get : createRelationshipFile();
-				map.set(relationshipKey, relationshipsJson);
-				const index = getNextRelationshipIndex(relationshipsJson);
-				const newJson = imageReplacer.replace(JSON.stringify(map.get(key)), mediaDatas, index);
-				map.set(key, JSON.parse(newJson));
-				for (let i = 0; i < mediaDatas.length; i++) {
-					const { fileName } = mediaDatas[i];
-					appendRelationship(relationshipsJson, index + i, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", `media/${fileName}`);
+				const mediaDatas = imageReplacer.getMediaData(JSON.stringify(json), context.file.Media);
+				if (mediaDatas.length > 0) {
+					hasMedia = true;
+					imageRelationshipAdditions.push({
+						key,
+						mediaDatas
+					});
 				}
 			}
-			for (const { key, hyperlink } of hyperlinkRelationshipAdditions) {
-				var _map$get2;
-				const relationshipKey = `word/_rels/${key.split("/").pop()}.rels`;
-				const relationshipsJson = (_map$get2 = map.get(relationshipKey)) !== null && _map$get2 !== void 0 ? _map$get2 : createRelationshipFile();
-				map.set(relationshipKey, relationshipsJson);
-				appendRelationship(relationshipsJson, hyperlink.id, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", hyperlink.link, TargetModeType.EXTERNAL);
+			map.set(key, json);
+		}
+		for (const { key, mediaDatas } of imageRelationshipAdditions) {
+			var _map$get;
+			const relationshipKey = `word/_rels/${key.split("/").pop()}.rels`;
+			const relationshipsJson = (_map$get = map.get(relationshipKey)) !== null && _map$get !== void 0 ? _map$get : createRelationshipFile();
+			map.set(relationshipKey, relationshipsJson);
+			const index = getNextRelationshipIndex(relationshipsJson);
+			const newJson = imageReplacer.replace(JSON.stringify(map.get(key)), mediaDatas, index);
+			map.set(key, JSON.parse(newJson));
+			for (let i = 0; i < mediaDatas.length; i++) {
+				const { fileName } = mediaDatas[i];
+				appendRelationship(relationshipsJson, index + i, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", `media/${fileName}`);
 			}
-			if (hasMedia) {
-				const contentTypesJson = map.get("[Content_Types].xml");
-				if (!contentTypesJson) throw new Error("Could not find content types file");
-				appendContentType(contentTypesJson, "image/png", "png");
-				appendContentType(contentTypesJson, "image/jpeg", "jpeg");
-				appendContentType(contentTypesJson, "image/jpeg", "jpg");
-				appendContentType(contentTypesJson, "image/bmp", "bmp");
-				appendContentType(contentTypesJson, "image/gif", "gif");
-				appendContentType(contentTypesJson, "image/svg+xml", "svg");
-			}
-			const files = {};
-			for (const [key, value] of map) files[key] = (0, undio.textToUint8Array)(toXml(value));
-			for (const [key, value] of binaryContentMap) files[key] = value;
-			for (const { data: mediaData, fileName } of file.Media.Array) files[`word/media/${fileName}`] = mediaData instanceof Uint8Array ? mediaData : new Uint8Array(mediaData);
-			return convertOutput((0, fflate.zipSync)(files, { level: 6 }), outputType);
-		});
-		return function patchDocument(_x) {
-			return _ref.apply(this, arguments);
-		};
-	}();
+		}
+		for (const { key, hyperlink } of hyperlinkRelationshipAdditions) {
+			var _map$get2;
+			const relationshipKey = `word/_rels/${key.split("/").pop()}.rels`;
+			const relationshipsJson = (_map$get2 = map.get(relationshipKey)) !== null && _map$get2 !== void 0 ? _map$get2 : createRelationshipFile();
+			map.set(relationshipKey, relationshipsJson);
+			appendRelationship(relationshipsJson, hyperlink.id, "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", hyperlink.link, TargetModeType.EXTERNAL);
+		}
+		if (hasMedia) {
+			const contentTypesJson = map.get("[Content_Types].xml");
+			if (!contentTypesJson) throw new Error("Could not find content types file");
+			appendContentType(contentTypesJson, "image/png", "png");
+			appendContentType(contentTypesJson, "image/jpeg", "jpeg");
+			appendContentType(contentTypesJson, "image/jpeg", "jpg");
+			appendContentType(contentTypesJson, "image/bmp", "bmp");
+			appendContentType(contentTypesJson, "image/gif", "gif");
+			appendContentType(contentTypesJson, "image/svg+xml", "svg");
+		}
+		const files = {};
+		for (const [key, value] of map) files[key] = (0, undio.textToUint8Array)(toXml(value));
+		for (const [key, value] of binaryContentMap) files[key] = value;
+		for (const { data: mediaData, fileName } of file.Media.Array) files[`word/media/${fileName}`] = mediaData instanceof Uint8Array ? mediaData : new Uint8Array(mediaData);
+		return convertOutput((0, fflate.zipSync)(files, { level: 6 }), outputType);
+	};
 	const toXml = (jsonObj) => {
 		return (0, xml_js.js2xml)(jsonObj, { attributeValueFn: (str) => String(str).replace(/&(?!amp;|lt;|gt;|quot;|apos;)/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;") });
 	};
@@ -19865,20 +23038,15 @@
 	* });
 	* ```
 	*/
-	const patchDetector = function() {
-		var _ref = _asyncToGenerator(function* ({ data }) {
-			const zipContent = (0, fflate.unzipSync)((0, undio.toUint8Array)(data));
-			const patches = /* @__PURE__ */ new Set();
-			for (const [key, value] of Object.entries(zipContent)) {
-				if (!key.endsWith(".xml") && !key.endsWith(".rels")) continue;
-				if (key.startsWith("word/") && !key.endsWith(".xml.rels")) traverse(toJson((0, fflate.strFromU8)(value))).forEach((p) => findPatchKeys(p.text).forEach((patch) => patches.add(patch)));
-			}
-			return [...patches];
-		});
-		return function patchDetector(_x) {
-			return _ref.apply(this, arguments);
-		};
-	}();
+	const patchDetector = async ({ data }) => {
+		const zipContent = (0, fflate.unzipSync)((0, undio.toUint8Array)(data));
+		const patches = /* @__PURE__ */ new Set();
+		for (const [key, value] of Object.entries(zipContent)) {
+			if (!key.endsWith(".xml") && !key.endsWith(".rels")) continue;
+			if (key.startsWith("word/") && !key.endsWith(".xml.rels")) traverse(toJson((0, fflate.strFromU8)(value))).forEach((p) => findPatchKeys(p.text).forEach((patch) => patches.add(patch)));
+		}
+		return [...patches];
+	};
 	/**
 	* Extracts placeholder keys from text using regex pattern.
 	*
@@ -19887,8 +23055,7 @@
 	*/
 	const findPatchKeys = (text) => {
 		var _text$match;
-		const pattern = /* @__PURE__ */ new RegExp("(?<=\\{\\{).+?(?=\\}\\})", "gs");
-		return (_text$match = text.match(pattern)) !== null && _text$match !== void 0 ? _text$match : [];
+		return (_text$match = text.match(/(?<=\{\{).+?(?=\}\})/gs)) !== null && _text$match !== void 0 ? _text$match : [];
 	};
 	//#endregion
 	exports.AbstractNumbering = AbstractNumbering;