@s8fy/emf2svg 1.0.0

package/dist/index.cjs

@@ -0,0 +1,3756 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/binary-reader.ts
+/**
+* Little-endian binary reader built on DataView.
+* EMF files are always little-endian.
+*/
+var BinaryReader = class BinaryReader {
+	constructor(buffer) {
+		if (buffer instanceof Uint8Array) this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+		else this.view = new DataView(buffer);
+		this.pos = 0;
+	}
+	get position() {
+		return this.pos;
+	}
+	get remaining() {
+		return this.view.byteLength - this.pos;
+	}
+	get length() {
+		return this.view.byteLength;
+	}
+	seek(offset) {
+		if (offset < 0 || offset > this.view.byteLength) throw new RangeError(`Seek offset ${offset} out of bounds [0, ${this.view.byteLength}]`);
+		this.pos = offset;
+	}
+	skip(bytes) {
+		this.seek(this.pos + bytes);
+	}
+	readUint8() {
+		const val = this.view.getUint8(this.pos);
+		this.pos += 1;
+		return val;
+	}
+	readInt16() {
+		const val = this.view.getInt16(this.pos, true);
+		this.pos += 2;
+		return val;
+	}
+	readUint16() {
+		const val = this.view.getUint16(this.pos, true);
+		this.pos += 2;
+		return val;
+	}
+	readInt32() {
+		const val = this.view.getInt32(this.pos, true);
+		this.pos += 4;
+		return val;
+	}
+	readUint32() {
+		const val = this.view.getUint32(this.pos, true);
+		this.pos += 4;
+		return val;
+	}
+	readFloat32() {
+		const val = this.view.getFloat32(this.pos, true);
+		this.pos += 4;
+		return val;
+	}
+	/**
+	* Read a UTF-16LE string of given character count.
+	*/
+	readUtf16String(charCount) {
+		const codes = [];
+		for (let i = 0; i < charCount; i++) {
+			const code = this.view.getUint16(this.pos, true);
+			this.pos += 2;
+			if (code === 0) {
+				this.pos += (charCount - i - 1) * 2;
+				break;
+			}
+			codes.push(code);
+		}
+		return String.fromCharCode(...codes);
+	}
+	/**
+	* Read raw bytes as a new Uint8Array (copies data).
+	*/
+	readBytes(count) {
+		if (this.pos + count > this.view.byteLength) throw new RangeError(`Cannot read ${count} bytes at position ${this.pos}, only ${this.remaining} remaining`);
+		const result = new Uint8Array(count);
+		const src = new Uint8Array(this.view.buffer, this.view.byteOffset + this.pos, count);
+		result.set(src);
+		this.pos += count;
+		return result;
+	}
+	/**
+	* Read a slice view without copying (for large bitmap data).
+	*/
+	readSlice(count) {
+		if (this.pos + count > this.view.byteLength) throw new RangeError(`Cannot slice ${count} bytes at position ${this.pos}, only ${this.remaining} remaining`);
+		const slice = new Uint8Array(this.view.buffer, this.view.byteOffset + this.pos, count);
+		this.pos += count;
+		return slice;
+	}
+	/**
+	* Create a sub-reader for a specific range (for record parsing).
+	*/
+	subReader(offset, length) {
+		const slice = new Uint8Array(this.view.buffer, this.view.byteOffset + offset, length);
+		return new BinaryReader(slice);
+	}
+};
+//#endregion
+//#region src/constants.ts
+const EMF_SIGNATURE = 1179469088;
+let PenStyle;
+(function(_PenStyle) {
+	_PenStyle.PS_SOLID = 0;
+	_PenStyle.PS_DASH = 1;
+	_PenStyle.PS_DOT = 2;
+	_PenStyle.PS_DASHDOT = 3;
+	_PenStyle.PS_DASHDOTDOT = 4;
+	_PenStyle.PS_NULL = 5;
+	_PenStyle.PS_INSIDEFRAME = 6;
+	_PenStyle.PS_USERSTYLE = 7;
+	_PenStyle.PS_ALTERNATE = 8;
+	_PenStyle.PS_STYLE_MASK = 15;
+	_PenStyle.PS_ENDCAP_ROUND = 0;
+	_PenStyle.PS_ENDCAP_SQUARE = 256;
+	_PenStyle.PS_ENDCAP_FLAT = 512;
+	_PenStyle.PS_ENDCAP_MASK = 3840;
+	_PenStyle.PS_JOIN_ROUND = 0;
+	_PenStyle.PS_JOIN_BEVEL = 4096;
+	_PenStyle.PS_JOIN_MITER = 8192;
+	_PenStyle.PS_JOIN_MASK = 61440;
+	_PenStyle.PS_COSMETIC = 0;
+	_PenStyle.PS_GEOMETRIC = 65536;
+	_PenStyle.PS_TYPE_MASK = 983040;
+})(PenStyle || (PenStyle = {}));
+let TextAlign;
+(function(_TextAlign) {
+	_TextAlign.TA_NOUPDATECP = 0;
+	_TextAlign.TA_UPDATECP = 1;
+	_TextAlign.TA_LEFT = 0;
+	_TextAlign.TA_RIGHT = 2;
+	_TextAlign.TA_CENTER = 6;
+	_TextAlign.TA_TOP = 0;
+	_TextAlign.TA_BOTTOM = 8;
+	_TextAlign.TA_BASELINE = 24;
+	_TextAlign.TA_RTLREADING = 256;
+})(TextAlign || (TextAlign = {}));
+const SYMBOL_CHAR_MAP = {
+	34: "∀",
+	36: "∃",
+	39: "∋",
+	40: "(",
+	41: ")",
+	42: "∗",
+	43: "+",
+	45: "−",
+	61: "=",
+	64: "≅",
+	65: "Α",
+	66: "Β",
+	67: "Χ",
+	68: "Δ",
+	69: "Ε",
+	70: "Φ",
+	71: "Γ",
+	72: "Η",
+	73: "Ι",
+	74: "ϑ",
+	75: "Κ",
+	76: "Λ",
+	77: "Μ",
+	78: "Ν",
+	79: "Ο",
+	80: "Π",
+	81: "Θ",
+	82: "Ρ",
+	83: "Σ",
+	84: "Τ",
+	85: "Υ",
+	86: "ς",
+	87: "Ω",
+	88: "Ξ",
+	89: "Ψ",
+	90: "Ζ",
+	92: "∴",
+	94: "⊥",
+	96: "‾",
+	97: "α",
+	98: "β",
+	99: "χ",
+	100: "δ",
+	101: "ε",
+	102: "φ",
+	103: "γ",
+	104: "η",
+	105: "ι",
+	106: "ϕ",
+	107: "κ",
+	108: "λ",
+	109: "μ",
+	110: "ν",
+	111: "ο",
+	112: "π",
+	113: "θ",
+	114: "ρ",
+	115: "σ",
+	116: "τ",
+	117: "υ",
+	118: "ϖ",
+	119: "ω",
+	120: "ξ",
+	121: "ψ",
+	122: "ζ",
+	126: "∼",
+	160: "€",
+	161: "ϒ",
+	162: "′",
+	163: "≤",
+	164: "⁄",
+	165: "∞",
+	166: "ƒ",
+	167: "♣",
+	168: "♦",
+	169: "♥",
+	170: "♠",
+	171: "↔",
+	172: "←",
+	173: "↑",
+	174: "→",
+	175: "↓",
+	176: "°",
+	177: "±",
+	178: "″",
+	179: "≥",
+	180: "×",
+	181: "∝",
+	182: "∂",
+	183: "•",
+	184: "÷",
+	185: "≠",
+	186: "≡",
+	187: "≈",
+	188: "…",
+	189: "⏐",
+	190: "⎯",
+	191: "↵",
+	192: "ℵ",
+	193: "ℑ",
+	194: "ℜ",
+	195: "℘",
+	196: "⊗",
+	197: "⊕",
+	198: "∅",
+	199: "∩",
+	200: "∪",
+	201: "⊃",
+	202: "⊇",
+	203: "⊄",
+	204: "⊂",
+	205: "⊆",
+	206: "∈",
+	207: "∉",
+	208: "∠",
+	209: "∇",
+	210: "®",
+	211: "©",
+	212: "™",
+	213: "∏",
+	214: "√",
+	215: "⋅",
+	216: "¬",
+	217: "∧",
+	218: "∨",
+	219: "⇔",
+	220: "⇐",
+	221: "⇑",
+	222: "⇒",
+	223: "⇓",
+	224: "◊",
+	225: "〈",
+	226: "®",
+	227: "©",
+	228: "™",
+	229: "∑",
+	230: "⎛",
+	231: "⎜",
+	232: "⎝",
+	233: "⎡",
+	234: "⎢",
+	235: "⎣",
+	236: "⎧",
+	237: "⎨",
+	238: "⎩",
+	239: "⎪",
+	241: "〉",
+	242: "∫",
+	243: "⌠",
+	244: "⎮",
+	245: "⌡",
+	246: "⎞",
+	247: "⎟",
+	248: "⎠",
+	249: "⎤",
+	250: "⎥",
+	251: "⎦",
+	252: "⎫",
+	253: "⎬",
+	254: "⎭"
+};
+const MT_EXTRA_CHAR_MAP = { 76: "⋯" };
+//#endregion
+//#region src/transform.ts
+/**
+* Affine transformation matrix operations.
+* Matrix format: [a, b, c, d, tx, ty]
+*
+* Transformation: [x', y'] = [a*x + c*y + tx, b*x + d*y + ty]
+*
+* All operations return new matrices (immutable style).
+*/
+/** Identity matrix */
+function identity() {
+	return [
+		1,
+		0,
+		0,
+		1,
+		0,
+		0
+	];
+}
+/**
+* Multiply two matrices: result = A * B
+* This means: first apply B, then apply A.
+*/
+function multiply(a, b) {
+	return [
+		a[0] * b[0] + a[2] * b[1],
+		a[1] * b[0] + a[3] * b[1],
+		a[0] * b[2] + a[2] * b[3],
+		a[1] * b[2] + a[3] * b[3],
+		a[0] * b[4] + a[2] * b[5] + a[4],
+		a[1] * b[4] + a[3] * b[5] + a[5]
+	];
+}
+/** Transform a point by a matrix */
+function transformPoint(m, p) {
+	return {
+		x: m[0] * p.x + m[2] * p.y + m[4],
+		y: m[1] * p.x + m[3] * p.y + m[5]
+	};
+}
+/** Convert matrix to SVG transform string: "matrix(a,b,c,d,tx,ty)" */
+function toSvgString(m) {
+	return `matrix(${m[0]},${m[1]},${m[2]},${m[3]},${m[4]},${m[5]})`;
+}
+/** Check if a matrix is the identity matrix */
+function isIdentity(m) {
+	return Math.abs(m[0] - 1) < 1e-10 && Math.abs(m[1]) < 1e-10 && Math.abs(m[2]) < 1e-10 && Math.abs(m[3] - 1) < 1e-10 && Math.abs(m[4]) < 1e-10 && Math.abs(m[5]) < 1e-10;
+}
+//#endregion
+//#region src/device-context.ts
+const DEFAULT_COLOR = {
+	r: 0,
+	g: 0,
+	b: 0,
+	a: 255
+};
+const WHITE_COLOR = {
+	r: 255,
+	g: 255,
+	b: 255,
+	a: 255
+};
+function defaultBrush() {
+	return {
+		type: "brush",
+		style: 0,
+		color: WHITE_COLOR,
+		hatch: 0
+	};
+}
+function defaultPen() {
+	return {
+		type: "pen",
+		style: PenStyle.PS_SOLID,
+		width: 1,
+		color: DEFAULT_COLOR,
+		endCap: 0,
+		lineJoin: 0
+	};
+}
+function defaultFont() {
+	return {
+		type: "font",
+		height: 12,
+		width: 0,
+		weight: 400,
+		italic: false,
+		underline: false,
+		strikeOut: false,
+		charSet: 0,
+		faceName: "Arial",
+		escapement: 0,
+		orientation: 0
+	};
+}
+function cloneState(s) {
+	return {
+		worldTransform: [...s.worldTransform],
+		windowOrgX: s.windowOrgX,
+		windowOrgY: s.windowOrgY,
+		windowExtX: s.windowExtX,
+		windowExtY: s.windowExtY,
+		viewportOrgX: s.viewportOrgX,
+		viewportOrgY: s.viewportOrgY,
+		viewportExtX: s.viewportExtX,
+		viewportExtY: s.viewportExtY,
+		hasExplicitWindowExt: s.hasExplicitWindowExt,
+		hasExplicitViewportExt: s.hasExplicitViewportExt,
+		currentPosX: s.currentPosX,
+		currentPosY: s.currentPosY,
+		textColor: { ...s.textColor },
+		bkColor: { ...s.bkColor },
+		bkMode: s.bkMode,
+		textAlign: s.textAlign,
+		polyFillMode: s.polyFillMode,
+		miterLimit: s.miterLimit,
+		mapMode: s.mapMode,
+		brush: {
+			...s.brush,
+			color: { ...s.brush.color }
+		},
+		pen: {
+			...s.pen,
+			color: { ...s.pen.color }
+		},
+		font: { ...s.font },
+		arcDirection: s.arcDirection,
+		clipPathIds: [...s.clipPathIds]
+	};
+}
+var DeviceContext = class {
+	constructor() {
+		this.stack = [];
+		this.state = {
+			worldTransform: identity(),
+			windowOrgX: 0,
+			windowOrgY: 0,
+			windowExtX: 1,
+			windowExtY: 1,
+			viewportOrgX: 0,
+			viewportOrgY: 0,
+			viewportExtX: 1,
+			viewportExtY: 1,
+			hasExplicitWindowExt: false,
+			hasExplicitViewportExt: false,
+			currentPosX: 0,
+			currentPosY: 0,
+			textColor: { ...DEFAULT_COLOR },
+			bkColor: { ...WHITE_COLOR },
+			bkMode: 2,
+			textAlign: TextAlign.TA_LEFT | TextAlign.TA_TOP,
+			polyFillMode: 1,
+			miterLimit: 10,
+			mapMode: 1,
+			brush: defaultBrush(),
+			pen: defaultPen(),
+			font: defaultFont(),
+			arcDirection: 1,
+			clipPathIds: []
+		};
+	}
+	save() {
+		this.stack.push(cloneState(this.state));
+	}
+	/**
+	* RestoreDC: if savedDC is negative, pop |savedDC| states.
+	* If positive, pop until stack size equals savedDC.
+	*/
+	restore(savedDC) {
+		if (savedDC < 0) {
+			const count = -savedDC;
+			for (let i = 0; i < count && this.stack.length > 0; i++) this.state = this.stack.pop();
+		} else while (this.stack.length >= savedDC && this.stack.length > 0) this.state = this.stack.pop();
+	}
+	/** Get fill style for SVG from current brush */
+	getFillStyle() {
+		return {
+			enabled: true,
+			color: { ...this.state.brush.color },
+			brushStyle: this.state.brush.style
+		};
+	}
+	/** Get stroke style for SVG from current pen */
+	getStrokeStyle() {
+		return {
+			enabled: true,
+			color: { ...this.state.pen.color },
+			width: this.state.pen.width,
+			penStyle: this.state.pen.style
+		};
+	}
+	/**
+	* Compute the combined Window → Viewport → World coordinate transform.
+	* Logical coord → (window/viewport mapping) → device coord → (world transform) → final.
+	*
+	* For SVG output, we use the viewBox for window/viewport mapping and
+	* emit the world transform as a <g transform="...">.
+	*/
+	getWindowToViewportScaleX() {
+		return this.state.windowExtX !== 0 ? this.state.viewportExtX / this.state.windowExtX : 1;
+	}
+	getWindowToViewportScaleY() {
+		return this.state.windowExtY !== 0 ? this.state.viewportExtY / this.state.windowExtY : 1;
+	}
+};
+//#endregion
+//#region src/dib-decoder.ts
+/**
+* DIB (Device Independent Bitmap) decoder.
+* Repacks EMF-embedded DIB data into a complete BMP file,
+* then encodes as base64 data URI. Browsers natively render BMP.
+*/
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/**
+* Decode a DIB embedded in an EMF record into a data URI.
+* DIB = BITMAPINFOHEADER + optional color table + pixel data.
+* We prepend a BITMAPFILEHEADER to make it a valid BMP file.
+*
+* @param dibData - Raw DIB bytes (starting with BITMAPINFOHEADER)
+* @param dibHeaderSize - Size of DIB data from the header offset
+* @param bitmapData - Raw bitmap bits
+* @returns data:image/bmp;base64,... URI string
+*/
+function dibToDataUri(dibData, bitmapData) {
+	const headerSize = readUint32(dibData, 0);
+	let height = readInt32(dibData, 8);
+	const bitCount = readUint16(dibData, 14);
+	if (height < 0) height = -height;
+	let colorTableSize = 0;
+	if (bitCount <= 8) {
+		let clrUsed = readUint32(dibData, 32);
+		if (clrUsed === 0) clrUsed = 1 << bitCount;
+		colorTableSize = clrUsed * 4;
+	}
+	const dibHeaderTotal = headerSize + colorTableSize;
+	const fileHeaderSize = 14;
+	const bfOffBits = fileHeaderSize + dibHeaderTotal;
+	const totalSize = bfOffBits + bitmapData.length;
+	const bmp = new Uint8Array(totalSize);
+	bmp[0] = 66;
+	bmp[1] = 77;
+	writeUint32(bmp, 2, totalSize);
+	writeUint32(bmp, 10, bfOffBits);
+	bmp.set(dibData.subarray(0, dibHeaderTotal), fileHeaderSize);
+	bmp.set(bitmapData, bfOffBits);
+	return "data:image/bmp;base64," + uint8ToBase64(bmp);
+}
+/**
+* Try to detect if DIB data is actually a PNG or JPEG
+* (some EMF files embed compressed images directly).
+*/
+function detectEmbeddedFormat(data) {
+	if (data.length < 4) return null;
+	if (data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "png";
+	if (data[0] === 255 && data[1] === 216 && data[2] === 255) return "jpeg";
+	if (data[0] === 66 && data[1] === 77) return "bmp";
+	return null;
+}
+/**
+* Create a data URI from raw image bytes with detected format.
+*/
+function rawImageToDataUri(data) {
+	const format = detectEmbeddedFormat(data);
+	if (format === "png") return "data:image/png;base64," + uint8ToBase64(data);
+	if (format === "jpeg") return "data:image/jpeg;base64," + uint8ToBase64(data);
+	if (format === "bmp") return "data:image/bmp;base64," + uint8ToBase64(data);
+	return "data:image/bmp;base64," + uint8ToBase64(data);
+}
+function readUint16(buf, offset) {
+	return buf[offset] | buf[offset + 1] << 8;
+}
+function readInt32(buf, offset) {
+	return buf[offset] | buf[offset + 1] << 8 | buf[offset + 2] << 16 | buf[offset + 3] << 24;
+}
+function readUint32(buf, offset) {
+	return readInt32(buf, offset) >>> 0;
+}
+function writeUint32(buf, offset, value) {
+	buf[offset] = value & 255;
+	buf[offset + 1] = value >> 8 & 255;
+	buf[offset + 2] = value >> 16 & 255;
+	buf[offset + 3] = value >> 24 & 255;
+}
+/** Pure JS base64 encoder (no btoa dependency for non-browser envs) */
+function uint8ToBase64(bytes) {
+	const len = bytes.length;
+	let result = "";
+	let i = 0;
+	for (; i + 2 < len; i += 3) {
+		const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+		result += BASE64_CHARS[n >> 18 & 63];
+		result += BASE64_CHARS[n >> 12 & 63];
+		result += BASE64_CHARS[n >> 6 & 63];
+		result += BASE64_CHARS[n & 63];
+	}
+	if (i + 1 === len) {
+		const n = bytes[i] << 16;
+		result += BASE64_CHARS[n >> 18 & 63];
+		result += BASE64_CHARS[n >> 12 & 63];
+		result += "==";
+	} else if (i + 2 === len) {
+		const n = bytes[i] << 16 | bytes[i + 1] << 8;
+		result += BASE64_CHARS[n >> 18 & 63];
+		result += BASE64_CHARS[n >> 12 & 63];
+		result += BASE64_CHARS[n >> 6 & 63];
+		result += "=";
+	}
+	return result;
+}
+//#endregion
+//#region src/object-table.ts
+/**
+* GDI Object Table.
+* Manages create/select/delete of GDI objects (pens, brushes, fonts).
+* Handles stock objects (predefined system objects).
+*/
+var ObjectTable = class {
+	constructor() {
+		this.objects = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Create a GDI object at the given handle index.
+	*/
+	create(index, obj) {
+		this.objects.set(index, obj);
+	}
+	/**
+	* Delete a GDI object by handle index.
+	*/
+	delete(index) {
+		this.objects.delete(index);
+	}
+	/**
+	* Select an object (by handle or stock object ID) into the device context.
+	* Returns true if the object was found and applied.
+	*/
+	select(index, dc) {
+		if (index & 2147483648) return this.selectStockObject(index, dc);
+		const obj = this.objects.get(index);
+		if (!obj) return false;
+		this.applyObject(obj, dc);
+		return true;
+	}
+	applyObject(obj, dc) {
+		switch (obj.type) {
+			case "brush":
+				dc.state.brush = {
+					...obj,
+					color: { ...obj.color }
+				};
+				break;
+			case "pen":
+				dc.state.pen = {
+					...obj,
+					color: { ...obj.color }
+				};
+				break;
+			case "font": dc.state.font = { ...obj };
+		}
+	}
+	selectStockObject(index, dc) {
+		const WHITE = {
+			r: 255,
+			g: 255,
+			b: 255,
+			a: 255
+		};
+		const BLACK = {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 255
+		};
+		const LTGRAY = {
+			r: 192,
+			g: 192,
+			b: 192,
+			a: 255
+		};
+		const GRAY = {
+			r: 128,
+			g: 128,
+			b: 128,
+			a: 255
+		};
+		const DKGRAY = {
+			r: 64,
+			g: 64,
+			b: 64,
+			a: 255
+		};
+		switch (index) {
+			case 2147483648:
+				dc.state.brush = {
+					type: "brush",
+					style: 0,
+					color: WHITE,
+					hatch: 0
+				};
+				return true;
+			case 2147483649:
+				dc.state.brush = {
+					type: "brush",
+					style: 0,
+					color: LTGRAY,
+					hatch: 0
+				};
+				return true;
+			case 2147483650:
+				dc.state.brush = {
+					type: "brush",
+					style: 0,
+					color: GRAY,
+					hatch: 0
+				};
+				return true;
+			case 2147483651:
+				dc.state.brush = {
+					type: "brush",
+					style: 0,
+					color: DKGRAY,
+					hatch: 0
+				};
+				return true;
+			case 2147483652:
+				dc.state.brush = {
+					type: "brush",
+					style: 0,
+					color: BLACK,
+					hatch: 0
+				};
+				return true;
+			case 2147483653:
+				dc.state.brush = {
+					type: "brush",
+					style: 1,
+					color: WHITE,
+					hatch: 0
+				};
+				return true;
+			case 2147483654:
+				dc.state.pen = {
+					type: "pen",
+					style: PenStyle.PS_SOLID,
+					width: 1,
+					color: WHITE,
+					endCap: 0,
+					lineJoin: 0
+				};
+				return true;
+			case 2147483655:
+				dc.state.pen = {
+					type: "pen",
+					style: PenStyle.PS_SOLID,
+					width: 1,
+					color: BLACK,
+					endCap: 0,
+					lineJoin: 0
+				};
+				return true;
+			case 2147483656:
+				dc.state.pen = {
+					type: "pen",
+					style: PenStyle.PS_NULL,
+					width: 0,
+					color: BLACK,
+					endCap: 0,
+					lineJoin: 0
+				};
+				return true;
+			case 2147483658:
+			case 2147483659:
+			case 2147483664:
+				dc.state.font = {
+					type: "font",
+					height: 12,
+					width: 0,
+					weight: 400,
+					italic: false,
+					underline: false,
+					strikeOut: false,
+					charSet: 0,
+					faceName: "Courier New",
+					escapement: 0,
+					orientation: 0
+				};
+				return true;
+			case 2147483660:
+			case 2147483665:
+				dc.state.font = {
+					type: "font",
+					height: 12,
+					width: 0,
+					weight: 400,
+					italic: false,
+					underline: false,
+					strikeOut: false,
+					charSet: 0,
+					faceName: "Arial",
+					escapement: 0,
+					orientation: 0
+				};
+				return true;
+			case 2147483661:
+			case 2147483662:
+				dc.state.font = {
+					type: "font",
+					height: 16,
+					width: 0,
+					weight: 700,
+					italic: false,
+					underline: false,
+					strikeOut: false,
+					charSet: 0,
+					faceName: "System",
+					escapement: 0,
+					orientation: 0
+				};
+				return true;
+			case 2147483666: return true;
+			case 2147483667: return true;
+			default: return false;
+		}
+	}
+};
+//#endregion
+//#region src/path-builder.ts
+/**
+* SVG path data builder.
+* Accumulates move/line/curve/close commands and outputs SVG `d` attribute string.
+*/
+var PathBuilder = class {
+	constructor() {
+		this.commands = [];
+		this._currentX = 0;
+		this._currentY = 0;
+		this._startX = 0;
+		this._startY = 0;
+		this._hasContent = false;
+		this.minX = Infinity;
+		this.maxX = -Infinity;
+		this.minY = Infinity;
+		this.maxY = -Infinity;
+	}
+	get currentX() {
+		return this._currentX;
+	}
+	get currentY() {
+		return this._currentY;
+	}
+	get hasContent() {
+		return this._hasContent;
+	}
+	trackXY(x, y) {
+		if (x < this.minX) this.minX = x;
+		if (x > this.maxX) this.maxX = x;
+		if (y < this.minY) this.minY = y;
+		if (y > this.maxY) this.maxY = y;
+	}
+	moveTo(x, y) {
+		this.commands.push(`M${fmt$2(x)},${fmt$2(y)}`);
+		this._currentX = x;
+		this._currentY = y;
+		this._startX = x;
+		this._startY = y;
+		this._hasContent = true;
+		this.trackXY(x, y);
+	}
+	lineTo(x, y) {
+		this.commands.push(`L${fmt$2(x)},${fmt$2(y)}`);
+		this._currentX = x;
+		this._currentY = y;
+		this._hasContent = true;
+		this.trackXY(x, y);
+	}
+	/**
+	* Cubic bezier curve to (x, y) with control points (cx1, cy1) and (cx2, cy2).
+	*/
+	curveTo(cx1, cy1, cx2, cy2, x, y) {
+		this.commands.push(`C${fmt$2(cx1)},${fmt$2(cy1)},${fmt$2(cx2)},${fmt$2(cy2)},${fmt$2(x)},${fmt$2(y)}`);
+		this._currentX = x;
+		this._currentY = y;
+		this._hasContent = true;
+		this.trackXY(cx1, cy1);
+		this.trackXY(cx2, cy2);
+		this.trackXY(x, y);
+	}
+	/**
+	* SVG elliptical arc command.
+	*/
+	arcTo(rx, ry, xAxisRotation, largeArcFlag, sweepFlag, x, y) {
+		this.commands.push(`A${fmt$2(rx)},${fmt$2(ry)},${xAxisRotation},${largeArcFlag},${sweepFlag},${fmt$2(x)},${fmt$2(y)}`);
+		this._currentX = x;
+		this._currentY = y;
+		this._hasContent = true;
+		this.trackXY(x, y);
+	}
+	closePath() {
+		this.commands.push("Z");
+		this._currentX = this._startX;
+		this._currentY = this._startY;
+	}
+	/** Get the SVG path d attribute string */
+	toPathData() {
+		return this.commands.join("");
+	}
+	/** Reset the builder */
+	clear() {
+		this.commands.length = 0;
+		this._currentX = 0;
+		this._currentY = 0;
+		this._startX = 0;
+		this._startY = 0;
+		this._hasContent = false;
+		this.minX = Infinity;
+		this.maxX = -Infinity;
+		this.minY = Infinity;
+		this.maxY = -Infinity;
+	}
+};
+/** Format a number for SVG: up to 2 decimal places, no trailing zeros */
+function fmt$2(n) {
+	return Number(n.toFixed(2)).toString();
+}
+//#endregion
+//#region src/svg-writer.ts
+/**
+* SVG XML string generator. Zero DOM dependency.
+* Builds SVG by concatenating string fragments.
+*/
+var SvgWriter = class {
+	constructor() {
+		this.parts = [];
+		this.clipCount = 0;
+		this.gradientCount = 0;
+		this.defs = [];
+		this.defsOpen = false;
+		this.groupScaleStack = [1];
+	}
+	/**
+	* Begin SVG document with viewBox.
+	*/
+	beginDocument(x, y, width, height) {
+		this.parts.push(`<svg xmlns="http://www.w3.org/2000/svg" viewBox="${fmt$1(x)} ${fmt$1(y)} ${fmt$1(width)} ${fmt$1(height)}">`);
+	}
+	/**
+	* Update the SVG viewBox after the document has been started.
+	* Used when EMF records change the logical coordinate space via SetWindowExtEx.
+	*/
+	updateViewBox(x, y, width, height) {
+		if (this.parts.length > 0) this.parts[0] = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${fmt$1(x)} ${fmt$1(y)} ${fmt$1(width)} ${fmt$1(height)}">`;
+	}
+	setRootDataAttribute(name, value) {
+		if (this.parts.length > 0 && /^data-[a-z0-9-]+$/.test(name)) this.parts[0] = this.parts[0].replace(">", ` ${name}="${escapeXml$1(value)}">`);
+	}
+	preserveAspectRatioNone() {
+		if (this.parts.length > 0) this.parts[0] = this.parts[0].replace(">", " preserveAspectRatio=\"none\">");
+	}
+	/**
+	* End SVG document.
+	*/
+	endDocument() {
+		let result = "";
+		if (this.parts.length > 0) {
+			result = this.parts[0];
+			if (this.defs.length > 0) result += "<defs>" + this.defs.join("") + "</defs>";
+			result += this.parts.slice(1).join("");
+		}
+		result += "</svg>";
+		return result;
+	}
+	/**
+	* Draw an ellipse.
+	*/
+	ellipse(cx, cy, rx, ry, fill, stroke) {
+		const fillAttr = buildFillAttr(fill);
+		const strokeAttr = buildStrokeAttr(stroke);
+		this.parts.push(`<ellipse cx="${fmt$1(cx)}" cy="${fmt$1(cy)}" rx="${fmt$1(rx)}" ry="${fmt$1(ry)}"${fillAttr}${strokeAttr}/>`);
+	}
+	/**
+	* Draw a rectangle.
+	*/
+	rect(x, y, width, height, fill, stroke) {
+		const fillAttr = buildFillAttr(fill);
+		const strokeAttr = buildStrokeAttr(stroke);
+		this.parts.push(`<rect x="${fmt$1(x)}" y="${fmt$1(y)}" width="${fmt$1(width)}" height="${fmt$1(height)}"${fillAttr}${strokeAttr}/>`);
+	}
+	/**
+	* Draw a path from SVG path data string.
+	*/
+	path(d, fill, stroke, fillRule) {
+		if (isDegenerateSingleLinePath(d) && fill.enabled && fill.brushStyle !== 1 && (!stroke.enabled || (stroke.penStyle & PenStyle.PS_STYLE_MASK) === PenStyle.PS_NULL)) {
+			const strokeAttr = buildStrokeAttr({
+				enabled: true,
+				color: fill.color,
+				width: 1,
+				penStyle: PenStyle.PS_SOLID,
+				opacity: degenerateLineStrokeOpacity(this.currentGroupScale())
+			});
+			this.parts.push(`<path d="${d}" fill="none"${strokeAttr} vector-effect="non-scaling-stroke"/>`);
+			return;
+		}
+		const fillAttr = buildFillAttr(fill);
+		const strokeAttr = buildStrokeAttr(stroke);
+		const ruleAttr = fillRule ? ` fill-rule="${fillRule}"` : "";
+		this.parts.push(`<path d="${d}"${fillAttr}${strokeAttr}${ruleAttr}/>`);
+	}
+	/**
+	* Draw a polyline (no fill).
+	*/
+	polyline(points, stroke) {
+		const strokeAttr = buildStrokeAttr(stroke);
+		this.parts.push(`<polyline points="${points}" fill="none"${strokeAttr}/>`);
+	}
+	/**
+	* Draw text.
+	*/
+	text(x, y, content, fontFamily, fontSize, fontWeight, fontStyle, fill, anchor, dominantBaseline, textDecoration = "none") {
+		const escaped = escapeXml$1(content);
+		const colorStr = colorToHex(fill);
+		const weightAttr = fontWeight !== 400 ? ` font-weight="${fontWeight}"` : "";
+		const styleAttr = fontStyle !== "normal" ? ` font-style="${fontStyle}"` : "";
+		const decorationAttr = textDecoration !== "none" ? ` text-decoration="${escapeXml$1(textDecoration)}"` : "";
+		this.parts.push(`<text x="${fmt$1(x)}" y="${fmt$1(y)}" font-family="${escapeXml$1(fontFamily)}" font-size="${fmt$1(fontSize)}"${weightAttr}${styleAttr}${decorationAttr} fill="${colorStr}" text-anchor="${anchor}" dominant-baseline="${dominantBaseline}">${escaped}</text>`);
+	}
+	/**
+	* Embed an image (base64 data URI).
+	*/
+	image(x, y, width, height, dataUri) {
+		this.parts.push(`<image x="${fmt$1(x)}" y="${fmt$1(y)}" width="${fmt$1(width)}" height="${fmt$1(height)}" href="${dataUri}" preserveAspectRatio="none"/>`);
+	}
+	/**
+	* Open a group with optional transform.
+	*/
+	openGroup(transform, clipPathId) {
+		let attrs = "";
+		if (transform) attrs += ` transform="${transform}"`;
+		if (clipPathId) attrs += ` clip-path="url(#${clipPathId})"`;
+		this.groupScaleStack.push(this.currentGroupScale() * transformScale$1(transform));
+		this.parts.push(`<g${attrs}>`);
+	}
+	/**
+	* Close current group.
+	*/
+	closeGroup() {
+		if (this.groupScaleStack.length > 1) this.groupScaleStack.pop();
+		this.parts.push("</g>");
+	}
+	/**
+	* Add a clip path definition. Returns the clip path ID.
+	*/
+	addClipPath(pathData, fillRule, transform) {
+		const id = `clip${this.clipCount++}`;
+		const ruleAttr = fillRule ? ` clip-rule="${fillRule}"` : "";
+		const transformAttr = transform ? ` transform="${transform}"` : "";
+		this.defs.push(`<clipPath id="${id}"><path d="${pathData}"${transformAttr}${ruleAttr}/></clipPath>`);
+		return id;
+	}
+	/**
+	* Write raw SVG string.
+	*/
+	raw(svg) {
+		this.parts.push(svg);
+	}
+	currentGroupScale() {
+		return this.groupScaleStack[this.groupScaleStack.length - 1] ?? 1;
+	}
+	/**
+	* Add a linear gradient definition. Returns the gradient ID.
+	*/
+	addLinearGradient(x1, y1, x2, y2, stops) {
+		const id = `grad${this.gradientCount++}`;
+		let def = `<linearGradient id="${id}" gradientUnits="userSpaceOnUse" x1="${fmt$1(x1)}" y1="${fmt$1(y1)}" x2="${fmt$1(x2)}" y2="${fmt$1(y2)}">`;
+		for (const s of stops) def += `<stop offset="${s.offset}" stop-color="${s.color}"/>`;
+		def += "</linearGradient>";
+		this.defs.push(def);
+		return id;
+	}
+	/**
+	* Draw a rectangle filled with a gradient.
+	*/
+	gradientRect(x, y, w, h, gradientId) {
+		this.parts.push(`<rect x="${fmt$1(x)}" y="${fmt$1(y)}" width="${fmt$1(w)}" height="${fmt$1(h)}" fill="url(#${gradientId})"/>`);
+	}
+	/**
+	* Draw a polygon (for triangle gradient fallback).
+	*/
+	gradientPolygon(points, fillColor) {
+		this.parts.push(`<polygon points="${points}" fill="${fillColor}"/>`);
+	}
+	/**
+	* Embed an image with opacity.
+	*/
+	imageWithOpacity(x, y, width, height, dataUri, opacity) {
+		const opacityAttr = opacity < 1 ? ` opacity="${opacity.toFixed(2)}"` : "";
+		this.parts.push(`<image x="${fmt$1(x)}" y="${fmt$1(y)}" width="${fmt$1(width)}" height="${fmt$1(height)}" href="${dataUri}" preserveAspectRatio="none"${opacityAttr}/>`);
+	}
+};
+function buildFillAttr(fill) {
+	if (!fill.enabled || fill.brushStyle === 1) return " fill=\"none\"";
+	return ` fill="${colorToRgba(fill.color)}"`;
+}
+function buildStrokeAttr(stroke) {
+	if (!stroke.enabled || (stroke.penStyle & PenStyle.PS_STYLE_MASK) === PenStyle.PS_NULL) return "";
+	let attr = ` stroke="${colorToRgba(stroke.color)}"`;
+	if (stroke.width > 0) attr += ` stroke-width="${fmt$1(stroke.width)}"`;
+	if (stroke.opacity !== void 0 && stroke.opacity < 1) attr += ` stroke-opacity="${fmt$1(stroke.opacity)}"`;
+	const style = stroke.penStyle & PenStyle.PS_STYLE_MASK;
+	if (style === PenStyle.PS_DASH) attr += " stroke-dasharray=\"8,4\"";
+	else if (style === PenStyle.PS_DOT) attr += " stroke-dasharray=\"2,2\"";
+	else if (style === PenStyle.PS_DASHDOT) attr += " stroke-dasharray=\"8,4,2,4\"";
+	else if (style === PenStyle.PS_DASHDOTDOT) attr += " stroke-dasharray=\"8,4,2,4,2,4\"";
+	const endCap = stroke.penStyle & PenStyle.PS_ENDCAP_MASK;
+	if (endCap === PenStyle.PS_ENDCAP_SQUARE) attr += " stroke-linecap=\"square\"";
+	else if (endCap === PenStyle.PS_ENDCAP_FLAT) attr += " stroke-linecap=\"butt\"";
+	else attr += " stroke-linecap=\"round\"";
+	const join = stroke.penStyle & PenStyle.PS_JOIN_MASK;
+	if (join === PenStyle.PS_JOIN_BEVEL) attr += " stroke-linejoin=\"bevel\"";
+	else if (join === PenStyle.PS_JOIN_MITER) attr += " stroke-linejoin=\"miter\"";
+	else attr += " stroke-linejoin=\"round\"";
+	return attr;
+}
+function isDegenerateSingleLinePath(pathData) {
+	return /^M-?\d+(?:\.\d+)?,-?\d+(?:\.\d+)?L-?\d+(?:\.\d+)?,-?\d+(?:\.\d+)?Z$/.test(pathData);
+}
+function degenerateLineStrokeOpacity(scale) {
+	if (!Number.isFinite(scale) || scale >= 1) return void 0;
+	return Math.max(.35, Math.min(1, Math.sqrt(scale)));
+}
+function transformScale$1(transform) {
+	if (!transform) return 1;
+	const match = transform.match(/^matrix\((-?\d+(?:\.\d+)?(?:e[+-]?\d+)?),(-?\d+(?:\.\d+)?(?:e[+-]?\d+)?),(-?\d+(?:\.\d+)?(?:e[+-]?\d+)?),(-?\d+(?:\.\d+)?(?:e[+-]?\d+)?),/);
+	if (!match) return 1;
+	const a = Number(match[1]);
+	const b = Number(match[2]);
+	const c = Number(match[3]);
+	const d = Number(match[4]);
+	const areaScale = Math.abs(a * d - b * c);
+	if (!Number.isFinite(areaScale) || areaScale <= 0) return 1;
+	return Math.sqrt(areaScale);
+}
+/** Convert Color to #RRGGBB hex string */
+function colorToHex(c) {
+	return `#${c.r.toString(16).padStart(2, "0")}${c.g.toString(16).padStart(2, "0")}${c.b.toString(16).padStart(2, "0")}`;
+}
+/** Convert Color to rgba() or #hex string */
+function colorToRgba(c) {
+	if (c.a < 255) return `rgba(${c.r},${c.g},${c.b},${(c.a / 255).toFixed(2)})`;
+	return colorToHex(c);
+}
+function escapeXml$1(s) {
+	return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/** Format number for SVG output */
+function fmt$1(n) {
+	return Number(n.toFixed(2)).toString();
+}
+//#endregion
+//#region src/emf-parser.ts
+/** Compare two affine matrices for equality (within epsilon). */
+function matricesEqual(a, b) {
+	for (let i = 0; i < 6; i++) if (Math.abs(a[i] - b[i]) > 1e-10) return false;
+	return true;
+}
+function usesExplicitPageTransform(dc) {
+	const s = dc.state;
+	if (!s.hasExplicitWindowExt || !s.hasExplicitViewportExt) return false;
+	if (s.windowExtX === 0 || s.windowExtY === 0) return false;
+	return true;
+}
+function getPageTransform(dc) {
+	if (!usesExplicitPageTransform(dc)) return identity();
+	const s = dc.state;
+	const sx = dc.getWindowToViewportScaleX();
+	const sy = dc.getWindowToViewportScaleY();
+	return [
+		sx,
+		0,
+		0,
+		sy,
+		s.viewportOrgX - s.windowOrgX * sx,
+		s.viewportOrgY - s.windowOrgY * sy
+	];
+}
+function getEffectiveTransform(dc) {
+	return multiply(getPageTransform(dc), dc.state.worldTransform);
+}
+function getOptionalTransformString(dc) {
+	const transform = getEffectiveTransform(dc);
+	return isIdentity(transform) ? void 0 : toSvgString(transform);
+}
+/**
+* Keep emitted SVG clip groups synchronized with the current EMF device context.
+* SVG ids are nested only for active intersections; replacing the clip region
+* closes prior groups before opening the new stack.
+*/
+function syncClipGroups(svg, dc, state) {
+	const targetClipIds = dc.state.clipPathIds;
+	const currentClipIds = state.emittedClipPathIds;
+	let commonPrefixLength = 0;
+	while (commonPrefixLength < targetClipIds.length && commonPrefixLength < currentClipIds.length && targetClipIds[commonPrefixLength] === currentClipIds[commonPrefixLength]) commonPrefixLength++;
+	if (commonPrefixLength === targetClipIds.length && commonPrefixLength === currentClipIds.length) return;
+	if (state.worldTransformGroup) {
+		svg.closeGroup();
+		state.worldTransformGroup = false;
+		state.lastEmittedTransform = null;
+	}
+	while (currentClipIds.length > commonPrefixLength) {
+		svg.closeGroup();
+		currentClipIds.pop();
+	}
+	for (let index = commonPrefixLength; index < targetClipIds.length; index++) {
+		const clipPathId = targetClipIds[index];
+		if (!clipPathId) continue;
+		svg.openGroup(void 0, clipPathId);
+		currentClipIds.push(clipPathId);
+		state.hadClipGroups = true;
+	}
+}
+/**
+* Ensure the SVG output has the correct world transform group open.
+* Opens/closes `<g transform="matrix(...)">` groups as the world transform changes.
+*/
+function ensureWorldTransformGroup(svg, dc, state) {
+	syncClipGroups(svg, dc, state);
+	const transform = getEffectiveTransform(dc);
+	const isId = isIdentity(transform);
+	if (state.lastEmittedTransform !== null) {
+		if (matricesEqual(transform, state.lastEmittedTransform)) return;
+		svg.closeGroup();
+		state.worldTransformGroup = false;
+		state.lastEmittedTransform = null;
+	}
+	if (!isId) {
+		svg.openGroup(toSvgString(transform));
+		state.worldTransformGroup = true;
+		state.lastEmittedTransform = [...transform];
+	}
+}
+/** Expand the content bounding box with a point, applying the current world transform. */
+function trackPoint(state, dc, x, y) {
+	const wt = getEffectiveTransform(dc);
+	const tx = wt[0] * x + wt[2] * y + wt[4];
+	const ty = wt[1] * x + wt[3] * y + wt[5];
+	if (tx < state.contentMinX) state.contentMinX = tx;
+	if (tx > state.contentMaxX) state.contentMaxX = tx;
+	if (ty < state.contentMinY) state.contentMinY = ty;
+	if (ty > state.contentMaxY) state.contentMaxY = ty;
+}
+/** Expand the clip bounding box with a point, applying the current world transform. */
+function trackClipPoint(state, dc, x, y) {
+	const wt = getEffectiveTransform(dc);
+	const tx = wt[0] * x + wt[2] * y + wt[4];
+	const ty = wt[1] * x + wt[3] * y + wt[5];
+	if (tx < state.clipMinX) state.clipMinX = tx;
+	if (tx > state.clipMaxX) state.clipMaxX = tx;
+	if (ty < state.clipMinY) state.clipMinY = ty;
+	if (ty > state.clipMaxY) state.clipMaxY = ty;
+}
+/** Expand the content bounding box with a rectangle, applying the current world transform. */
+function trackRect(state, dc, x, y, w, h) {
+	trackPoint(state, dc, x, y);
+	trackPoint(state, dc, x + w, y);
+	trackPoint(state, dc, x, y + h);
+	trackPoint(state, dc, x + w, y + h);
+}
+function estimateTextWidth(text, fontSize, fontWidth) {
+	if (fontWidth > 0) return Math.max(fontWidth * Array.from(text).length, 1);
+	let width = 0;
+	for (const char of Array.from(text)) width += char.codePointAt(0) > 255 ? fontSize : fontSize * .62;
+	return Math.max(width, fontSize * .25);
+}
+const ETO_PDY = 8192;
+const ROP_PATCOPY$1 = 15728673;
+function isSymbolEncodedFont(font) {
+	return font.charSet === 2 || font.faceName.toLowerCase() === "symbol";
+}
+function isMathTypeExtraFont(font) {
+	return font.faceName.toLowerCase().includes("mt extra");
+}
+function decodePrivateUseMathText(text, font) {
+	const map = isSymbolEncodedFont(font) ? SYMBOL_CHAR_MAP : isMathTypeExtraFont(font) ? MT_EXTRA_CHAR_MAP : void 0;
+	if (!map) return text;
+	let decoded = "";
+	for (const char of Array.from(text)) {
+		const code = char.codePointAt(0);
+		const lowByte = code & 255;
+		decoded += code >= 61440 && code <= 61695 ? map[lowByte] ?? char : char;
+	}
+	return decoded;
+}
+function svgFontFamilyForEmfText(font) {
+	if (isSymbolEncodedFont(font) || isMathTypeExtraFont(font)) return "serif";
+	return font.faceName || "Arial";
+}
+function readTextDx$1(reader, recordStart, offDx, nChars, options) {
+	if (offDx <= 0 || nChars <= 0) return void 0;
+	const valuesPerChar = options & ETO_PDY ? 2 : 1;
+	const count = nChars * valuesPerChar;
+	if (recordStart + offDx + count * 4 > reader.length) return void 0;
+	const original = reader.position;
+	reader.seek(recordStart + offDx);
+	const x = [];
+	const y = [];
+	for (let i = 0; i < nChars; i++) {
+		x.push(reader.readInt32());
+		if (valuesPerChar === 2) y.push(reader.readInt32());
+	}
+	reader.seek(original);
+	return {
+		x,
+		y
+	};
+}
+function textOriginFromCurrentPosition(dc, x, y) {
+	if (dc.state.textAlign & TextAlign.TA_UPDATECP) return {
+		x: dc.state.currentPosX,
+		y: dc.state.currentPosY
+	};
+	return {
+		x,
+		y
+	};
+}
+function updateCurrentTextPosition(dc, originX, originY, text, fontSize, fontWidth, dx) {
+	if (!(dc.state.textAlign & TextAlign.TA_UPDATECP)) return;
+	const chars = Array.from(text);
+	const advanceX = dx?.x.length ? dx.x.slice(0, chars.length).reduce((sum, item) => sum + item, 0) : estimateTextWidth(text, fontSize, fontWidth);
+	const advanceY = dx?.y.length ? dx.y.slice(0, chars.length).reduce((sum, item) => sum + item, 0) : 0;
+	dc.state.currentPosX = originX + advanceX;
+	dc.state.currentPosY = originY + advanceY;
+}
+function emitEmfText(svg, dc, state, x, y, text, fontFamily, fontSize, fontWeight, fontStyle, anchor, baseline, dx) {
+	const chars = Array.from(text);
+	const decoration = [dc.state.font.underline ? "underline" : "", dc.state.font.strikeOut ? "line-through" : ""].filter(Boolean).join(" ") || "none";
+	if (!dx?.x.length || chars.length <= 1) {
+		trackTextBounds(state, dc, x, y, text, fontSize, dc.state.font.width ?? 0, anchor, baseline);
+		svg.text(x, y, text, fontFamily, fontSize, fontWeight, fontStyle, dc.state.textColor, anchor, baseline, decoration);
+		return;
+	}
+	const totalAdvance = dx.x.slice(0, chars.length).reduce((sum, item) => sum + item, 0);
+	let cursorX = x;
+	if (anchor === "middle") cursorX -= totalAdvance / 2;
+	else if (anchor === "end") cursorX -= totalAdvance;
+	let cursorY = y;
+	for (let i = 0; i < chars.length; i++) {
+		const char = chars[i];
+		trackTextBounds(state, dc, cursorX, cursorY, char, fontSize, dc.state.font.width ?? 0, "start", baseline);
+		svg.text(cursorX, cursorY, char, fontFamily, fontSize, fontWeight, fontStyle, dc.state.textColor, "start", baseline, decoration);
+		cursorX += dx.x[i] ?? 0;
+		cursorY += dx.y[i] ?? 0;
+	}
+}
+function trackTextBounds(state, dc, x, y, text, fontSize, fontWidth, anchor, baseline) {
+	const width = estimateTextWidth(text, fontSize, fontWidth);
+	const italicPad = dc.state.font.italic ? fontSize * .2 : 0;
+	let left = x;
+	if (anchor === "middle") left -= width / 2;
+	else if (anchor === "end") left -= width;
+	left -= italicPad * .5;
+	let top = y;
+	let height = fontSize;
+	if (baseline === "auto") {
+		top = y - fontSize;
+		height = fontSize * 1.25;
+	} else if (baseline === "text-after-edge") top = y - fontSize;
+	trackRect(state, dc, left, top, width + italicPad, height);
+}
+/** Expand the clip bounding box with a rectangle, applying the current world transform. */
+function trackClipRect(state, dc, x, y, w, h) {
+	trackClipPoint(state, dc, x, y);
+	trackClipPoint(state, dc, x + w, y);
+	trackClipPoint(state, dc, x, y + h);
+	trackClipPoint(state, dc, x + w, y + h);
+}
+function transformRectBounds(transform, x, y, w, h) {
+	const p1 = transformPoint(transform, {
+		x,
+		y
+	});
+	const p2 = transformPoint(transform, {
+		x: x + w,
+		y
+	});
+	const p3 = transformPoint(transform, {
+		x,
+		y: y + h
+	});
+	const p4 = transformPoint(transform, {
+		x: x + w,
+		y: y + h
+	});
+	return {
+		left: Math.min(p1.x, p2.x, p3.x, p4.x),
+		top: Math.min(p1.y, p2.y, p3.y, p4.y),
+		right: Math.max(p1.x, p2.x, p3.x, p4.x),
+		bottom: Math.max(p1.y, p2.y, p3.y, p4.y)
+	};
+}
+/** Expand the content bounding box with an array of points. */
+function trackPoints(state, dc, points) {
+	for (const p of points) trackPoint(state, dc, p.x, p.y);
+}
+/** Transfer the pathBuilder's accumulated bounds into the parser state (applying world transform). */
+function trackPathBounds(state, dc, pb) {
+	if (pb.minX <= pb.maxX && pb.minY <= pb.maxY) {
+		trackPoint(state, dc, pb.minX, pb.minY);
+		trackPoint(state, dc, pb.maxX, pb.maxY);
+		trackPoint(state, dc, pb.minX, pb.maxY);
+		trackPoint(state, dc, pb.maxX, pb.minY);
+	}
+}
+/** Transfer the pathBuilder's accumulated bounds into the clip bounds. */
+function trackClipPathBounds(state, dc, pb) {
+	if (pb.minX <= pb.maxX && pb.minY <= pb.maxY) {
+		trackClipPoint(state, dc, pb.minX, pb.minY);
+		trackClipPoint(state, dc, pb.maxX, pb.maxY);
+		trackClipPoint(state, dc, pb.minX, pb.maxY);
+		trackClipPoint(state, dc, pb.maxX, pb.minY);
+	}
+}
+function rectsOverlap(ax, ay, aw, ah, bx, by, bw, bh) {
+	return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by;
+}
+/**
+* Parse an EMF buffer and return SVG string.
+*/
+function parseEmf(buffer) {
+	const reader = new BinaryReader(buffer);
+	const dc = new DeviceContext();
+	const objects = new ObjectTable();
+	const svg = new SvgWriter();
+	const pathBuilder = new PathBuilder();
+	const state = {
+		pathRecording: false,
+		worldTransformGroup: false,
+		emittedClipPathIds: [],
+		lastEmittedTransform: null,
+		hadClipGroups: false,
+		contentMinX: Infinity,
+		contentMaxX: -Infinity,
+		contentMinY: Infinity,
+		contentMaxY: -Infinity,
+		clipMinX: Infinity,
+		clipMaxX: -Infinity,
+		clipMinY: Infinity,
+		clipMaxY: -Infinity,
+		sourceCanvasBounds: void 0
+	};
+	const header = parseHeader(reader);
+	if (!header) throw new Error("Invalid EMF file: could not parse header");
+	const bounds = header.bounds;
+	const viewX = bounds.left;
+	const viewY = bounds.top;
+	const viewW = bounds.right - bounds.left;
+	const viewH = bounds.bottom - bounds.top;
+	if (viewW <= 0 || viewH <= 0) throw new Error("Invalid EMF file: zero or negative bounds");
+	dc.state.windowOrgX = viewX;
+	dc.state.windowOrgY = viewY;
+	dc.state.windowExtX = viewW;
+	dc.state.windowExtY = viewH;
+	dc.state.viewportOrgX = viewX;
+	dc.state.viewportOrgY = viewY;
+	dc.state.viewportExtX = viewW;
+	dc.state.viewportExtY = viewH;
+	svg.beginDocument(viewX, viewY, viewW, viewH);
+	reader.seek(header.size);
+	let recordCount = 0;
+	while (reader.remaining >= 8 && recordCount < header.numRecords) {
+		const recordStart = reader.position;
+		const recordType = reader.readUint32();
+		const recordSize = reader.readUint32();
+		if (recordSize < 8 || recordStart + recordSize > reader.length) break;
+		const dataSize = recordSize - 8;
+		processRecord$1(recordType, reader, recordStart + 8, dataSize, dc, objects, svg, pathBuilder, state);
+		if (recordType === 59) state.pathRecording = true;
+		else if (recordType === 60 || recordType === 62 || recordType === 64 || recordType === 63 || recordType === 68) state.pathRecording = false;
+		reader.seek(recordStart + recordSize);
+		recordCount++;
+		if (recordType === 14) break;
+	}
+	if (state.worldTransformGroup) svg.closeGroup();
+	while (state.emittedClipPathIds.length > 0) {
+		svg.closeGroup();
+		state.emittedClipPathIds.pop();
+	}
+	const finalWindow = transformRectBounds(getPageTransform(dc), dc.state.windowOrgX, dc.state.windowOrgY, dc.state.windowExtX, dc.state.windowExtY);
+	let finalX = finalWindow.left;
+	let finalY = finalWindow.top;
+	let finalW = finalWindow.right - finalWindow.left;
+	let finalH = finalWindow.bottom - finalWindow.top;
+	let usedSourceCanvasBounds = false;
+	if (state.sourceCanvasBounds && state.contentMinX < state.contentMaxX) {
+		finalX = state.contentMinX;
+		finalY = state.sourceCanvasBounds.top;
+		finalW = state.contentMaxX - state.contentMinX;
+		finalH = state.sourceCanvasBounds.bottom - state.sourceCanvasBounds.top;
+		usedSourceCanvasBounds = true;
+	} else if (state.sourceCanvasBounds) {
+		finalX = state.sourceCanvasBounds.left;
+		finalY = state.sourceCanvasBounds.top;
+		finalW = state.sourceCanvasBounds.right - state.sourceCanvasBounds.left;
+		finalH = state.sourceCanvasBounds.bottom - state.sourceCanvasBounds.top;
+		usedSourceCanvasBounds = true;
+	} else if (state.contentMinX < state.contentMaxX && state.contentMinY < state.contentMaxY) {
+		if (state.hadClipGroups) {
+			if (!(state.clipMinX < state.clipMaxX && state.clipMinY < state.clipMaxY) || rectsOverlap(state.clipMinX, state.clipMinY, state.clipMaxX - state.clipMinX, state.clipMaxY - state.clipMinY, finalX, finalY, finalW, finalH)) {
+				const winRight = finalX + finalW;
+				const winBottom = finalY + finalH;
+				const clampedX = Math.max(state.contentMinX, finalX);
+				const clampedY = Math.max(state.contentMinY, finalY);
+				const clampedRight = Math.min(state.contentMaxX, winRight);
+				const clampedBottom = Math.min(state.contentMaxY, winBottom);
+				if (clampedRight > clampedX && clampedBottom > clampedY) {
+					finalX = clampedX;
+					finalY = clampedY;
+					finalW = clampedRight - clampedX;
+					finalH = clampedBottom - clampedY;
+				}
+			} else {
+				finalX = state.contentMinX;
+				finalY = state.contentMinY;
+				finalW = state.contentMaxX - state.contentMinX;
+				finalH = state.contentMaxY - state.contentMinY;
+			}
+		} else {
+			finalX = state.contentMinX;
+			finalY = state.contentMinY;
+			finalW = state.contentMaxX - state.contentMinX;
+			finalH = state.contentMaxY - state.contentMinY;
+		}
+	}
+	if (finalW > 0 && finalH > 0 && (finalW !== viewW || finalH !== viewH || finalX !== viewX || finalY !== viewY)) svg.updateViewBox(finalX, finalY, finalW, finalH);
+	if (usedSourceCanvasBounds) {
+		svg.setRootDataAttribute("data-s8fy-preserves-src-rect", "true");
+		svg.preserveAspectRatioNone();
+	}
+	return svg.endDocument();
+}
+function processRecord$1(type, reader, dataStart, dataSize, dc, objects, svg, pathBuilder, state) {
+	reader.seek(dataStart);
+	switch (type) {
+		case 1:
+		case 14: break;
+		case 70: {
+			const cbData = reader.readUint32();
+			if (cbData >= 28 && reader.remaining >= cbData) {
+				const data = reader.readBytes(cbData);
+				if (data[0] === 71 && data[1] === 68 && data[2] === 73 && data[3] === 67) {
+					const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+					const width = view.getInt32(16, true);
+					const height = view.getInt32(20, true);
+					if (width > 0 && height > 0) state.sourceCanvasBounds = transformRectBounds(getEffectiveTransform(dc), 0, 0, width, height);
+				}
+			}
+			break;
+		}
+		case 33:
+			dc.save();
+			break;
+		case 34: {
+			const savedDC = reader.readInt32();
+			dc.restore(savedDC);
+			syncClipGroups(svg, dc, state);
+			break;
+		}
+		case 9:
+			dc.state.windowExtX = reader.readInt32();
+			dc.state.windowExtY = reader.readInt32();
+			dc.state.hasExplicitWindowExt = true;
+			break;
+		case 10:
+			dc.state.windowOrgX = reader.readInt32();
+			dc.state.windowOrgY = reader.readInt32();
+			break;
+		case 11:
+			dc.state.viewportExtX = reader.readInt32();
+			dc.state.viewportExtY = reader.readInt32();
+			dc.state.hasExplicitViewportExt = true;
+			break;
+		case 12:
+			dc.state.viewportOrgX = reader.readInt32();
+			dc.state.viewportOrgY = reader.readInt32();
+			break;
+		case 24:
+			dc.state.textColor = readColorRef(reader);
+			break;
+		case 22:
+			dc.state.textAlign = reader.readUint32();
+			break;
+		case 18:
+			dc.state.bkMode = reader.readUint32();
+			break;
+		case 25:
+			dc.state.bkColor = readColorRef(reader);
+			break;
+		case 19:
+			dc.state.polyFillMode = reader.readUint32();
+			break;
+		case 58:
+			dc.state.miterLimit = reader.readUint32();
+			break;
+		case 17:
+			dc.state.mapMode = reader.readUint32();
+			break;
+		case 20:
+		case 21:
+		case 13:
+		case 16:
+		case 98:
+		case 115:
+		case 23: break;
+		case 57:
+			dc.state.arcDirection = reader.readUint32();
+			break;
+		case 35:
+			dc.state.worldTransform = readXForm(reader);
+			break;
+		case 36: {
+			const xform = readXForm(reader);
+			switch (reader.readUint32()) {
+				case 1:
+					dc.state.worldTransform = identity();
+					break;
+				case 2:
+					dc.state.worldTransform = multiply(xform, dc.state.worldTransform);
+					break;
+				case 3:
+					dc.state.worldTransform = multiply(dc.state.worldTransform, xform);
+					break;
+				case 4: dc.state.worldTransform = xform;
+			}
+			break;
+		}
+		case 37: {
+			const index = reader.readUint32();
+			objects.select(index, dc);
+			break;
+		}
+		case 40: {
+			const index = reader.readUint32();
+			objects.delete(index);
+			break;
+		}
+		case 39: {
+			const ihBrush = reader.readUint32();
+			const style = reader.readUint32();
+			const color = readColorRef(reader);
+			const hatch = reader.readUint32();
+			objects.create(ihBrush, {
+				type: "brush",
+				style,
+				color,
+				hatch
+			});
+			break;
+		}
+		case 38: {
+			const ihPen = reader.readUint32();
+			const style = reader.readUint32();
+			const widthX = reader.readInt32();
+			reader.readInt32();
+			const color = readColorRef(reader);
+			objects.create(ihPen, {
+				type: "pen",
+				style,
+				width: Math.max(widthX, 1),
+				color,
+				endCap: 0,
+				lineJoin: 0
+			});
+			break;
+		}
+		case 95: {
+			const ihPen = reader.readUint32();
+			reader.readUint32();
+			reader.readUint32();
+			reader.readUint32();
+			reader.readUint32();
+			const style = reader.readUint32();
+			const width = reader.readUint32();
+			reader.readUint32();
+			const color = readColorRef(reader);
+			const endCap = style & PenStyle.PS_ENDCAP_MASK;
+			const lineJoin = style & PenStyle.PS_JOIN_MASK;
+			objects.create(ihPen, {
+				type: "pen",
+				style: style & PenStyle.PS_STYLE_MASK,
+				width: Math.max(width, 1),
+				color,
+				endCap,
+				lineJoin
+			});
+			break;
+		}
+		case 82: {
+			const ihFont = reader.readUint32();
+			const height = reader.readInt32();
+			const width = reader.readInt32();
+			const escapement = reader.readInt32();
+			const orientation = reader.readInt32();
+			const weight = reader.readInt32();
+			const italic = reader.readUint8() !== 0;
+			const underline = reader.readUint8() !== 0;
+			const strikeOut = reader.readUint8() !== 0;
+			const charSet = reader.readUint8();
+			reader.skip(4);
+			const faceName = reader.readUtf16String(32);
+			objects.create(ihFont, {
+				type: "font",
+				height: Math.abs(height),
+				width,
+				weight,
+				italic,
+				underline,
+				strikeOut,
+				charSet,
+				faceName,
+				escapement,
+				orientation
+			});
+			break;
+		}
+		case 48:
+		case 49:
+		case 50:
+		case 51:
+		case 52: break;
+		case 27: {
+			const x = reader.readInt32();
+			const y = reader.readInt32();
+			dc.state.currentPosX = x;
+			dc.state.currentPosY = y;
+			if (state.pathRecording) pathBuilder.moveTo(x, y);
+			break;
+		}
+		case 54: {
+			const x = reader.readInt32();
+			const y = reader.readInt32();
+			if (state.pathRecording) {
+				if (!pathBuilder.hasContent) pathBuilder.moveTo(dc.state.currentPosX, dc.state.currentPosY);
+				pathBuilder.lineTo(x, y);
+			} else {
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPoint(state, dc, dc.state.currentPosX, dc.state.currentPosY);
+				trackPoint(state, dc, x, y);
+				emitLine(svg, dc, dc.state.currentPosX, dc.state.currentPosY, x, y);
+			}
+			dc.state.currentPosX = x;
+			dc.state.currentPosY = y;
+			break;
+		}
+		case 43: {
+			const left = reader.readInt32();
+			const top = reader.readInt32();
+			const right = reader.readInt32();
+			const bottom = reader.readInt32();
+			if (state.pathRecording) {
+				pathBuilder.moveTo(left, top);
+				pathBuilder.lineTo(right, top);
+				pathBuilder.lineTo(right, bottom);
+				pathBuilder.lineTo(left, bottom);
+				pathBuilder.closePath();
+			} else {
+				ensureWorldTransformGroup(svg, dc, state);
+				trackRect(state, dc, left, top, right - left, bottom - top);
+				svg.rect(left, top, right - left, bottom - top, dc.getFillStyle(), dc.getStrokeStyle());
+			}
+			break;
+		}
+		case 42: {
+			const left = reader.readInt32();
+			const top = reader.readInt32();
+			const right = reader.readInt32();
+			const bottom = reader.readInt32();
+			const cx = (left + right) / 2;
+			const cy = (top + bottom) / 2;
+			const rx = (right - left) / 2;
+			const ry = (bottom - top) / 2;
+			if (state.pathRecording) approximateEllipse(pathBuilder, cx, cy, rx, ry);
+			else {
+				ensureWorldTransformGroup(svg, dc, state);
+				trackRect(state, dc, left, top, right - left, bottom - top);
+				svg.ellipse(cx, cy, rx, ry, dc.getFillStyle(), dc.getStrokeStyle());
+			}
+			break;
+		}
+		case 44: {
+			const left = reader.readInt32();
+			const top = reader.readInt32();
+			const right = reader.readInt32();
+			const bottom = reader.readInt32();
+			const cornerW = reader.readInt32();
+			const cornerH = reader.readInt32();
+			if (!state.pathRecording) {
+				const rx = cornerW / 2;
+				const ry = cornerH / 2;
+				const w = right - left;
+				const h = bottom - top;
+				const d = roundedRectPath(left, top, w, h, rx, ry);
+				ensureWorldTransformGroup(svg, dc, state);
+				trackRect(state, dc, left, top, w, h);
+				svg.path(d, dc.getFillStyle(), dc.getStrokeStyle());
+			}
+			break;
+		}
+		case 45:
+		case 46:
+		case 47: {
+			const left = reader.readInt32();
+			const top = reader.readInt32();
+			const right = reader.readInt32();
+			const bottom = reader.readInt32();
+			const startPtX = reader.readInt32();
+			const startPtY = reader.readInt32();
+			const endPtX = reader.readInt32();
+			const endPtY = reader.readInt32();
+			const kind = type === 45 ? "arc" : type === 46 ? "chord" : "pie";
+			const arc = buildArcPath(left, top, right, bottom, startPtX, startPtY, endPtX, endPtY, dc.state.arcDirection, kind);
+			if (arc) {
+				if (state.pathRecording) addArcToPathBuilder(pathBuilder, arc, dc.state.arcDirection, kind);
+				else {
+					ensureWorldTransformGroup(svg, dc, state);
+					trackRect(state, dc, left, top, right - left, bottom - top);
+					if (kind === "arc") svg.path(arc.d, {
+						enabled: false,
+						color: {
+							r: 0,
+							g: 0,
+							b: 0,
+							a: 0
+						},
+						brushStyle: 1
+					}, dc.getStrokeStyle());
+					else svg.path(arc.d, dc.getFillStyle(), dc.getStrokeStyle());
+				}
+			}
+			break;
+		}
+		case 55: {
+			const arc = buildArcPath(reader.readInt32(), reader.readInt32(), reader.readInt32(), reader.readInt32(), reader.readInt32(), reader.readInt32(), reader.readInt32(), reader.readInt32(), dc.state.arcDirection, "arc");
+			if (arc && state.pathRecording) {
+				if (!pathBuilder.hasContent) pathBuilder.moveTo(dc.state.currentPosX, dc.state.currentPosY);
+				pathBuilder.lineTo(arc.startX, arc.startY);
+				pathBuilder.arcTo(arc.rx, arc.ry, 0, arc.largeArc, arc.sweep, arc.endX, arc.endY);
+				dc.state.currentPosX = arc.endX;
+				dc.state.currentPosY = arc.endY;
+			}
+			break;
+		}
+		case 41: {
+			const cx = reader.readInt32();
+			const cy = reader.readInt32();
+			const radius = reader.readUint32();
+			const startAngleDeg = reader.readFloat32();
+			const sweepAngleDeg = reader.readFloat32();
+			if (radius > 0 && sweepAngleDeg !== 0) {
+				const startAngle = startAngleDeg * Math.PI / 180;
+				const endAngle = (startAngleDeg + sweepAngleDeg) * Math.PI / 180;
+				const sx = cx + radius * Math.cos(startAngle);
+				const sy = cy + radius * Math.sin(startAngle);
+				const ex = cx + radius * Math.cos(endAngle);
+				const ey = cy + radius * Math.sin(endAngle);
+				const sweepFlag = sweepAngleDeg > 0 ? 1 : 0;
+				const largeArc = Math.abs(sweepAngleDeg) > 180 ? 1 : 0;
+				if (state.pathRecording) {
+					if (!pathBuilder.hasContent) pathBuilder.moveTo(dc.state.currentPosX, dc.state.currentPosY);
+					pathBuilder.lineTo(sx, sy);
+					pathBuilder.arcTo(radius, radius, 0, largeArc, sweepFlag, ex, ey);
+					dc.state.currentPosX = ex;
+					dc.state.currentPosY = ey;
+				} else {
+					const d = `M${fmtN(sx)},${fmtN(sy)}A${radius},${radius},0,${largeArc},${sweepFlag},${fmtN(ex)},${fmtN(ey)}`;
+					ensureWorldTransformGroup(svg, dc, state);
+					trackPoint(state, dc, cx - radius, cy - radius);
+					trackPoint(state, dc, cx + radius, cy + radius);
+					svg.path(d, {
+						enabled: false,
+						color: {
+							r: 0,
+							g: 0,
+							b: 0,
+							a: 0
+						},
+						brushStyle: 1
+					}, dc.getStrokeStyle());
+				}
+			}
+			break;
+		}
+		case 86: {
+			readBoundsRect(reader);
+			const points = readPoints16(reader, reader.readUint32());
+			if (state.pathRecording) addPolygonToPath(pathBuilder, points);
+			else {
+				const d = polygonToPathData(points);
+				const fillRule = dc.state.polyFillMode === 1 ? "evenodd" : "nonzero";
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPoints(state, dc, points);
+				svg.path(d, dc.getFillStyle(), dc.getStrokeStyle(), fillRule);
+			}
+			break;
+		}
+		case 87: {
+			readBoundsRect(reader);
+			const points = readPoints16(reader, reader.readUint32());
+			if (state.pathRecording) addPolylineToPath(pathBuilder, points);
+			else {
+				const d = polylineToPathData(points);
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPoints(state, dc, points);
+				svg.path(d, {
+					enabled: false,
+					color: {
+						r: 0,
+						g: 0,
+						b: 0,
+						a: 0
+					},
+					brushStyle: 1
+				}, dc.getStrokeStyle());
+			}
+			break;
+		}
+		case 85: {
+			readBoundsRect(reader);
+			const points = readPoints16(reader, reader.readUint32());
+			if (points.length >= 4) {
+				if (state.pathRecording) addPolyBezierToPath(pathBuilder, points);
+				else {
+					const d = polyBezierToPathData(points);
+					ensureWorldTransformGroup(svg, dc, state);
+					trackPoints(state, dc, points);
+					svg.path(d, {
+						enabled: false,
+						color: {
+							r: 0,
+							g: 0,
+							b: 0,
+							a: 0
+						},
+						brushStyle: 1
+					}, dc.getStrokeStyle());
+				}
+			}
+			break;
+		}
+		case 88: {
+			readBoundsRect(reader);
+			const points = readPoints16(reader, reader.readUint32());
+			if (state.pathRecording && points.length >= 3) {
+				if (!pathBuilder.hasContent) pathBuilder.moveTo(dc.state.currentPosX, dc.state.currentPosY);
+				for (let i = 0; i + 2 < points.length; i += 3) pathBuilder.curveTo(points[i].x, points[i].y, points[i + 1].x, points[i + 1].y, points[i + 2].x, points[i + 2].y);
+				const last = points[points.length - 1];
+				dc.state.currentPosX = last.x;
+				dc.state.currentPosY = last.y;
+			}
+			break;
+		}
+		case 89: {
+			readBoundsRect(reader);
+			const points = readPoints16(reader, reader.readUint32());
+			if (state.pathRecording) {
+				if (!pathBuilder.hasContent) pathBuilder.moveTo(dc.state.currentPosX, dc.state.currentPosY);
+				for (const p of points) pathBuilder.lineTo(p.x, p.y);
+				if (points.length > 0) {
+					const last = points[points.length - 1];
+					dc.state.currentPosX = last.x;
+					dc.state.currentPosY = last.y;
+				}
+			}
+			break;
+		}
+		case 91: {
+			readBoundsRect(reader);
+			const numPolygons = reader.readUint32();
+			const totalPoints = reader.readUint32();
+			const polygonCounts = [];
+			for (let i = 0; i < numPolygons; i++) polygonCounts.push(reader.readUint32());
+			const allPoints = readPoints16(reader, totalPoints);
+			let offset = 0;
+			let d = "";
+			for (let i = 0; i < numPolygons; i++) {
+				const count = polygonCounts[i];
+				const polyPoints = allPoints.slice(offset, offset + count);
+				d += polygonToPathData(polyPoints);
+				offset += count;
+			}
+			if (state.pathRecording) {} else {
+				const fillRule = dc.state.polyFillMode === 1 ? "evenodd" : "nonzero";
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPoints(state, dc, allPoints);
+				svg.path(d, dc.getFillStyle(), dc.getStrokeStyle(), fillRule);
+			}
+			break;
+		}
+		case 3: {
+			readBoundsRect(reader);
+			const points = readPoints32(reader, reader.readUint32());
+			if (!state.pathRecording) {
+				const d = polygonToPathData(points);
+				const fillRule = dc.state.polyFillMode === 1 ? "evenodd" : "nonzero";
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPoints(state, dc, points);
+				svg.path(d, dc.getFillStyle(), dc.getStrokeStyle(), fillRule);
+			}
+			break;
+		}
+		case 4: {
+			readBoundsRect(reader);
+			const points = readPoints32(reader, reader.readUint32());
+			if (!state.pathRecording) {
+				const d = polylineToPathData(points);
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPoints(state, dc, points);
+				svg.path(d, {
+					enabled: false,
+					color: {
+						r: 0,
+						g: 0,
+						b: 0,
+						a: 0
+					},
+					brushStyle: 1
+				}, dc.getStrokeStyle());
+			}
+			break;
+		}
+		case 2: {
+			readBoundsRect(reader);
+			const points = readPoints32(reader, reader.readUint32());
+			if (points.length >= 4 && !state.pathRecording) {
+				const d = polyBezierToPathData(points);
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPoints(state, dc, points);
+				svg.path(d, {
+					enabled: false,
+					color: {
+						r: 0,
+						g: 0,
+						b: 0,
+						a: 0
+					},
+					brushStyle: 1
+				}, dc.getStrokeStyle());
+			}
+			break;
+		}
+		case 5: {
+			readBoundsRect(reader);
+			const points = readPoints32(reader, reader.readUint32());
+			if (state.pathRecording && points.length >= 3) {
+				if (!pathBuilder.hasContent) pathBuilder.moveTo(dc.state.currentPosX, dc.state.currentPosY);
+				for (let i = 0; i + 2 < points.length; i += 3) pathBuilder.curveTo(points[i].x, points[i].y, points[i + 1].x, points[i + 1].y, points[i + 2].x, points[i + 2].y);
+				const last = points[points.length - 1];
+				dc.state.currentPosX = last.x;
+				dc.state.currentPosY = last.y;
+			}
+			break;
+		}
+		case 6: {
+			readBoundsRect(reader);
+			const points = readPoints32(reader, reader.readUint32());
+			if (state.pathRecording) {
+				if (!pathBuilder.hasContent) pathBuilder.moveTo(dc.state.currentPosX, dc.state.currentPosY);
+				for (const p of points) pathBuilder.lineTo(p.x, p.y);
+				if (points.length > 0) {
+					const last = points[points.length - 1];
+					dc.state.currentPosX = last.x;
+					dc.state.currentPosY = last.y;
+				}
+			}
+			break;
+		}
+		case 59:
+			pathBuilder.clear();
+			break;
+		case 60: break;
+		case 61:
+			if (state.pathRecording) pathBuilder.closePath();
+			break;
+		case 62: {
+			const d = pathBuilder.toPathData();
+			if (d) {
+				const fillRule = dc.state.polyFillMode === 1 ? "evenodd" : "nonzero";
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPathBounds(state, dc, pathBuilder);
+				svg.path(d, dc.getFillStyle(), {
+					enabled: false,
+					color: {
+						r: 0,
+						g: 0,
+						b: 0,
+						a: 0
+					},
+					width: 0,
+					penStyle: PenStyle.PS_NULL
+				}, fillRule);
+			}
+			pathBuilder.clear();
+			break;
+		}
+		case 64: {
+			const d = pathBuilder.toPathData();
+			if (d) {
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPathBounds(state, dc, pathBuilder);
+				svg.path(d, {
+					enabled: false,
+					color: {
+						r: 0,
+						g: 0,
+						b: 0,
+						a: 0
+					},
+					brushStyle: 1
+				}, dc.getStrokeStyle());
+			}
+			pathBuilder.clear();
+			break;
+		}
+		case 63: {
+			const d = pathBuilder.toPathData();
+			if (d) {
+				const fillRule = dc.state.polyFillMode === 1 ? "evenodd" : "nonzero";
+				ensureWorldTransformGroup(svg, dc, state);
+				trackPathBounds(state, dc, pathBuilder);
+				svg.path(d, dc.getFillStyle(), dc.getStrokeStyle(), fillRule);
+			}
+			pathBuilder.clear();
+			break;
+		}
+		case 68:
+			pathBuilder.clear();
+			break;
+		case 65:
+		case 66: break;
+		case 67: {
+			const d = pathBuilder.toPathData();
+			const regionMode = reader.readUint32();
+			if (d) {
+				const fillRule = dc.state.polyFillMode === 1 ? "evenodd" : "nonzero";
+				const clipId = svg.addClipPath(d, fillRule, getOptionalTransformString(dc));
+				trackClipPathBounds(state, dc, pathBuilder);
+				if (regionMode === 1) dc.state.clipPathIds = [...dc.state.clipPathIds, clipId];
+				else dc.state.clipPathIds = [clipId];
+				syncClipGroups(svg, dc, state);
+			}
+			pathBuilder.clear();
+			break;
+		}
+		case 30: {
+			const left = reader.readInt32();
+			const top = reader.readInt32();
+			const right = reader.readInt32();
+			const bottom = reader.readInt32();
+			const w = right - left;
+			const h = bottom - top;
+			if (w > 0 && h > 0) {
+				const d = `M${left},${top}L${right},${top}L${right},${bottom}L${left},${bottom}Z`;
+				const clipId = svg.addClipPath(d, void 0, getOptionalTransformString(dc));
+				trackClipRect(state, dc, left, top, w, h);
+				dc.state.clipPathIds = [...dc.state.clipPathIds, clipId];
+				syncClipGroups(svg, dc, state);
+			}
+			break;
+		}
+		case 84: {
+			readBoundsRect(reader);
+			reader.skip(4);
+			reader.skip(4);
+			reader.skip(4);
+			const refX = reader.readInt32();
+			const refY = reader.readInt32();
+			const nChars = reader.readUint32();
+			const offString = reader.readUint32();
+			const options = reader.readUint32();
+			reader.skip(16);
+			const offDx = reader.readUint32();
+			if (nChars > 0 && offString > 0) {
+				const recordStart = dataStart - 8;
+				reader.seek(recordStart + offString);
+				const text = decodePrivateUseMathText(reader.readUtf16String(nChars), dc.state.font);
+				if (text.length > 0) {
+					const font = dc.state.font;
+					const fontSize = font.height > 0 ? font.height : 12;
+					const fontWeight = font.weight;
+					const fontStyle = font.italic ? "italic" : "normal";
+					const fontFamily = svgFontFamilyForEmfText(font);
+					const point = textOriginFromCurrentPosition(dc, refX, refY);
+					let anchor = "start";
+					const hAlign = dc.state.textAlign & 6;
+					if (hAlign === 6) anchor = "middle";
+					else if (hAlign === 2) anchor = "end";
+					let baseline = "auto";
+					const vAlign = dc.state.textAlign & 24;
+					if (vAlign === 24) baseline = "auto";
+					else if (vAlign === 8) baseline = "text-after-edge";
+					else baseline = "text-before-edge";
+					const textY = baseline === "auto" && point.y === 0 ? point.y + fontSize : point.y;
+					const dx = readTextDx$1(reader, recordStart, offDx, nChars, options);
+					ensureWorldTransformGroup(svg, dc, state);
+					emitEmfText(svg, dc, state, point.x, textY, text, fontFamily, fontSize, fontWeight, fontStyle, anchor, baseline, dx);
+					updateCurrentTextPosition(dc, point.x, textY, text, fontSize, font.width ?? 0, dx);
+				}
+			}
+			break;
+		}
+		case 81: {
+			readBoundsRect(reader);
+			const xDest = reader.readInt32();
+			const yDest = reader.readInt32();
+			reader.skip(4);
+			reader.skip(4);
+			reader.skip(4);
+			reader.skip(4);
+			const offBmiSrc = reader.readUint32();
+			const cbBmiSrc = reader.readUint32();
+			const offBitsSrc = reader.readUint32();
+			const cbBitsSrc = reader.readUint32();
+			reader.skip(4);
+			reader.skip(4);
+			const cxDest = reader.readInt32();
+			const cyDest = reader.readInt32();
+			if (cbBmiSrc > 0 && cbBitsSrc > 0) {
+				const recordStart = dataStart - 8;
+				reader.seek(recordStart + offBmiSrc);
+				const dibHeader = reader.readSlice(cbBmiSrc);
+				reader.seek(recordStart + offBitsSrc);
+				const bitmapBits = reader.readSlice(cbBitsSrc);
+				const format = detectEmbeddedFormat(bitmapBits);
+				let dataUri;
+				if (format === "png" || format === "jpeg") dataUri = rawImageToDataUri(bitmapBits);
+				else dataUri = dibToDataUri(dibHeader, bitmapBits);
+				ensureWorldTransformGroup(svg, dc, state);
+				trackRect(state, dc, xDest, yDest, Math.abs(cxDest), Math.abs(cyDest));
+				svg.image(xDest, yDest, Math.abs(cxDest), Math.abs(cyDest), dataUri);
+			}
+			break;
+		}
+		case 76: {
+			readBoundsRect(reader);
+			const xDest = reader.readInt32();
+			const yDest = reader.readInt32();
+			const cxDest = reader.readInt32();
+			const cyDest = reader.readInt32();
+			const dwRop = reader.readUint32();
+			reader.skip(4);
+			reader.skip(4);
+			reader.skip(24);
+			reader.skip(4);
+			reader.skip(4);
+			const offBmiSrc = reader.readUint32();
+			const cbBmiSrc = reader.readUint32();
+			const offBitsSrc = reader.readUint32();
+			const cbBitsSrc = reader.readUint32();
+			if (cbBmiSrc > 0 && cbBitsSrc > 0) {
+				const recordStart = dataStart - 8;
+				reader.seek(recordStart + offBmiSrc);
+				const dibHeader = reader.readSlice(cbBmiSrc);
+				reader.seek(recordStart + offBitsSrc);
+				const bitmapBits = reader.readSlice(cbBitsSrc);
+				const format = detectEmbeddedFormat(bitmapBits);
+				let dataUri;
+				if (format === "png" || format === "jpeg") dataUri = rawImageToDataUri(bitmapBits);
+				else dataUri = dibToDataUri(dibHeader, bitmapBits);
+				ensureWorldTransformGroup(svg, dc, state);
+				svg.image(xDest, yDest, Math.abs(cxDest), Math.abs(cyDest), dataUri);
+			} else if (dwRop === ROP_PATCOPY$1 && cxDest !== 0 && cyDest !== 0) {
+				ensureWorldTransformGroup(svg, dc, state);
+				trackRect(state, dc, xDest, yDest, Math.abs(cxDest), Math.abs(cyDest));
+				svg.rect(xDest, yDest, Math.abs(cxDest), Math.abs(cyDest), dc.getFillStyle(), {
+					enabled: false,
+					color: dc.state.pen.color,
+					penStyle: PenStyle.PS_NULL,
+					width: 0
+				});
+			}
+			break;
+		}
+		case 15:
+		case 26:
+		case 28:
+		case 29:
+		case 31:
+		case 32:
+		case 75:
+		case 71:
+		case 72:
+		case 74:
+		case 73:
+		case 53:
+		case 56:
+		case 92:
+		case 7:
+		case 90:
+		case 77:
+		case 78:
+		case 79:
+		case 80:
+		case 83:
+		case 93:
+		case 94:
+		case 96:
+		case 97:
+		case 108: break;
+		case 118: {
+			readBoundsRect(reader);
+			const nTriVert = reader.readUint32();
+			const nGradObj = reader.readUint32();
+			const ulMode = reader.readUint32();
+			const vertices = [];
+			for (let i = 0; i < nTriVert; i++) {
+				const x = reader.readInt32();
+				const y = reader.readInt32();
+				const r = reader.readUint16() >> 8;
+				const g = reader.readUint16() >> 8;
+				const b = reader.readUint16() >> 8;
+				const a = reader.readUint16() >> 8;
+				vertices.push({
+					x,
+					y,
+					r,
+					g,
+					b,
+					a
+				});
+			}
+			ensureWorldTransformGroup(svg, dc, state);
+			if (ulMode === 0 || ulMode === 1) for (let i = 0; i < nGradObj; i++) {
+				const ul = reader.readUint32();
+				const lr = reader.readUint32();
+				const v0 = vertices[ul];
+				const v1 = vertices[lr];
+				if (!v0 || !v1) continue;
+				const c0 = `rgb(${v0.r},${v0.g},${v0.b})`;
+				const c1 = `rgb(${v1.r},${v1.g},${v1.b})`;
+				const x1 = v0.x;
+				const y1 = v0.y;
+				const x2 = ulMode === 0 ? v1.x : v0.x;
+				const y2 = ulMode === 0 ? v0.y : v1.y;
+				const gradId = svg.addLinearGradient(x1, y1, x2, y2, [{
+					offset: 0,
+					color: c0
+				}, {
+					offset: 1,
+					color: c1
+				}]);
+				const rx = Math.min(v0.x, v1.x);
+				const ry = Math.min(v0.y, v1.y);
+				const rw = Math.abs(v1.x - v0.x);
+				const rh = Math.abs(v1.y - v0.y);
+				trackRect(state, dc, rx, ry, rw, rh);
+				svg.gradientRect(rx, ry, rw, rh, gradId);
+			}
+			else if (ulMode === 2) for (let i = 0; i < nGradObj; i++) {
+				const i0 = reader.readUint32();
+				const i1 = reader.readUint32();
+				const i2 = reader.readUint32();
+				const v0 = vertices[i0];
+				const v1 = vertices[i1];
+				const v2 = vertices[i2];
+				if (!v0 || !v1 || !v2) continue;
+				const ar = Math.round((v0.r + v1.r + v2.r) / 3);
+				const ag = Math.round((v0.g + v1.g + v2.g) / 3);
+				const ab = Math.round((v0.b + v1.b + v2.b) / 3);
+				const pts = `${v0.x},${v0.y} ${v1.x},${v1.y} ${v2.x},${v2.y}`;
+				trackPoint(state, dc, v0.x, v0.y);
+				trackPoint(state, dc, v1.x, v1.y);
+				trackPoint(state, dc, v2.x, v2.y);
+				svg.gradientPolygon(pts, `rgb(${ar},${ag},${ab})`);
+			}
+			break;
+		}
+		case 114: {
+			readBoundsRect(reader);
+			const xDest = reader.readInt32();
+			const yDest = reader.readInt32();
+			const cxDest = reader.readInt32();
+			const cyDest = reader.readInt32();
+			reader.readUint8();
+			reader.readUint8();
+			const srcConstantAlpha = reader.readUint8();
+			reader.readUint8();
+			reader.skip(4);
+			reader.skip(4);
+			reader.skip(24);
+			reader.skip(4);
+			reader.skip(4);
+			const offBmiSrc = reader.readUint32();
+			const cbBmiSrc = reader.readUint32();
+			const offBitsSrc = reader.readUint32();
+			const cbBitsSrc = reader.readUint32();
+			if (cbBmiSrc > 0 && cbBitsSrc > 0) {
+				const recordStart = dataStart - 8;
+				reader.seek(recordStart + offBmiSrc);
+				const dibHeader = reader.readSlice(cbBmiSrc);
+				reader.seek(recordStart + offBitsSrc);
+				const bitmapBits = reader.readSlice(cbBitsSrc);
+				const format = detectEmbeddedFormat(bitmapBits);
+				let dataUri;
+				if (format === "png" || format === "jpeg") dataUri = rawImageToDataUri(bitmapBits);
+				else dataUri = dibToDataUri(dibHeader, bitmapBits);
+				const opacity = srcConstantAlpha / 255;
+				ensureWorldTransformGroup(svg, dc, state);
+				trackRect(state, dc, xDest, yDest, Math.abs(cxDest), Math.abs(cyDest));
+				svg.imageWithOpacity(xDest, yDest, Math.abs(cxDest), Math.abs(cyDest), dataUri, opacity);
+			}
+			break;
+		}
+		case 116: {
+			readBoundsRect(reader);
+			const xDest = reader.readInt32();
+			const yDest = reader.readInt32();
+			const cxDest = reader.readInt32();
+			const cyDest = reader.readInt32();
+			reader.skip(4);
+			reader.skip(4);
+			reader.skip(4);
+			reader.skip(24);
+			reader.skip(4);
+			reader.skip(4);
+			const offBmiSrc = reader.readUint32();
+			const cbBmiSrc = reader.readUint32();
+			const offBitsSrc = reader.readUint32();
+			const cbBitsSrc = reader.readUint32();
+			if (cbBmiSrc > 0 && cbBitsSrc > 0) {
+				const recordStart = dataStart - 8;
+				reader.seek(recordStart + offBmiSrc);
+				const dibHeader = reader.readSlice(cbBmiSrc);
+				reader.seek(recordStart + offBitsSrc);
+				const bitmapBits = reader.readSlice(cbBitsSrc);
+				const format = detectEmbeddedFormat(bitmapBits);
+				let dataUri;
+				if (format === "png" || format === "jpeg") dataUri = rawImageToDataUri(bitmapBits);
+				else dataUri = dibToDataUri(dibHeader, bitmapBits);
+				ensureWorldTransformGroup(svg, dc, state);
+				trackRect(state, dc, xDest, yDest, Math.abs(cxDest), Math.abs(cyDest));
+				svg.image(xDest, yDest, Math.abs(cxDest), Math.abs(cyDest), dataUri);
+			}
+			break;
+		}
+	}
+}
+function parseHeader(reader) {
+	if (reader.remaining < 88) return null;
+	const startPos = reader.position;
+	const recordType = reader.readUint32();
+	const recordSize = reader.readUint32();
+	if (recordType !== 1) return null;
+	const boundsLeft = reader.readInt32();
+	const boundsTop = reader.readInt32();
+	const boundsRight = reader.readInt32();
+	const boundsBottom = reader.readInt32();
+	const frameLeft = reader.readInt32();
+	const frameTop = reader.readInt32();
+	const frameRight = reader.readInt32();
+	const frameBottom = reader.readInt32();
+	const signature = reader.readUint32();
+	if (signature !== 1179469088) return null;
+	const version = reader.readUint32();
+	reader.readUint32();
+	const numRecords = reader.readUint32();
+	const numHandles = reader.readUint16();
+	reader.readUint16();
+	const descriptionLen = reader.readUint32();
+	const descriptionOff = reader.readUint32();
+	const nPalEntries = reader.readUint32();
+	const deviceWidth = reader.readInt32();
+	const deviceHeight = reader.readInt32();
+	const deviceWidthMm = reader.readInt32();
+	const deviceHeightMm = reader.readInt32();
+	let description = "";
+	if (descriptionLen > 0 && descriptionOff > 0) {
+		const savedPos = reader.position;
+		reader.seek(startPos + descriptionOff);
+		description = reader.readUtf16String(descriptionLen);
+		reader.seek(savedPos);
+	}
+	let pixelFormatSize = 0;
+	let pixelFormatOff = 0;
+	let hasOpenGl = false;
+	let deviceWidthUm = 0;
+	let deviceHeightUm = 0;
+	if (recordSize >= 100) {
+		reader.seek(startPos + 88);
+		pixelFormatSize = reader.readUint32();
+		pixelFormatOff = reader.readUint32();
+		hasOpenGl = reader.readUint32() !== 0;
+	}
+	if (recordSize >= 108) {
+		deviceWidthUm = reader.readUint32();
+		deviceHeightUm = reader.readUint32();
+	}
+	return {
+		bounds: {
+			left: boundsLeft,
+			top: boundsTop,
+			right: boundsRight,
+			bottom: boundsBottom
+		},
+		frame: {
+			left: frameLeft,
+			top: frameTop,
+			right: frameRight,
+			bottom: frameBottom
+		},
+		signature,
+		version,
+		size: recordSize,
+		numRecords,
+		numHandles,
+		description,
+		nPalEntries,
+		deviceWidth,
+		deviceHeight,
+		deviceWidthMm,
+		deviceHeightMm,
+		pixelFormatSize,
+		pixelFormatOff,
+		hasOpenGl,
+		deviceWidthUm,
+		deviceHeightUm
+	};
+}
+function readColorRef(reader) {
+	const r = reader.readUint8();
+	const g = reader.readUint8();
+	const b = reader.readUint8();
+	const a = reader.readUint8();
+	return {
+		r,
+		g,
+		b,
+		a: a === 0 ? 255 : a
+	};
+}
+function readXForm(reader) {
+	return [
+		reader.readFloat32(),
+		reader.readFloat32(),
+		reader.readFloat32(),
+		reader.readFloat32(),
+		reader.readFloat32(),
+		reader.readFloat32()
+	];
+}
+function readBoundsRect(reader) {
+	return {
+		left: reader.readInt32(),
+		top: reader.readInt32(),
+		right: reader.readInt32(),
+		bottom: reader.readInt32()
+	};
+}
+function readPoints16(reader, count) {
+	const points = [];
+	for (let i = 0; i < count; i++) {
+		const x = reader.readInt16();
+		const y = reader.readInt16();
+		points.push({
+			x,
+			y
+		});
+	}
+	return points;
+}
+function readPoints32(reader, count) {
+	const points = [];
+	for (let i = 0; i < count; i++) {
+		const x = reader.readInt32();
+		const y = reader.readInt32();
+		points.push({
+			x,
+			y
+		});
+	}
+	return points;
+}
+function emitLine(svg, dc, x1, y1, x2, y2) {
+	const d = `M${x1},${y1}L${x2},${y2}`;
+	svg.path(d, {
+		enabled: false,
+		color: {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		},
+		brushStyle: 1
+	}, dc.getStrokeStyle());
+}
+function polygonToPathData(points) {
+	if (points.length === 0) return "";
+	let d = `M${points[0].x},${points[0].y}`;
+	for (let i = 1; i < points.length; i++) d += `L${points[i].x},${points[i].y}`;
+	d += "Z";
+	return d;
+}
+function polylineToPathData(points) {
+	if (points.length === 0) return "";
+	let d = `M${points[0].x},${points[0].y}`;
+	for (let i = 1; i < points.length; i++) d += `L${points[i].x},${points[i].y}`;
+	return d;
+}
+function polyBezierToPathData(points) {
+	if (points.length < 4) return "";
+	let d = `M${points[0].x},${points[0].y}`;
+	for (let i = 1; i + 2 < points.length; i += 3) d += `C${points[i].x},${points[i].y},${points[i + 1].x},${points[i + 1].y},${points[i + 2].x},${points[i + 2].y}`;
+	return d;
+}
+function addPolygonToPath(builder, points) {
+	if (points.length === 0) return;
+	builder.moveTo(points[0].x, points[0].y);
+	for (let i = 1; i < points.length; i++) builder.lineTo(points[i].x, points[i].y);
+	builder.closePath();
+}
+function addPolylineToPath(builder, points) {
+	if (points.length === 0) return;
+	builder.moveTo(points[0].x, points[0].y);
+	for (let i = 1; i < points.length; i++) builder.lineTo(points[i].x, points[i].y);
+}
+function addPolyBezierToPath(builder, points) {
+	if (points.length < 4) return;
+	builder.moveTo(points[0].x, points[0].y);
+	for (let i = 1; i + 2 < points.length; i += 3) builder.curveTo(points[i].x, points[i].y, points[i + 1].x, points[i + 1].y, points[i + 2].x, points[i + 2].y);
+}
+/** Approximate an ellipse with 4 cubic bezier curves */
+function approximateEllipse(builder, cx, cy, rx, ry) {
+	const k = .5522847498;
+	const kx = rx * k;
+	const ky = ry * k;
+	builder.moveTo(cx + rx, cy);
+	builder.curveTo(cx + rx, cy + ky, cx + kx, cy + ry, cx, cy + ry);
+	builder.curveTo(cx - kx, cy + ry, cx - rx, cy + ky, cx - rx, cy);
+	builder.curveTo(cx - rx, cy - ky, cx - kx, cy - ry, cx, cy - ry);
+	builder.curveTo(cx + kx, cy - ry, cx + rx, cy - ky, cx + rx, cy);
+	builder.closePath();
+}
+/** Build SVG path data for a rounded rectangle */
+function roundedRectPath(x, y, w, h, rx, ry) {
+	const r = Math.min(rx, w / 2);
+	const rv = Math.min(ry, h / 2);
+	return `M${x + r},${y}L${x + w - r},${y}Q${x + w},${y},${x + w},${y + rv}L${x + w},${y + h - rv}Q${x + w},${y + h},${x + w - r},${y + h}L${x + r},${y + h}Q${x},${y + h},${x},${y + h - rv}L${x},${y + rv}Q${x},${y},${x + r},${y}Z`;
+}
+/** Format a number for SVG: up to 2 decimal places, no trailing zeros */
+function fmtN(n) {
+	return Number(n.toFixed(2)).toString();
+}
+/**
+* Compute the intersection of a ray from (cx,cy) through (px,py) with an ellipse
+* centered at (cx,cy) with semi-axes rx, ry.
+*/
+function intersectEllipseRay(cx, cy, rx, ry, px, py) {
+	const dx = px - cx;
+	const dy = py - cy;
+	if (dx === 0 && dy === 0) return {
+		x: cx + rx,
+		y: cy,
+		angle: 0
+	};
+	const t = 1 / Math.sqrt((dx / rx) ** 2 + (dy / ry) ** 2);
+	const hitX = cx + dx * t;
+	const hitY = cy + dy * t;
+	return {
+		x: hitX,
+		y: hitY,
+		angle: Math.atan2(hitY - cy, hitX - cx)
+	};
+}
+/**
+* Compute SVG arc flags from start/end angles and arc direction.
+* Y-down coordinate system: atan2 angle increasing = screen clockwise.
+*/
+function computeArcFlags(startAngle, endAngle, arcDir) {
+	const sweepFlag = arcDir === 2 ? 1 : 0;
+	let span;
+	if (sweepFlag === 1) {
+		span = endAngle - startAngle;
+		if (span <= 0) span += 2 * Math.PI;
+	} else {
+		span = startAngle - endAngle;
+		if (span <= 0) span += 2 * Math.PI;
+	}
+	return {
+		largeArc: span > Math.PI ? 1 : 0,
+		sweepFlag
+	};
+}
+/**
+* Build SVG path data for Arc/Chord/Pie shapes.
+* Returns null for degenerate (zero-size) cases.
+*/
+function buildArcPath(left, top, right, bottom, startPtX, startPtY, endPtX, endPtY, arcDir, kind) {
+	const rx = (right - left) / 2;
+	const ry = (bottom - top) / 2;
+	if (rx <= 0 || ry <= 0) return null;
+	const cx = left + rx;
+	const cy = top + ry;
+	const start = intersectEllipseRay(cx, cy, rx, ry, startPtX, startPtY);
+	const end = intersectEllipseRay(cx, cy, rx, ry, endPtX, endPtY);
+	const { largeArc, sweepFlag } = computeArcFlags(start.angle, end.angle, arcDir);
+	let d;
+	if (kind === "pie") d = `M${fmtN(cx)},${fmtN(cy)}L${fmtN(start.x)},${fmtN(start.y)}A${fmtN(rx)},${fmtN(ry)},0,${largeArc},${sweepFlag},${fmtN(end.x)},${fmtN(end.y)}Z`;
+	else if (kind === "chord") d = `M${fmtN(start.x)},${fmtN(start.y)}A${fmtN(rx)},${fmtN(ry)},0,${largeArc},${sweepFlag},${fmtN(end.x)},${fmtN(end.y)}Z`;
+	else d = `M${fmtN(start.x)},${fmtN(start.y)}A${fmtN(rx)},${fmtN(ry)},0,${largeArc},${sweepFlag},${fmtN(end.x)},${fmtN(end.y)}`;
+	return {
+		d,
+		startX: start.x,
+		startY: start.y,
+		endX: end.x,
+		endY: end.y,
+		rx,
+		ry,
+		largeArc,
+		sweep: sweepFlag
+	};
+}
+/** Add arc geometry to a PathBuilder (for path recording mode). */
+function addArcToPathBuilder(pb, arc, _arcDir, kind) {
+	pb.moveTo(arc.startX, arc.startY);
+	pb.arcTo(arc.rx, arc.ry, 0, arc.largeArc, arc.sweep, arc.endX, arc.endY);
+	if (kind === "chord" || kind === "pie") pb.closePath();
+}
+//#endregion
+//#region src/wmf-parser.ts
+const PLACEABLE_KEY = 2596720087;
+const META_EOF = 0;
+const META_SETTEXTCOLOR = 521;
+const META_SETWINDOWORG = 523;
+const META_SETWINDOWEXT = 524;
+const META_MOVETO = 532;
+const META_LINETO = 531;
+const META_POLYGON = 804;
+const META_POLYLINE = 805;
+const META_ELLIPSE = 1048;
+const META_RECTANGLE = 1051;
+const META_SELECTOBJECT = 301;
+const META_SETTEXTALIGN = 302;
+const META_ESCAPE = 1574;
+const META_TEXTOUT = 1313;
+const META_EXTTEXTOUT = 2610;
+const META_ROUNDRECT = 1564;
+const META_PATBLT = 1565;
+const META_POLYPOLYGON = 1336;
+const META_CREATEPENINDIRECT = 762;
+const META_CREATEFONTINDIRECT = 763;
+const META_CREATEBRUSHINDIRECT = 764;
+const META_DELETEOBJECT = 496;
+const ROP_PATCOPY = 15728673;
+const TA_UPDATECP = 1;
+var WmfReader = class {
+	constructor(buffer) {
+		this.pos = 0;
+		this.view = buffer instanceof Uint8Array ? new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength) : new DataView(buffer);
+	}
+	get length() {
+		return this.view.byteLength;
+	}
+	get remaining() {
+		return this.length - this.pos;
+	}
+	seek(pos) {
+		if (pos < 0 || pos > this.length) throw new Error("Invalid WMF seek");
+		this.pos = pos;
+	}
+	readUint16() {
+		const value = this.view.getUint16(this.pos, true);
+		this.pos += 2;
+		return value;
+	}
+	readInt16() {
+		const value = this.view.getInt16(this.pos, true);
+		this.pos += 2;
+		return value;
+	}
+	readUint32() {
+		const value = this.view.getUint32(this.pos, true);
+		this.pos += 4;
+		return value;
+	}
+	uint32At(pos) {
+		return pos + 4 <= this.length ? this.view.getUint32(pos, true) : 0;
+	}
+	bytesAt(start, end) {
+		const safeStart = Math.max(0, Math.min(start, this.length));
+		const safeEnd = Math.max(safeStart, Math.min(end, this.length));
+		const bytes = new Uint8Array(safeEnd - safeStart);
+		for (let i = 0; i < bytes.length; i++) bytes[i] = this.view.getUint8(safeStart + i);
+		return bytes;
+	}
+};
+function isWmf$1(buffer) {
+	const reader = new WmfReader(buffer);
+	if (reader.length < 18) return false;
+	const start = reader.uint32At(0) === PLACEABLE_KEY ? 22 : 0;
+	if (reader.length < start + 18) return false;
+	reader.seek(start);
+	const fileType = reader.readUint16();
+	const headerSizeWords = reader.readUint16();
+	const version = reader.readUint16();
+	return (fileType === 1 || fileType === 2) && headerSizeWords === 9 && version >= 256;
+}
+function wmf2svg$1(buffer) {
+	const reader = new WmfReader(buffer);
+	if (!isWmf$1(buffer)) throw new Error("Invalid WMF file");
+	const hasPlaceable = reader.uint32At(0) === PLACEABLE_KEY;
+	const placeable = hasPlaceable ? readPlaceableHeader(reader) : void 0;
+	const headerStart = hasPlaceable ? 22 : 0;
+	reader.seek(headerStart);
+	reader.seek(headerStart + 18);
+	const state = {
+		windowX: placeable?.left ?? 0,
+		windowY: placeable?.top ?? 0,
+		windowW: Math.max((placeable?.right ?? 1e3) - (placeable?.left ?? 0), 1),
+		windowH: Math.max((placeable?.bottom ?? 1e3) - (placeable?.top ?? 0), 1),
+		canvasX: placeable?.left ?? 0,
+		canvasY: placeable?.top ?? 0,
+		canvasW: Math.max((placeable?.right ?? 1e3) - (placeable?.left ?? 0), 1),
+		canvasH: Math.max((placeable?.bottom ?? 1e3) - (placeable?.top ?? 0), 1),
+		drawingStarted: false,
+		currentX: 0,
+		currentY: 0,
+		pen: {
+			type: "pen",
+			style: PenStyle.PS_SOLID,
+			color: {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 255
+			},
+			width: 1
+		},
+		brush: {
+			type: "brush",
+			style: 0,
+			color: {
+				r: 255,
+				g: 255,
+				b: 255,
+				a: 255
+			}
+		},
+		font: {
+			type: "font",
+			style: 0,
+			color: {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 255
+			}
+		},
+		textColor: {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 255
+		},
+		textAlignUpdateCP: false,
+		textAlignBaseline: false,
+		mathTypeLeftInset: 0,
+		objects: [],
+		parts: []
+	};
+	while (reader.remaining >= 6) {
+		const recordStart = reader.pos;
+		const sizeWords = reader.readUint32();
+		const fn = reader.readUint16();
+		const recordBytes = sizeWords * 2;
+		if (recordBytes < 6 || recordStart + recordBytes > reader.length) break;
+		const record = reader.bytesAt(recordStart, recordStart + recordBytes);
+		processRecord(fn, readParams(reader, recordStart + recordBytes), state, record);
+		reader.seek(recordStart + recordBytes);
+		if (fn === META_EOF) break;
+	}
+	const viewTop = Math.min(state.canvasY, state.textMinY ?? state.canvasY);
+	const viewBottom = state.canvasY + state.canvasH;
+	const viewX = state.canvasX - state.mathTypeLeftInset;
+	const viewW = state.canvasW + state.mathTypeLeftInset;
+	return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${fmt(viewX)} ${fmt(viewTop)} ${fmt(viewW)} ${fmt(viewBottom - viewTop)}">${state.parts.join("")}</svg>`;
+}
+function readPlaceableHeader(reader) {
+	reader.seek(6);
+	return {
+		left: reader.readInt16(),
+		top: reader.readInt16(),
+		right: reader.readInt16(),
+		bottom: reader.readInt16()
+	};
+}
+function readParams(reader, end) {
+	const params = [];
+	while (reader.pos + 2 <= end) params.push(reader.readInt16());
+	return params;
+}
+function processRecord(fn, p, state, record) {
+	switch (fn) {
+		case META_SETTEXTCOLOR:
+			if (p.length >= 2) state.textColor = colorRef(p[0], p[1]);
+			break;
+		case META_SETWINDOWORG:
+			if (p.length >= 2) {
+				state.windowX = p[1];
+				state.windowY = p[0];
+				syncCanvasWindow(state);
+			}
+			break;
+		case META_SETWINDOWEXT:
+			if (p.length >= 2) {
+				state.windowW = Math.max(Math.abs(p[1]), 1);
+				state.windowH = Math.max(Math.abs(p[0]), 1);
+				syncCanvasWindow(state);
+			}
+			break;
+		case META_MOVETO:
+			if (p.length >= 2) {
+				state.currentX = p[1];
+				state.currentY = p[0];
+			}
+			break;
+		case META_SETTEXTALIGN:
+			if (p.length >= 1) {
+				state.textAlignUpdateCP = (p[0] & TA_UPDATECP) === TA_UPDATECP;
+				state.textAlignBaseline = (p[0] & 24) === 24;
+			}
+			break;
+		case META_ESCAPE:
+			readEscapeRecord(p, state);
+			break;
+		case META_LINETO:
+			if (p.length >= 2) {
+				const x = p[1];
+				const y = p[0];
+				beginDrawing(state);
+				state.parts.push(`<path d="M${fmt(transformX(state, state.currentX))} ${fmt(transformY(state, state.currentY))} L${fmt(transformX(state, x))} ${fmt(transformY(state, y))}"${strokeAttr(state.pen, state)} fill="none"/>`);
+				state.currentX = x;
+				state.currentY = y;
+			}
+			break;
+		case META_RECTANGLE:
+		case META_ELLIPSE:
+			if (p.length >= 4) {
+				const { left, top, right, bottom } = rectParams(p);
+				beginDrawing(state);
+				if (fn === META_RECTANGLE) state.parts.push(`<rect x="${fmt(transformX(state, left))}" y="${fmt(transformY(state, top))}" width="${fmt(transformWidth(state, right - left))}" height="${fmt(transformHeight(state, bottom - top))}"${fillAttr(state.brush)}${strokeAttr(state.pen, state)}/>`);
+				else state.parts.push(`<ellipse cx="${fmt(transformX(state, (left + right) / 2))}" cy="${fmt(transformY(state, (top + bottom) / 2))}" rx="${fmt(transformWidth(state, (right - left) / 2))}" ry="${fmt(transformHeight(state, (bottom - top) / 2))}"${fillAttr(state.brush)}${strokeAttr(state.pen, state)}/>`);
+			}
+			break;
+		case META_ROUNDRECT:
+			if (p.length >= 6) {
+				const { left, top, right, bottom } = rectParams(p.slice(2));
+				beginDrawing(state);
+				state.parts.push(`<rect x="${fmt(transformX(state, left))}" y="${fmt(transformY(state, top))}" width="${fmt(transformWidth(state, right - left))}" height="${fmt(transformHeight(state, bottom - top))}" rx="${fmt(transformWidth(state, Math.abs(p[1]) / 2))}" ry="${fmt(transformHeight(state, Math.abs(p[0]) / 2))}"${fillAttr(state.brush)}${strokeAttr(state.pen, state)}/>`);
+			}
+			break;
+		case META_PATBLT:
+			drawPatBlt(p, state);
+			break;
+		case META_POLYGON:
+		case META_POLYLINE:
+			drawPoly(fn, p, state);
+			break;
+		case META_POLYPOLYGON:
+			drawPolyPolygon(p, state);
+			break;
+		case META_TEXTOUT:
+			drawTextOut(record, state);
+			break;
+		case META_EXTTEXTOUT:
+			drawExtTextOut(record, state);
+			break;
+		case META_CREATEPENINDIRECT:
+			if (p.length >= 5) addWmfObject(state, {
+				type: "pen",
+				style: p[0],
+				width: Math.max(Math.abs(p[2]), Math.abs(p[1]), 1),
+				color: colorRef(p[3], p[4])
+			});
+			break;
+		case META_CREATEFONTINDIRECT:
+			addWmfObject(state, readFontObject(record));
+			break;
+		case META_CREATEBRUSHINDIRECT:
+			if (p.length >= 4) addWmfObject(state, {
+				type: "brush",
+				style: p[0],
+				color: colorRef(p[1], p[2])
+			});
+			break;
+		case META_SELECTOBJECT: {
+			const obj = state.objects[p[0]];
+			if (obj?.type === "pen") state.pen = obj;
+			if (obj?.type === "brush") state.brush = obj;
+			if (obj?.type === "font") state.font = obj;
+			break;
+		}
+		case META_DELETEOBJECT: state.objects[p[0]] = void 0;
+	}
+}
+function syncCanvasWindow(state) {
+	if (state.drawingStarted) return;
+	state.canvasX = state.windowX;
+	state.canvasY = state.windowY;
+	state.canvasW = state.windowW;
+	state.canvasH = state.windowH;
+}
+function beginDrawing(state) {
+	state.drawingStarted = true;
+}
+function transformX(state, x) {
+	const transform = state.objectTransform;
+	return transform ? transform.dst.left + (x - transform.src.left) * transform.scaleX : x;
+}
+function transformY(state, y) {
+	const transform = state.objectTransform;
+	return transform ? transform.dst.top + (y - transform.src.top) * transform.scaleY : y;
+}
+function transformWidth(state, width) {
+	return Math.abs(width * (state.objectTransform?.scaleX ?? 1));
+}
+function transformHeight(state, height) {
+	return Math.abs(height * (state.objectTransform?.scaleY ?? 1));
+}
+function transformScale(state) {
+	const transform = state.objectTransform;
+	return transform ? (Math.abs(transform.scaleX) + Math.abs(transform.scaleY)) / 2 : 1;
+}
+function transformFontSize(state, fontSize) {
+	return fontSize * transformScale(state);
+}
+function includeTextVerticalBounds(state, y, fontSize) {
+	const top = transformY(state, y) - transformFontSize(state, fontSize);
+	const bottom = transformY(state, y) + transformFontSize(state, fontSize) * .25;
+	state.textMinY = state.textMinY === void 0 ? top : Math.min(state.textMinY, top);
+	state.textMaxY = state.textMaxY === void 0 ? bottom : Math.max(state.textMaxY, bottom);
+}
+function readEscapeRecord(p, state) {
+	if (isOfficeObjectEndEscape(p)) {
+		state.objectTransform = void 0;
+		state.pendingObjectDest = void 0;
+		return;
+	}
+	if (p.length < 8) return;
+	const marker = wordsToAscii(p.slice(2, 6));
+	if (p[0] === 15 && marker === "MathType" && !state.objectTransform) {
+		state.mathTypeLeftInset = Math.max(state.mathTypeLeftInset, p[7] ?? 0);
+		return;
+	}
+	if (isOfficeObjectDestEscape(p)) {
+		state.pendingObjectDest = readOfficeEscapeRect(p, 5);
+		return;
+	}
+	if (isOfficeObjectSourceEscape(p) && state.pendingObjectDest) {
+		const src = readOfficeEscapeRect(p, 7);
+		const dst = state.pendingObjectDest;
+		const srcW = src.right - src.left;
+		const srcH = src.bottom - src.top;
+		if (srcW !== 0 && srcH !== 0) state.objectTransform = {
+			src,
+			dst,
+			scaleX: (dst.right - dst.left) / srcW,
+			scaleY: (dst.bottom - dst.top) / srcH
+		};
+		return;
+	}
+}
+function isOfficeObjectDestEscape(p) {
+	return p.length >= 13 && p[0] === 15 && p[1] === 22 && p[2] === -1 && p[3] === -1 && p[4] === 0;
+}
+function isOfficeObjectSourceEscape(p) {
+	return p.length >= 15 && p[0] === 15 && p[1] === 26 && p[2] === -1 && p[3] === -1 && p[4] === 0;
+}
+function isOfficeObjectEndEscape(p) {
+	return p[0] === 15 && (p[1] === 10 || p[1] === 6) && p[2] === -1 && p[3] === -1 && p[4] === 1;
+}
+function readOfficeEscapeRect(p, start) {
+	return {
+		left: signedLongFromWords(p[start], p[start + 1]),
+		top: signedLongFromWords(p[start + 2], p[start + 3]),
+		right: signedLongFromWords(p[start + 4], p[start + 5]),
+		bottom: signedLongFromWords(p[start + 6], p[start + 7])
+	};
+}
+function signedLongFromWords(lowWord, highWord) {
+	const value = lowWord & 65535 | (highWord & 65535) << 16;
+	return value >= 2147483648 ? value - 4294967296 : value;
+}
+function wordsToAscii(words) {
+	let value = "";
+	for (const word of words) {
+		value += String.fromCharCode(word & 255);
+		const high = word >> 8 & 255;
+		if (high) value += String.fromCharCode(high);
+	}
+	return value;
+}
+function addWmfObject(state, object) {
+	const index = state.objects.findIndex((entry) => entry === void 0);
+	if (index >= 0) state.objects[index] = object;
+	else state.objects.push(object);
+}
+function rectParams(p) {
+	const bottom = p[0];
+	const right = p[1];
+	const top = p[2];
+	const left = p[3];
+	return {
+		left: Math.min(left, right),
+		top: Math.min(top, bottom),
+		right: Math.max(left, right),
+		bottom: Math.max(top, bottom)
+	};
+}
+function drawPoly(fn, p, state) {
+	const count = p[0] ?? 0;
+	if (count <= 0 || p.length < 1 + count * 2) return;
+	const points = [];
+	for (let i = 0; i < count; i++) points.push(`${fmt(transformX(state, p[1 + i * 2]))} ${fmt(transformY(state, p[2 + i * 2]))}`);
+	if (fn === META_POLYGON) {
+		beginDrawing(state);
+		state.parts.push(`<polygon points="${points.join(" ")}"${fillAttr(state.brush)}${strokeAttr(state.pen, state)}/>`);
+	} else {
+		beginDrawing(state);
+		state.parts.push(`<polyline points="${points.join(" ")}"${strokeAttr(state.pen, state)} fill="none"/>`);
+	}
+}
+function drawPatBlt(p, state) {
+	if (p.length < 6) return;
+	if (unsignedLongFromWords(p[0], p[1]) !== ROP_PATCOPY) return;
+	const height = Math.abs(p[2]);
+	const width = Math.abs(p[3]);
+	const y = p[4];
+	const x = p[5];
+	if (width === 0 || height === 0) return;
+	beginDrawing(state);
+	state.parts.push(`<rect x="${fmt(transformX(state, x))}" y="${fmt(transformY(state, y))}" width="${fmt(transformWidth(state, width))}" height="${fmt(transformHeight(state, height))}"${fillAttr(state.brush)}/>`);
+}
+function unsignedLongFromWords(lowWord, highWord) {
+	return (lowWord & 65535 | (highWord & 65535) << 16) >>> 0;
+}
+function drawPolyPolygon(p, state) {
+	const polygonCount = p[0] ?? 0;
+	if (polygonCount <= 0 || p.length < 1 + polygonCount) return;
+	let offset = 1 + polygonCount;
+	for (let polygonIndex = 0; polygonIndex < polygonCount; polygonIndex++) {
+		const pointCount = p[1 + polygonIndex] ?? 0;
+		if (pointCount <= 0 || p.length < offset + pointCount * 2) return;
+		const points = [];
+		for (let i = 0; i < pointCount; i++) points.push(`${fmt(transformX(state, p[offset + i * 2]))} ${fmt(transformY(state, p[offset + i * 2 + 1]))}`);
+		beginDrawing(state);
+		state.parts.push(`<polygon points="${points.join(" ")}"${fillAttr(state.brush)}${strokeAttr(state.pen, state)}/>`);
+		offset += pointCount * 2;
+	}
+}
+function drawTextOut(record, state) {
+	if (record.length < 12) return;
+	const length = int16At(record, 6);
+	if (length <= 0) return;
+	const textStart = 8;
+	const textEnd = Math.min(textStart + length, record.length);
+	const coordOffset = textStart + length + length % 2;
+	if (coordOffset + 4 > record.length) return;
+	const y = int16At(record, coordOffset);
+	const point = resolveTextPoint(state, int16At(record, coordOffset + 2), y);
+	const textInfo = decodeWmfText(record.subarray(textStart, textEnd), state.font);
+	drawText(state, point.x, point.y, textInfo.text);
+	updateTextCurrentPosition(state, point.x, point.y, textInfo.text);
+}
+function drawExtTextOut(record, state) {
+	if (record.length < 14) return;
+	const y = int16At(record, 6);
+	const x = int16At(record, 8);
+	const length = int16At(record, 10);
+	const opts = uint16At(record, 12);
+	if (length <= 0) return;
+	const textStart = 14 + (opts & 6 ? 8 : 0);
+	const textEnd = Math.min(textStart + length, record.length);
+	if (textStart >= record.length) return;
+	const point = resolveTextPoint(state, x, y);
+	const textInfo = decodeWmfText(record.subarray(textStart, textEnd), state.font);
+	const dx = readTextDx(record, textStart + length + length % 2, textInfo);
+	drawText(state, point.x, point.y, textInfo.text, dx);
+	updateTextCurrentPosition(state, point.x, point.y, textInfo.text, dx);
+}
+function resolveTextPoint(state, x, y) {
+	if (state.textAlignUpdateCP && x === 0 && y === 0) return {
+		x: state.currentX,
+		y: state.currentY
+	};
+	return {
+		x,
+		y
+	};
+}
+function readTextDx(record, offset, textInfo) {
+	const charCount = textInfo.byteLengths.length;
+	if (charCount <= 0) return void 0;
+	const byteCount = textInfo.byteLengths.reduce((sum, length) => sum + length, 0);
+	if (byteCount > charCount && offset + byteCount * 2 <= record.length) {
+		const rawDx = [];
+		for (let i = 0; i < byteCount; i++) rawDx.push(uint16At(record, offset + i * 2));
+		const dx = [];
+		let rawIndex = 0;
+		for (const byteLength of textInfo.byteLengths) {
+			let advance = 0;
+			for (let i = 0; i < byteLength; i++) advance += rawDx[rawIndex++] ?? 0;
+			dx.push(advance);
+		}
+		return dx;
+	}
+	if (offset + charCount * 2 > record.length) return void 0;
+	const dx = [];
+	for (let i = 0; i < charCount; i++) dx.push(uint16At(record, offset + i * 2));
+	return dx;
+}
+function updateTextCurrentPosition(state, x, y, value, dx) {
+	if (!state.textAlignUpdateCP) return;
+	const chars = Array.from(value);
+	state.currentX = x + (dx?.length ? dx.slice(0, chars.length).reduce((sum, item) => sum + item, 0) : estimateWmfTextWidth(state, chars));
+	state.currentY = y;
+}
+function estimateWmfTextWidth(state, chars) {
+	const fontSize = state.font.height || Math.max(Math.min(state.windowH, state.windowW) * .04, 1);
+	return chars.reduce((sum, char) => sum + (char.codePointAt(0) > 255 ? fontSize : fontSize * .62), 0);
+}
+function drawText(state, x, y, value, dx) {
+	const text = escapeXml(value);
+	if (!text) return;
+	const fontSize = state.font.height || Math.max(Math.min(state.windowH, state.windowW) * .04, 1);
+	const fontAttrs = textFontAttrs(state.font);
+	const baselineAttrs = textBaselineAttrs(state);
+	const chars = Array.from(value);
+	const vectorizeMathDelimiters = isSymbolFont(state.font);
+	if (dx && chars.length > 1 || vectorizeMathDelimiters && chars.some(isVectorMathDelimiterPiece)) {
+		let cursorX = x;
+		for (let i = 0; i < chars.length; i++) {
+			drawTextChar(state, cursorX, y, chars[i], fontSize, fontAttrs, vectorizeMathDelimiters);
+			cursorX += dx?.[i] ?? estimateWmfTextWidth(state, [chars[i]]);
+		}
+		return;
+	}
+	beginDrawing(state);
+	includeTextVerticalBounds(state, y, fontSize);
+	state.parts.push(`<text x="${fmt(transformX(state, x))}" y="${fmt(transformY(state, y))}" fill="${color(state.textColor)}" font-size="${fmt(transformFontSize(state, fontSize))}"${fontAttrs}${baselineAttrs}>${text}</text>`);
+}
+function drawTextChar(state, x, y, char, fontSize, fontAttrs, vectorizeMathDelimiters) {
+	if (vectorizeMathDelimiters && drawVectorMathDelimiterPiece(state, x, y, char, fontSize)) return;
+	const text = escapeXml(char);
+	if (!text) return;
+	beginDrawing(state);
+	includeTextVerticalBounds(state, y, fontSize);
+	state.parts.push(`<text x="${fmt(transformX(state, x))}" y="${fmt(transformY(state, y))}" fill="${color(state.textColor)}" font-size="${fmt(transformFontSize(state, fontSize))}"${fontAttrs}${textBaselineAttrs(state)}>${text}</text>`);
+}
+function isVectorMathDelimiterPiece(char) {
+	return "⎛⎜⎝⎞⎟⎠⎡⎢⎣⎤⎥⎦⎧⎨⎩⎪⎫⎬⎭".includes(char);
+}
+function drawVectorMathDelimiterPiece(state, x, y, char, fontSize) {
+	if (!isVectorMathDelimiterPiece(char)) return false;
+	const transformedX = transformX(state, x);
+	const transformedY = transformY(state, y);
+	const transformedFontSize = transformFontSize(state, fontSize);
+	const top = transformedY - transformedFontSize * .84;
+	const bottom = transformedY + transformedFontSize * .12;
+	const mid = (top + bottom) / 2;
+	const width = transformedFontSize * (char === "⎧" || char === "⎨" || char === "⎩" || char === "⎫" || char === "⎬" || char === "⎭" ? .34 : .28);
+	const strokeWidth = Math.max(transformedFontSize * .052, 1);
+	const path = mathDelimiterPiecePath(char, transformedX, top, mid, bottom, width);
+	if (!path) return false;
+	beginDrawing(state);
+	state.textMinY = state.textMinY === void 0 ? top : Math.min(state.textMinY, top);
+	state.textMaxY = state.textMaxY === void 0 ? bottom : Math.max(state.textMaxY, bottom);
+	state.parts.push(`<path d="${path}" fill="none" stroke="${color(state.textColor)}" stroke-width="${fmt(strokeWidth)}" stroke-linecap="round" stroke-linejoin="round"/>`);
+	return true;
+}
+function mathDelimiterPiecePath(char, x, top, mid, bottom, width) {
+	const left = x;
+	const right = x + width;
+	const nearLeft = x + width * .08;
+	const nearRight = x + width * .92;
+	const center = x + width * .5;
+	switch (char) {
+		case "⎛": return pathData([
+			"M",
+			right,
+			top,
+			"C",
+			center,
+			top,
+			nearLeft,
+			mid,
+			nearLeft,
+			bottom
+		]);
+		case "⎜": return pathData([
+			"M",
+			nearLeft,
+			top,
+			"L",
+			nearLeft,
+			bottom
+		]);
+		case "⎝": return pathData([
+			"M",
+			nearLeft,
+			top,
+			"C",
+			nearLeft,
+			mid,
+			center,
+			bottom,
+			right,
+			bottom
+		]);
+		case "⎞": return pathData([
+			"M",
+			left,
+			top,
+			"C",
+			center,
+			top,
+			nearRight,
+			mid,
+			nearRight,
+			bottom
+		]);
+		case "⎟": return pathData([
+			"M",
+			nearRight,
+			top,
+			"L",
+			nearRight,
+			bottom
+		]);
+		case "⎠": return pathData([
+			"M",
+			nearRight,
+			top,
+			"C",
+			nearRight,
+			mid,
+			center,
+			bottom,
+			left,
+			bottom
+		]);
+		case "⎡": return pathData([
+			"M",
+			right,
+			top,
+			"L",
+			nearLeft,
+			top,
+			"L",
+			nearLeft,
+			bottom
+		]);
+		case "⎢": return pathData([
+			"M",
+			nearLeft,
+			top,
+			"L",
+			nearLeft,
+			bottom
+		]);
+		case "⎣": return pathData([
+			"M",
+			nearLeft,
+			top,
+			"L",
+			nearLeft,
+			bottom,
+			"L",
+			right,
+			bottom
+		]);
+		case "⎤": return pathData([
+			"M",
+			left,
+			top,
+			"L",
+			nearRight,
+			top,
+			"L",
+			nearRight,
+			bottom
+		]);
+		case "⎥": return pathData([
+			"M",
+			nearRight,
+			top,
+			"L",
+			nearRight,
+			bottom
+		]);
+		case "⎦": return pathData([
+			"M",
+			nearRight,
+			top,
+			"L",
+			nearRight,
+			bottom,
+			"L",
+			left,
+			bottom
+		]);
+		case "⎧": return pathData([
+			"M",
+			right,
+			top,
+			"C",
+			center,
+			top,
+			center,
+			mid,
+			nearLeft,
+			mid,
+			"C",
+			center,
+			mid,
+			center,
+			bottom,
+			right,
+			bottom
+		]);
+		case "⎨": return pathData([
+			"M",
+			right,
+			top,
+			"C",
+			center,
+			top,
+			center,
+			mid,
+			nearLeft,
+			mid,
+			"C",
+			center,
+			mid,
+			center,
+			bottom,
+			right,
+			bottom
+		]);
+		case "⎩": return pathData([
+			"M",
+			right,
+			top,
+			"C",
+			center,
+			top,
+			center,
+			mid,
+			nearLeft,
+			mid,
+			"C",
+			center,
+			mid,
+			center,
+			bottom,
+			right,
+			bottom
+		]);
+		case "⎪": return pathData([
+			"M",
+			nearLeft,
+			top,
+			"L",
+			nearLeft,
+			bottom
+		]);
+		case "⎫": return pathData([
+			"M",
+			left,
+			top,
+			"C",
+			center,
+			top,
+			center,
+			mid,
+			nearRight,
+			mid,
+			"C",
+			center,
+			mid,
+			center,
+			bottom,
+			left,
+			bottom
+		]);
+		case "⎬": return pathData([
+			"M",
+			left,
+			top,
+			"C",
+			center,
+			top,
+			center,
+			mid,
+			nearRight,
+			mid,
+			"C",
+			center,
+			mid,
+			center,
+			bottom,
+			left,
+			bottom
+		]);
+		case "⎭": return pathData([
+			"M",
+			left,
+			top,
+			"C",
+			center,
+			top,
+			center,
+			mid,
+			nearRight,
+			mid,
+			"C",
+			center,
+			mid,
+			center,
+			bottom,
+			left,
+			bottom
+		]);
+		default: return;
+	}
+}
+function pathData(parts) {
+	return parts.map((part) => typeof part === "number" ? fmt(part) : part).join(" ");
+}
+function readFontObject(record) {
+	const charset = record[19];
+	return {
+		type: "font",
+		style: 0,
+		color: {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 255
+		},
+		height: Math.abs(int16At(record, 6)),
+		weight: int16At(record, 14),
+		italic: record[16] !== 0,
+		charset,
+		faceName: readNullTerminatedAnsi(record, 24, charset)
+	};
+}
+function int16At(bytes, offset) {
+	const value = uint16At(bytes, offset);
+	return value >= 32768 ? value - 65536 : value;
+}
+function uint16At(bytes, offset) {
+	if (offset + 2 > bytes.length) return 0;
+	return bytes[offset] | bytes[offset + 1] << 8;
+}
+function decodeWmfText(bytes, font) {
+	if (!isSymbolFont(font)) return decodeAnsiText(stripNullBytes(bytes), font?.charset);
+	let text = "";
+	const byteLengths = [];
+	for (const byte of bytes) if (byte !== 0) {
+		text += SYMBOL_CHAR_MAP[byte] ?? String.fromCharCode(byte);
+		byteLengths.push(1);
+	}
+	return {
+		text,
+		byteLengths
+	};
+}
+function isSymbolFont(font) {
+	const faceName = font?.faceName?.toLowerCase();
+	return font?.charset === 2 || faceName === "symbol";
+}
+function stripNullBytes(bytes) {
+	const out = [];
+	for (const byte of bytes) if (byte !== 0) out.push(byte);
+	return new Uint8Array(out);
+}
+function textDecoderLabel(charset) {
+	switch (charset) {
+		case 128: return "shift_jis";
+		case 129: return "ks_c_5601-1987";
+		case 134: return "gb18030";
+		case 136: return "big5";
+		case 161: return "windows-1253";
+		case 162: return "windows-1254";
+		case 163: return "windows-1258";
+		case 177: return "windows-1255";
+		case 178: return "windows-1256";
+		case 186: return "windows-1257";
+		case 204: return "windows-1251";
+		case 222: return "windows-874";
+		case 238: return "windows-1250";
+		default: return;
+	}
+}
+function decodeAnsiBytes(bytes, charset) {
+	const label = textDecoderLabel(charset);
+	if (label && typeof TextDecoder !== "undefined") try {
+		return new TextDecoder(label).decode(bytes);
+	} catch {}
+	let text = "";
+	for (const byte of bytes) text += String.fromCharCode(byte);
+	return text;
+}
+function decodeAnsiText(bytes, charset) {
+	const chunks = splitAnsiTextBytes(bytes, charset);
+	return {
+		text: chunks.map((chunk) => decodeAnsiBytes(chunk, charset)).join(""),
+		byteLengths: chunks.map((chunk) => chunk.length)
+	};
+}
+function splitAnsiTextBytes(bytes, charset) {
+	const chunks = [];
+	for (let i = 0; i < bytes.length;) {
+		const length = ansiCharByteLength(bytes, i, charset);
+		chunks.push(bytes.subarray(i, i + length));
+		i += length;
+	}
+	return chunks;
+}
+function ansiCharByteLength(bytes, offset, charset) {
+	const first = bytes[offset] ?? 0;
+	if (first < 128) return 1;
+	switch (charset) {
+		case 128: return isShiftJisLead(first) && offset + 1 < bytes.length ? 2 : 1;
+		case 129: return isDoubleByteLead(first) && offset + 1 < bytes.length ? 2 : 1;
+		case 134: return gb18030CharByteLength(bytes, offset);
+		case 136: return isBig5Lead(first) && offset + 1 < bytes.length ? 2 : 1;
+		default: return 1;
+	}
+}
+function gb18030CharByteLength(bytes, offset) {
+	const b0 = bytes[offset] ?? 0;
+	const b1 = bytes[offset + 1] ?? 0;
+	const b2 = bytes[offset + 2] ?? 0;
+	const b3 = bytes[offset + 3] ?? 0;
+	if (b0 >= 129 && b0 <= 254 && b1 >= 48 && b1 <= 57 && b2 >= 129 && b2 <= 254 && b3 >= 48 && b3 <= 57) return 4;
+	return b0 >= 129 && b0 <= 254 && offset + 1 < bytes.length ? 2 : 1;
+}
+function isShiftJisLead(byte) {
+	return byte >= 129 && byte <= 159 || byte >= 224 && byte <= 252;
+}
+function isBig5Lead(byte) {
+	return byte >= 129 && byte <= 254;
+}
+function isDoubleByteLead(byte) {
+	return byte >= 129 && byte <= 254;
+}
+function readNullTerminatedAnsi(bytes, offset, charset) {
+	const out = [];
+	for (let i = offset; i < bytes.length; i++) {
+		const byte = bytes[i];
+		if (byte === 0) break;
+		out.push(byte);
+	}
+	return decodeAnsiBytes(new Uint8Array(out), charset);
+}
+function textFontAttrs(font) {
+	const attrs = [` font-family="${escapeXml(isSymbolFont(font) ? "serif" : font.faceName || "sans-serif")}"`];
+	if (font.italic) attrs.push(" font-style=\"italic\"");
+	if (font.weight && font.weight >= 700) attrs.push(" font-weight=\"700\"");
+	return attrs.join("");
+}
+function textBaselineAttrs(state) {
+	if (state.objectTransform && state.mathTypeLeftInset === 0) return " dominant-baseline=\"text-after-edge\"";
+	if (!state.textAlignBaseline || state.objectTransform || isSymbolFont(state.font)) return "";
+	if (state.mathTypeLeftInset > 0) return "";
+	if (state.canvasW < 1e3 || state.canvasH < 500) return "";
+	return " dominant-baseline=\"text-before-edge\"";
+}
+function escapeXml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function colorRef(low, high) {
+	const lo = low & 65535;
+	const hi = high & 65535;
+	return {
+		r: lo & 255,
+		g: lo >> 8 & 255,
+		b: hi & 255,
+		a: 255
+	};
+}
+function fillAttr(brush) {
+	return brush.style === 1 ? " fill=\"none\"" : ` fill="${color(brush.color)}"`;
+}
+function strokeAttr(pen, state) {
+	if (pen.style === PenStyle.PS_NULL) return "";
+	const scaledWidth = pen.width && state ? pen.width * transformScale(state) : pen.width;
+	const width = scaledWidth && scaledWidth > 0 ? ` stroke-width="${fmt(scaledWidth)}"` : "";
+	return ` stroke="${color(pen.color)}"${width}`;
+}
+function color(c) {
+	return `rgb(${c.r},${c.g},${c.b})`;
+}
+function fmt(n) {
+	return Number(n.toFixed(2)).toString();
+}
+//#endregion
+//#region src/index.ts
+/**
+* Convert an EMF (Enhanced Metafile) buffer to SVG string.
+*
+* @param buffer - EMF file data as ArrayBuffer or Uint8Array
+* @returns Complete SVG XML string
+* @throws Error if the buffer is not a valid EMF file
+*/
+function emf2svg(buffer) {
+	return parseEmf(buffer);
+}
+/**
+* Convert a WMF (Windows Metafile) buffer to SVG string.
+*
+* This lightweight converter covers common vector records used in legacy
+* Office clipart/templates: window extents, lines, rectangles, ellipses,
+* polygons, polylines, solid pens, and solid brushes.
+*/
+function wmf2svg(buffer) {
+	return wmf2svg$1(buffer);
+}
+/**
+* Check if a buffer is a valid EMF file by verifying the magic number.
+* EMF files have signature 0x464D4520 (' EMF') at offset 40 in the header.
+*
+* @param buffer - Data to check
+* @returns true if the buffer starts with a valid EMF header
+*/
+function isEmf(buffer) {
+	const view = buffer instanceof Uint8Array ? new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength) : new DataView(buffer);
+	if (view.byteLength < 88) return false;
+	if (view.getUint32(0, true) !== 1) return false;
+	return view.getUint32(40, true) === EMF_SIGNATURE;
+}
+/**
+* Check if a buffer looks like a WMF file, including Aldus placeable WMF.
+*/
+function isWmf(buffer) {
+	return isWmf$1(buffer);
+}
+//#endregion
+exports.emf2svg = emf2svg;
+exports.isEmf = isEmf;
+exports.isWmf = isWmf;
+exports.wmf2svg = wmf2svg;