docx-plus 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -23,14 +23,13 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 let xml_js = require("xml-js");
 let hash_js = require("hash.js");
-hash_js = __toESM(hash_js);
+hash_js = __toESM(hash_js, 1);
 let nanoid_non_secure = require("nanoid/non-secure");
-let stream = require("stream");
-let fflate = require("fflate");
 let undio = require("undio");
+let fflate = require("fflate");
 let xml = require("xml");
-xml = __toESM(xml);
-//#region \0@oxc-project+runtime@0.123.0/helpers/typeof.js
+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) {
@@ -40,7 +39,7 @@ function _typeof(o) {
 	}, _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];
@@ -52,13 +51,13 @@ function toPrimitive(t, r) {
 	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,
@@ -243,29 +242,6 @@ var IgnoreIfEmptyXmlComponent = class extends XmlComponent {
 	}
 };
 //#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.
@@ -359,7 +335,10 @@ var NextAttributeComponent = class extends BaseXmlComponent {
 	* @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
@@ -4733,13 +4712,16 @@ var ChildNonVisualProperties = class extends XmlComponent {
 * @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
@@ -4987,21 +4969,23 @@ var GraphicData = class extends XmlComponent {
 		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,
@@ -5630,14 +5614,15 @@ var AnchorAttributes = class extends XmlAttributeComponent {
 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,
@@ -5777,29 +5762,20 @@ var Drawing = class extends XmlComponent {
 };
 //#endregion
 //#region src/file/paragraph/run/image-run.ts
-const convertDataURIToBinary = (dataURI) => {
-	const base64Index = dataURI.indexOf(";base64,");
-	const base64IndexWithOffset = base64Index === -1 ? 0 : base64Index + 8;
-	const binaryString = atob(dataURI.substring(base64IndexWithOffset));
-	const bytes = new Uint8Array(binaryString.length);
-	for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
-	return bytes;
-};
-const standardizeData = (data) => typeof data === "string" ? convertDataURIToBinary(data) : data;
-const createImageData = (options, key) => ({
-	data: standardizeData(options.data),
+const createImageData = (data, transformation, key) => ({
+	data,
 	fileName: key,
 	transformation: {
 		emus: {
-			x: Math.round(options.transformation.width * 9525),
-			y: Math.round(options.transformation.height * 9525)
+			x: Math.round(transformation.width * 9525),
+			y: Math.round(transformation.height * 9525)
 		},
-		flip: options.transformation.flip,
+		flip: transformation.flip,
 		pixels: {
-			x: Math.round(options.transformation.width),
-			y: Math.round(options.transformation.height)
+			x: Math.round(transformation.width),
+			y: Math.round(transformation.height)
 		},
-		rotation: options.transformation.rotation ? options.transformation.rotation * 6e4 : void 0
+		rotation: transformation.rotation ? transformation.rotation * 6e4 : void 0
 	}
 });
 /**
@@ -5828,8 +5804,22 @@ var ImageRun = class extends Run {
 	constructor(options) {
 		super({});
 		_defineProperty(this, "imageData", void 0);
-		const key = `${hashedId(options.data)}.${options.type}`;
-		this.imageData = options.type === "svg" ? _objectSpread2(_objectSpread2({ type: options.type }, createImageData(options, key)), {}, { fallback: _objectSpread2({ type: options.fallback.type }, createImageData(_objectSpread2(_objectSpread2({}, options.fallback), {}, { transformation: options.transformation }), `${hashedId(options.fallback.data)}.${options.fallback.type}`)) }) : _objectSpread2({ type: options.type }, createImageData(options, key));
+		const rawData = (0, undio.toUint8Array)(options.data);
+		const key = `${hashedId(rawData)}.${options.type}`;
+		if (options.type === "svg") {
+			const fallbackData = (0, undio.toUint8Array)(options.fallback.data);
+			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 +5868,7 @@ var WpsShapeRun = class extends Run {
 		super({});
 		_defineProperty(this, "wpsShapeData", void 0);
 		this.wpsShapeData = {
-			data: _objectSpread2({}, options),
+			data: { ...options },
 			transformation: createTransformation(options.transformation),
 			type: options.type
 		};
@@ -7905,13 +7895,16 @@ const CharacterSet = {
 * 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 +8142,10 @@ var FontWrapper = class {
 		_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 +8563,10 @@ var ParagraphPropertiesChange = class extends XmlComponent {
 			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 +10781,10 @@ const VerticalAlignTable = {
 *
 * @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 +11301,10 @@ var TableCellPropertiesChange = class extends XmlComponent {
 			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 +11848,10 @@ var TablePropertiesChange = class extends XmlComponent {
 			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 +12096,10 @@ var TableRowPropertiesChange = class extends XmlComponent {
 			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 +12498,14 @@ const DocumentAttributeNamespaces = {
 */
 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 +16185,10 @@ var Settings = class extends XmlComponent {
 		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 +16457,11 @@ var StyleForCharacter = class extends Style {
 		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 +16497,12 @@ var StyleForCharacter = class extends Style {
 */
 var HeadingStyle = class extends StyleForParagraph {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			basedOn: "Normal",
 			next: "Normal",
-			quickFormat: true
-		}, options));
+			quickFormat: true,
+			...options
+		});
 	}
 };
 /**
@@ -16497,10 +16519,11 @@ var HeadingStyle = class extends StyleForParagraph {
 */
 var TitleStyle = class extends HeadingStyle {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			id: "Title",
-			name: "Title"
-		}, options));
+			name: "Title",
+			...options
+		});
 	}
 };
 /**
@@ -16517,10 +16540,11 @@ var TitleStyle = class extends HeadingStyle {
 */
 var Heading1Style = class extends HeadingStyle {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			id: "Heading1",
-			name: "Heading 1"
-		}, options));
+			name: "Heading 1",
+			...options
+		});
 	}
 };
 /**
@@ -16530,10 +16554,11 @@ var Heading1Style = class extends HeadingStyle {
 */
 var Heading2Style = class extends HeadingStyle {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			id: "Heading2",
-			name: "Heading 2"
-		}, options));
+			name: "Heading 2",
+			...options
+		});
 	}
 };
 /**
@@ -16543,10 +16568,11 @@ var Heading2Style = class extends HeadingStyle {
 */
 var Heading3Style = class extends HeadingStyle {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			id: "Heading3",
-			name: "Heading 3"
-		}, options));
+			name: "Heading 3",
+			...options
+		});
 	}
 };
 /**
@@ -16556,10 +16582,11 @@ var Heading3Style = class extends HeadingStyle {
 */
 var Heading4Style = class extends HeadingStyle {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			id: "Heading4",
-			name: "Heading 4"
-		}, options));
+			name: "Heading 4",
+			...options
+		});
 	}
 };
 /**
@@ -16569,10 +16596,11 @@ var Heading4Style = class extends HeadingStyle {
 */
 var Heading5Style = class extends HeadingStyle {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			id: "Heading5",
-			name: "Heading 5"
-		}, options));
+			name: "Heading 5",
+			...options
+		});
 	}
 };
 /**
@@ -16582,10 +16610,11 @@ var Heading5Style = class extends HeadingStyle {
 */
 var Heading6Style = class extends HeadingStyle {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			id: "Heading6",
-			name: "Heading 6"
-		}, options));
+			name: "Heading 6",
+			...options
+		});
 	}
 };
 /**
@@ -16595,10 +16624,11 @@ var Heading6Style = class extends HeadingStyle {
 */
 var StrongStyle = class extends HeadingStyle {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			id: "Strong",
-			name: "Strong"
-		}, options));
+			name: "Strong",
+			...options
+		});
 	}
 };
 /**
@@ -16608,12 +16638,13 @@ var StrongStyle = class extends HeadingStyle {
 */
 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 +16654,7 @@ var ListParagraph = class extends StyleForParagraph {
 */
 var FootnoteText = class extends StyleForParagraph {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			basedOn: "Normal",
 			id: "FootnoteText",
 			link: "FootnoteTextChar",
@@ -16636,8 +16667,9 @@ var FootnoteText = class extends StyleForParagraph {
 			run: { size: 20 },
 			semiHidden: true,
 			uiPriority: 99,
-			unhideWhenUsed: true
-		}, options));
+			unhideWhenUsed: true,
+			...options
+		});
 	}
 };
 /**
@@ -16647,13 +16679,14 @@ var FootnoteText = class extends StyleForParagraph {
 */
 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 +16696,15 @@ var FootnoteReferenceStyle = class extends StyleForCharacter {
 */
 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 +16714,7 @@ var FootnoteTextChar = class extends StyleForCharacter {
 */
 var EndnoteText = class extends StyleForParagraph {
 	constructor(options) {
-		super(_objectSpread2({
+		super({
 			basedOn: "Normal",
 			id: "EndnoteText",
 			link: "EndnoteTextChar",
@@ -16693,8 +16727,9 @@ var EndnoteText = class extends StyleForParagraph {
 			run: { size: 20 },
 			semiHidden: true,
 			uiPriority: 99,
-			unhideWhenUsed: true
-		}, options));
+			unhideWhenUsed: true,
+			...options
+		});
 	}
 };
 /**
@@ -16704,13 +16739,14 @@ var EndnoteText = class extends StyleForParagraph {
 */
 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 +16756,15 @@ var EndnoteReferenceStyle = class extends StyleForCharacter {
 */
 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 +16774,16 @@ var EndnoteTextChar = class extends StyleForCharacter {
 */
 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 +17053,50 @@ var DefaultStylesFactory = class {
 		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 +17214,12 @@ var File = class {
 		_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 +17248,14 @@ var File = class {
 			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 +17264,8 @@ var File = class {
 		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 +17276,7 @@ var File = class {
 				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 +17533,6 @@ var StructuredDocumentTagProperties = class extends XmlComponent {
 	}
 };
 //#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 +17544,6 @@ function _objectWithoutProperties(e, t) {
 *
 * @module
 */
-const _excluded$1 = [
-	"contentChildren",
-	"cachedEntries",
-	"beginDirty"
-];
 /**
 * Represents a Table of Contents in a WordprocessingML document.
 *
@@ -17531,8 +17574,7 @@ const _excluded$1 = [
 * ```
 */
 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 +18270,6 @@ const createShape = ({ id, children, type = SHAPE_TYPE, style }) => new BuilderE
 *
 * @module
 */
-const _excluded = ["style", "children"];
 /**
 * Represents a textbox in a WordprocessingML document.
 *
@@ -18278,8 +18319,7 @@ const _excluded = ["style", "children"];
 * ```
 */
 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,116 +18330,3260 @@ var Textbox = class extends FileChild {
 	}
 };
 //#endregion
-//#region src/util/output-type.ts
-/**
-* 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 Buffer.from(data).toString("base64");
-		case "string":
-		case "text": return Buffer.from(data).toString("binary");
-		case "binarystring": return Buffer.from(data).toString("binary");
-		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 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.
+* 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.
 *
-* @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);
 	}
-};
-//#endregion
-//#region src/export/packer/image-replacer.ts
+	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);
+}
 /**
-* Replaces image placeholders with relationship IDs in XML content.
-*
-* During document compilation, images are referenced using placeholder tokens
+* 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
+/**
+* Replaces image placeholders with relationship IDs in XML content.
+*
+* During document compilation, images are referenced using placeholder tokens
 * like {image1.png}. This class replaces those placeholders with the actual
 * relationship IDs used in the OOXML structure.
 *
@@ -18881,32 +22065,6 @@ var Compiler = class {
 	}
 };
 //#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.
@@ -18959,11 +22117,8 @@ var Packer = class Packer {
 	* @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.
@@ -19039,16 +22194,20 @@ var Packer = class Packer {
 	* ```
 	*/
 	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;
@@ -19060,9 +22219,9 @@ var Packer = class Packer {
 			}
 			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());
@@ -19131,7 +22290,10 @@ const createTextElementContents = (text) => {
 * // 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.
 *
@@ -19323,14 +22485,24 @@ const splitRunElement = (runElement, token) => {
 		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
@@ -19590,9 +22762,15 @@ const replacer = ({ json, patch, patchText, context, keepOriginalStyles = true }
 					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;
@@ -19678,69 +22856,70 @@ const compareByteArrays = (a, b) => {
 *
 * @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({
@@ -19752,63 +22931,60 @@ const patchDocument = function() {
 									});
 									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;") });
 };
@@ -19857,20 +23033,15 @@ const createRelationshipFile = () => ({
 * });
 * ```
 */
-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.
 *
@@ -19879,8 +23050,7 @@ const patchDetector = function() {
 */
 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;
@@ -20179,7 +23349,6 @@ exports.sectionPageSizeDefaults = sectionPageSizeDefaults;
 exports.shortHexNumber = shortHexNumber;
 exports.signedHpsMeasureValue = signedHpsMeasureValue;
 exports.signedTwipsMeasureValue = signedTwipsMeasureValue;
-exports.standardizeData = standardizeData;
 exports.twipsMeasureValue = twipsMeasureValue;
 exports.uCharHexNumber = uCharHexNumber;
 exports.uniqueId = uniqueId;