@office-open/core 0.10.15 → 0.11.0

package/dist/vector-TpjW6ZSc.mjs

@@ -0,0 +1,3092 @@
+import { escapeXml, stringifyElement } from "@office-open/xml";
+//#region src/vector/style.ts
+/**
+* Maps VmlShapeStyle property names to their corresponding CSS-style property names.
+* Used internally for converting TypeScript-friendly property names to VML style attributes.
+*/
+const styleToKeyMap = {
+	flip: "flip",
+	height: "height",
+	left: "left",
+	marginBottom: "margin-bottom",
+	marginLeft: "margin-left",
+	marginRight: "margin-right",
+	marginTop: "margin-top",
+	position: "position",
+	positionHorizontal: "mso-position-horizontal",
+	positionHorizontalRelative: "mso-position-horizontal-relative",
+	positionVertical: "mso-position-vertical",
+	positionVerticalRelative: "mso-position-vertical-relative",
+	rotation: "rotation",
+	top: "top",
+	visibility: "visibility",
+	width: "width",
+	wrapDistanceBottom: "mso-wrap-distance-bottom",
+	wrapDistanceLeft: "mso-wrap-distance-left",
+	wrapDistanceRight: "mso-wrap-distance-right",
+	wrapDistanceTop: "mso-wrap-distance-top",
+	wrapEdited: "mso-wrap-edited",
+	wrapStyle: "mso-wrap-style",
+	fitShapeToText: "mso-fit-shape-to-text",
+	directionAlt: "mso-direction-alt",
+	zIndex: "z-index"
+};
+/**
+* Serialize a VmlShapeStyle object to the VML style attribute value
+* (`"width:100pt;height:50pt"`), translating property names via
+* {@link styleToKeyMap}.
+*/
+function stringifyVmlStyle(style) {
+	return Object.entries(style).map(([key, value]) => {
+		const text = typeof value === "boolean" ? value ? "t" : "f" : String(value);
+		return `${styleToKeyMap[key]}:${text}`;
+	}).join(";");
+}
+/**
+* Parse a VML style attribute value into a CSS-name-keyed record
+* (`{ "mso-position-horizontal": "absolute", … }`). Keys stay in VML/CSS form;
+* callers read the entries they understand (width/height, wrap distances, …).
+*/
+function parseVmlStyle(styleStr) {
+	const style = {};
+	for (const part of styleStr.split(";")) {
+		const [key, val] = part.split(":").map((s) => s.trim());
+		if (key && val) style[key] = val;
+	}
+	return style;
+}
+/** Reverse of {@link styleToKeyMap} — CSS-style property name → VmlShapeStyle field. */
+const keyToStyleMap = Object.fromEntries(Object.entries(styleToKeyMap).map(([field, key]) => [key, field]));
+const NUMERIC = /^-?\d+(\.\d+)?$/;
+/**
+* Parse a CSS-name-keyed style record into a VmlShapeStyle object (camelCase
+* fields, numeric and boolean literals coerced) — the inverse of
+* {@link stringifyVmlStyle}. Keys outside the map are dropped.
+*/
+function parseVmlShapeStyle(record) {
+	const style = {};
+	for (const [key, value] of Object.entries(record)) {
+		const field = keyToStyleMap[key];
+		if (!field) continue;
+		if (field === "wrapEdited" || field === "fitShapeToText") style[field] = value === "t" || value === "true";
+		else if (NUMERIC.test(value)) style[field] = Number(value);
+		else style[field] = value;
+	}
+	return style;
+}
+//#endregion
+//#region src/vector/attributes.ts
+/** AG_CoreAttributes — `style` is special-cased (mini-language), not tabulated. */
+const VML_CORE_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "href",
+		attr: "href",
+		kind: "string"
+	},
+	{
+		field: "target",
+		attr: "target",
+		kind: "string"
+	},
+	{
+		field: "class",
+		attr: "class",
+		kind: "string"
+	},
+	{
+		field: "title",
+		attr: "title",
+		kind: "string"
+	},
+	{
+		field: "alt",
+		attr: "alt",
+		kind: "string"
+	},
+	{
+		field: "coordsize",
+		attr: "coordsize",
+		kind: "string"
+	},
+	{
+		field: "coordorigin",
+		attr: "coordorigin",
+		kind: "string"
+	},
+	{
+		field: "wrapcoords",
+		attr: "wrapcoords",
+		kind: "string"
+	},
+	{
+		field: "print",
+		attr: "print",
+		kind: "trueFalse"
+	}
+];
+/** AG_ShapeAttributes. */
+const VML_SHAPE_ATTRS = [
+	{
+		field: "chromakey",
+		attr: "chromakey",
+		kind: "string"
+	},
+	{
+		field: "filled",
+		attr: "filled",
+		kind: "trueFalse"
+	},
+	{
+		field: "fillcolor",
+		attr: "fillcolor",
+		kind: "string"
+	},
+	{
+		field: "opacity",
+		attr: "opacity",
+		kind: "string"
+	},
+	{
+		field: "stroked",
+		attr: "stroked",
+		kind: "trueFalse"
+	},
+	{
+		field: "strokecolor",
+		attr: "strokecolor",
+		kind: "string"
+	},
+	{
+		field: "strokeweight",
+		attr: "strokeweight",
+		kind: "string"
+	},
+	{
+		field: "insetpen",
+		attr: "insetpen",
+		kind: "trueFalse"
+	}
+];
+/** AG_OfficeCoreAttributes — field names mirror the o: attribute names. */
+const VML_OFFICE_CORE_ATTRS = [
+	{
+		field: "spid",
+		attr: "o:spid",
+		kind: "string"
+	},
+	{
+		field: "oned",
+		attr: "o:oned",
+		kind: "trueFalse"
+	},
+	{
+		field: "regroupid",
+		attr: "o:regroupid",
+		kind: "number"
+	},
+	{
+		field: "doubleclicknotify",
+		attr: "o:doubleclicknotify",
+		kind: "trueFalse"
+	},
+	{
+		field: "button",
+		attr: "o:button",
+		kind: "trueFalse"
+	},
+	{
+		field: "userhidden",
+		attr: "o:userhidden",
+		kind: "trueFalse"
+	},
+	{
+		field: "bullet",
+		attr: "o:bullet",
+		kind: "trueFalse"
+	},
+	{
+		field: "hr",
+		attr: "o:hr",
+		kind: "trueFalse"
+	},
+	{
+		field: "hrstd",
+		attr: "o:hrstd",
+		kind: "trueFalse"
+	},
+	{
+		field: "hrnoshade",
+		attr: "o:hrnoshade",
+		kind: "trueFalse"
+	},
+	{
+		field: "hrpct",
+		attr: "o:hrpct",
+		kind: "number"
+	},
+	{
+		field: "hralign",
+		attr: "o:hralign",
+		kind: "string"
+	},
+	{
+		field: "allowincell",
+		attr: "o:allowincell",
+		kind: "trueFalse"
+	},
+	{
+		field: "allowoverlap",
+		attr: "o:allowoverlap",
+		kind: "trueFalse"
+	},
+	{
+		field: "userdrawn",
+		attr: "o:userdrawn",
+		kind: "trueFalse"
+	},
+	{
+		field: "bordertopcolor",
+		attr: "o:bordertopcolor",
+		kind: "string"
+	},
+	{
+		field: "borderleftcolor",
+		attr: "o:borderleftcolor",
+		kind: "string"
+	},
+	{
+		field: "borderbottomcolor",
+		attr: "o:borderbottomcolor",
+		kind: "string"
+	},
+	{
+		field: "borderrightcolor",
+		attr: "o:borderrightcolor",
+		kind: "string"
+	},
+	{
+		field: "dgmlayout",
+		attr: "o:dgmlayout",
+		kind: "string"
+	},
+	{
+		field: "dgmnodekind",
+		attr: "o:dgmnodekind",
+		kind: "number"
+	},
+	{
+		field: "dgmlayoutmru",
+		attr: "o:dgmlayoutmru",
+		kind: "string"
+	},
+	{
+		field: "insetmode",
+		attr: "o:insetmode",
+		kind: "string"
+	}
+];
+/** AG_OfficeShapeAttributes. */
+const VML_OFFICE_SHAPE_ATTRS = [
+	{
+		field: "spt",
+		attr: "o:spt",
+		kind: "number"
+	},
+	{
+		field: "connectortype",
+		attr: "o:connectortype",
+		kind: "string"
+	},
+	{
+		field: "bwmode",
+		attr: "o:bwmode",
+		kind: "string"
+	},
+	{
+		field: "bwpure",
+		attr: "o:bwpure",
+		kind: "string"
+	},
+	{
+		field: "bwnormal",
+		attr: "o:bwnormal",
+		kind: "string"
+	},
+	{
+		field: "forcedash",
+		attr: "o:forcedash",
+		kind: "trueFalse"
+	},
+	{
+		field: "oleicon",
+		attr: "o:oleicon",
+		kind: "trueFalse"
+	},
+	{
+		field: "ole",
+		attr: "o:ole",
+		kind: "string"
+	},
+	{
+		field: "preferrelative",
+		attr: "o:preferrelative",
+		kind: "trueFalse"
+	},
+	{
+		field: "cliptowrap",
+		attr: "o:cliptowrap",
+		kind: "trueFalse"
+	},
+	{
+		field: "clip",
+		attr: "o:clip",
+		kind: "trueFalse"
+	}
+];
+/** s:ST_TrueFalse output form — "t"/"f", the spelling Office itself writes. */
+function stringifyVmlTrueFalse(value) {
+	return value ? "t" : "f";
+}
+/** Accepts every ST_TrueFalse input spelling. */
+function parseVmlTrueFalse(value) {
+	return value === "t" || value === "true" || value === "1";
+}
+/**
+* Serialize the tabulated fields of `opts` into one attribute string (leading
+* space included when non-empty). The `style` field of
+* {@link VmlCoreAttributes} joins here so callers need a single call.
+*/
+function stringifyVmlAttributes(opts, specs) {
+	const parts = [];
+	for (const spec of specs) {
+		const value = opts[spec.field];
+		if (value === void 0) continue;
+		const text = spec.kind === "trueFalse" ? stringifyVmlTrueFalse(value) : spec.kind === "trueFalseBlank" ? stringifyVmlTrueFalseBlank(value) : spec.kind === "number" ? String(value) : escapeXml(String(value));
+		parts.push(`${spec.attr}="${text}"`);
+	}
+	return parts.length > 0 ? ` ${parts.join(" ")}` : "";
+}
+/** Serialize a boolean-or-empty ST_TrueFalseBlank ("t"/"f"/""). */
+function stringifyVmlTrueFalseBlank(value) {
+	return value === "" ? "" : stringifyVmlTrueFalse(value);
+}
+/** Parse a boolean-or-empty ST_TrueFalseBlank. */
+function parseVmlTrueFalseBlank(value) {
+	return value === "" ? "" : parseVmlTrueFalse(value);
+}
+/** Inverse of {@link stringifyVmlAttributes} — fills the tabulated fields onto `out`. */
+function parseVmlAttributes(el, specs, out) {
+	for (const spec of specs) {
+		const raw = el.attributes?.[spec.attr];
+		if (raw === void 0) continue;
+		out[spec.field] = spec.kind === "trueFalse" ? parseVmlTrueFalse(String(raw)) : spec.kind === "trueFalseBlank" ? parseVmlTrueFalseBlank(String(raw)) : spec.kind === "number" ? Number(raw) : String(raw);
+	}
+}
+//#endregion
+//#region src/vector/shape-elements/office-elements.ts
+/** AG_Ext as a spec entry — prepend to every o: element's spec list. */
+const EXT_ATTR = [{
+	field: "ext",
+	attr: "v:ext",
+	kind: "string"
+}];
+const SKEW_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "on",
+		attr: "on",
+		kind: "trueFalse"
+	},
+	{
+		field: "offset",
+		attr: "offset",
+		kind: "string"
+	},
+	{
+		field: "origin",
+		attr: "origin",
+		kind: "string"
+	},
+	{
+		field: "matrix",
+		attr: "matrix",
+		kind: "string"
+	}
+];
+/** Serialize o:skew. */
+function stringifyVmlSkew(opts) {
+	return `<o:skew${stringifyVmlAttributes(opts, [...EXT_ATTR, ...SKEW_ATTRS])}/>`;
+}
+/** Parse an o:skew element. */
+function parseVmlSkew(el) {
+	const out = {};
+	parseVmlAttributes(el, [...EXT_ATTR, ...SKEW_ATTRS], out);
+	return out;
+}
+const EXTRUSION_ATTRS = [
+	{
+		field: "on",
+		attr: "on",
+		kind: "trueFalse"
+	},
+	{
+		field: "type",
+		attr: "type",
+		kind: "string"
+	},
+	{
+		field: "render",
+		attr: "render",
+		kind: "string"
+	},
+	{
+		field: "viewpointorigin",
+		attr: "viewpointorigin",
+		kind: "string"
+	},
+	{
+		field: "viewpoint",
+		attr: "viewpoint",
+		kind: "string"
+	},
+	{
+		field: "plane",
+		attr: "plane",
+		kind: "string"
+	},
+	{
+		field: "skewangle",
+		attr: "skewangle",
+		kind: "number"
+	},
+	{
+		field: "skewamt",
+		attr: "skewamt",
+		kind: "string"
+	},
+	{
+		field: "foredepth",
+		attr: "foredepth",
+		kind: "string"
+	},
+	{
+		field: "backdepth",
+		attr: "backdepth",
+		kind: "string"
+	},
+	{
+		field: "orientation",
+		attr: "orientation",
+		kind: "string"
+	},
+	{
+		field: "orientationangle",
+		attr: "orientationangle",
+		kind: "number"
+	},
+	{
+		field: "lockrotationcenter",
+		attr: "lockrotationcenter",
+		kind: "trueFalse"
+	},
+	{
+		field: "autorotationcenter",
+		attr: "autorotationcenter",
+		kind: "trueFalse"
+	},
+	{
+		field: "rotationcenter",
+		attr: "rotationcenter",
+		kind: "string"
+	},
+	{
+		field: "rotationangle",
+		attr: "rotationangle",
+		kind: "string"
+	},
+	{
+		field: "colormode",
+		attr: "colormode",
+		kind: "string"
+	},
+	{
+		field: "color",
+		attr: "color",
+		kind: "string"
+	},
+	{
+		field: "shininess",
+		attr: "shininess",
+		kind: "number"
+	},
+	{
+		field: "specularity",
+		attr: "specularity",
+		kind: "string"
+	},
+	{
+		field: "diffusity",
+		attr: "diffusity",
+		kind: "string"
+	},
+	{
+		field: "metal",
+		attr: "metal",
+		kind: "trueFalse"
+	},
+	{
+		field: "edge",
+		attr: "edge",
+		kind: "string"
+	},
+	{
+		field: "facet",
+		attr: "facet",
+		kind: "string"
+	},
+	{
+		field: "lightface",
+		attr: "lightface",
+		kind: "trueFalse"
+	},
+	{
+		field: "brightness",
+		attr: "brightness",
+		kind: "string"
+	},
+	{
+		field: "lightposition",
+		attr: "lightposition",
+		kind: "string"
+	},
+	{
+		field: "lightlevel",
+		attr: "lightlevel",
+		kind: "string"
+	},
+	{
+		field: "lightharsh",
+		attr: "lightharsh",
+		kind: "trueFalse"
+	},
+	{
+		field: "lightposition2",
+		attr: "lightposition2",
+		kind: "string"
+	},
+	{
+		field: "lightlevel2",
+		attr: "lightlevel2",
+		kind: "string"
+	},
+	{
+		field: "lightharsh2",
+		attr: "lightharsh2",
+		kind: "trueFalse"
+	}
+];
+/** Serialize o:extrusion. */
+function stringifyVmlExtrusion(opts) {
+	return `<o:extrusion${stringifyVmlAttributes(opts, [...EXT_ATTR, ...EXTRUSION_ATTRS])}/>`;
+}
+/** Parse an o:extrusion element. */
+function parseVmlExtrusion(el) {
+	const out = {};
+	parseVmlAttributes(el, [...EXT_ATTR, ...EXTRUSION_ATTRS], out);
+	return out;
+}
+const CALLOUT_ATTRS = [
+	{
+		field: "on",
+		attr: "on",
+		kind: "trueFalse"
+	},
+	{
+		field: "type",
+		attr: "type",
+		kind: "string"
+	},
+	{
+		field: "gap",
+		attr: "gap",
+		kind: "string"
+	},
+	{
+		field: "angle",
+		attr: "angle",
+		kind: "string"
+	},
+	{
+		field: "dropauto",
+		attr: "dropauto",
+		kind: "trueFalse"
+	},
+	{
+		field: "drop",
+		attr: "drop",
+		kind: "string"
+	},
+	{
+		field: "distance",
+		attr: "distance",
+		kind: "string"
+	},
+	{
+		field: "lengthspecified",
+		attr: "lengthspecified",
+		kind: "trueFalse"
+	},
+	{
+		field: "length",
+		attr: "length",
+		kind: "string"
+	},
+	{
+		field: "accentbar",
+		attr: "accentbar",
+		kind: "trueFalse"
+	},
+	{
+		field: "textborder",
+		attr: "textborder",
+		kind: "trueFalse"
+	},
+	{
+		field: "minusx",
+		attr: "minusx",
+		kind: "trueFalse"
+	},
+	{
+		field: "minusy",
+		attr: "minusy",
+		kind: "trueFalse"
+	}
+];
+/** Serialize o:callout. */
+function stringifyVmlCallout(opts) {
+	return `<o:callout${stringifyVmlAttributes(opts, [...EXT_ATTR, ...CALLOUT_ATTRS])}/>`;
+}
+/** Parse an o:callout element. */
+function parseVmlCallout(el) {
+	const out = {};
+	parseVmlAttributes(el, [...EXT_ATTR, ...CALLOUT_ATTRS], out);
+	return out;
+}
+const LOCK_ATTRS = [
+	{
+		field: "position",
+		attr: "position",
+		kind: "trueFalse"
+	},
+	{
+		field: "selection",
+		attr: "selection",
+		kind: "trueFalse"
+	},
+	{
+		field: "grouping",
+		attr: "grouping",
+		kind: "trueFalse"
+	},
+	{
+		field: "ungrouping",
+		attr: "ungrouping",
+		kind: "trueFalse"
+	},
+	{
+		field: "rotation",
+		attr: "rotation",
+		kind: "trueFalse"
+	},
+	{
+		field: "cropping",
+		attr: "cropping",
+		kind: "trueFalse"
+	},
+	{
+		field: "verticies",
+		attr: "verticies",
+		kind: "trueFalse"
+	},
+	{
+		field: "adjusthandles",
+		attr: "adjusthandles",
+		kind: "trueFalse"
+	},
+	{
+		field: "text",
+		attr: "text",
+		kind: "trueFalse"
+	},
+	{
+		field: "aspectratio",
+		attr: "aspectratio",
+		kind: "trueFalse"
+	},
+	{
+		field: "shapetype",
+		attr: "shapetype",
+		kind: "trueFalse"
+	}
+];
+/** Serialize o:lock. */
+function stringifyVmlLock(opts) {
+	return `<o:lock${stringifyVmlAttributes(opts, [...EXT_ATTR, ...LOCK_ATTRS])}/>`;
+}
+/** Parse an o:lock element. */
+function parseVmlLock(el) {
+	const out = {};
+	parseVmlAttributes(el, [...EXT_ATTR, ...LOCK_ATTRS], out);
+	return out;
+}
+/** Serialize o:clippath. */
+function stringifyVmlClipPath(opts) {
+	return `<o:clippath v:v="${escapeXml(opts.v)}"/>`;
+}
+/** Parse an o:clippath element. */
+function parseVmlClipPath(el) {
+	return { v: String(el.attributes?.["v:v"] ?? "") };
+}
+const SIGNATURE_ATTRS = [
+	{
+		field: "issignatureline",
+		attr: "issignatureline",
+		kind: "trueFalse"
+	},
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "provid",
+		attr: "provid",
+		kind: "string"
+	},
+	{
+		field: "signinginstructionsset",
+		attr: "signinginstructionsset",
+		kind: "trueFalse"
+	},
+	{
+		field: "allowcomments",
+		attr: "allowcomments",
+		kind: "trueFalse"
+	},
+	{
+		field: "showsigndate",
+		attr: "showsigndate",
+		kind: "trueFalse"
+	},
+	{
+		field: "suggestedsigner",
+		attr: "o:suggestedsigner",
+		kind: "string"
+	},
+	{
+		field: "suggestedsigner2",
+		attr: "o:suggestedsigner2",
+		kind: "string"
+	},
+	{
+		field: "suggestedsigneremail",
+		attr: "o:suggestedsigneremail",
+		kind: "string"
+	},
+	{
+		field: "signinginstructions",
+		attr: "signinginstructions",
+		kind: "string"
+	},
+	{
+		field: "addlxml",
+		attr: "addlxml",
+		kind: "string"
+	},
+	{
+		field: "sigprovurl",
+		attr: "sigprovurl",
+		kind: "string"
+	}
+];
+/** Serialize o:signatureline. */
+function stringifyVmlSignatureLine(opts) {
+	return `<o:signatureline${stringifyVmlAttributes(opts, [...EXT_ATTR, ...SIGNATURE_ATTRS])}/>`;
+}
+/** Parse an o:signatureline element. */
+function parseVmlSignatureLine(el) {
+	const out = {};
+	parseVmlAttributes(el, [...EXT_ATTR, ...SIGNATURE_ATTRS], out);
+	return out;
+}
+/** Serialize o:ink (hand-written — `i` is required, so no table-driven cast). */
+function stringifyVmlInk(opts) {
+	const attrs = [`i="${escapeXml(opts.i)}"`];
+	if (opts.annotation !== void 0) attrs.push(`annotation="${stringifyVmlTrueFalse(opts.annotation)}"`);
+	if (opts.contentType !== void 0) attrs.push(`contentType="${escapeXml(opts.contentType)}"`);
+	return `<o:ink ${attrs.join(" ")}/>`;
+}
+/** Parse an o:ink element. */
+function parseVmlInk(el) {
+	const out = { i: String(el.attributes?.i ?? "") };
+	if (el.attributes?.annotation !== void 0) out.annotation = parseVmlTrueFalse(String(el.attributes.annotation));
+	if (el.attributes?.contentType !== void 0) out.contentType = String(el.attributes.contentType);
+	return out;
+}
+/** Serialize o:equationxml. */
+function stringifyVmlEquationXml(opts) {
+	return `<o:equationxml${opts.contentType !== void 0 ? ` contentType="${escapeXml(opts.contentType)}"` : ""}>${opts.content ?? ""}</o:equationxml>`;
+}
+/** Parse an o:equationxml element. */
+function parseVmlEquationXml(el) {
+	const out = {};
+	const contentType = el.attributes?.contentType;
+	if (contentType !== void 0) out.contentType = String(contentType);
+	if ((el.elements ?? []).length > 0) {
+		const child = el.elements.find((c) => c.type === "element");
+		if (child) out.content = stringifyElement(child);
+	}
+	return out;
+}
+const RELATION_ATTRS = [
+	{
+		field: "idsrc",
+		attr: "idsrc",
+		kind: "string"
+	},
+	{
+		field: "iddest",
+		attr: "iddest",
+		kind: "string"
+	},
+	{
+		field: "idcntr",
+		attr: "idcntr",
+		kind: "string"
+	}
+];
+const DIAGRAM_ATTRS = [
+	{
+		field: "dgmstyle",
+		attr: "dgmstyle",
+		kind: "number"
+	},
+	{
+		field: "autoformat",
+		attr: "autoformat",
+		kind: "trueFalse"
+	},
+	{
+		field: "reverse",
+		attr: "reverse",
+		kind: "trueFalse"
+	},
+	{
+		field: "autolayout",
+		attr: "autolayout",
+		kind: "trueFalse"
+	},
+	{
+		field: "dgmscalex",
+		attr: "dgmscalex",
+		kind: "number"
+	},
+	{
+		field: "dgmscaley",
+		attr: "dgmscaley",
+		kind: "number"
+	},
+	{
+		field: "dgmfontsize",
+		attr: "dgmfontsize",
+		kind: "number"
+	},
+	{
+		field: "constrainbounds",
+		attr: "constrainbounds",
+		kind: "string"
+	},
+	{
+		field: "dgmbasetextscale",
+		attr: "dgmbasetextscale",
+		kind: "number"
+	}
+];
+/** Serialize o:diagram. */
+function stringifyVmlDiagram(opts) {
+	const relations = (opts.relations ?? []).map((rel) => `<o:rel${stringifyVmlAttributes(rel, [...EXT_ATTR, ...RELATION_ATTRS])}/>`).join("");
+	const children = relations !== "" ? `<o:relationtable>${relations}</o:relationtable>` : "";
+	return `<o:diagram${stringifyVmlAttributes(opts, [...EXT_ATTR, ...DIAGRAM_ATTRS])}>${children}</o:diagram>`;
+}
+/** Parse an o:diagram element. */
+function parseVmlDiagram(el) {
+	const out = {};
+	parseVmlAttributes(el, [...EXT_ATTR, ...DIAGRAM_ATTRS], out);
+	const relationTable = (el.elements ?? []).find((c) => c.type === "element" && c.name === "o:relationtable");
+	if (relationTable) {
+		const relations = [];
+		for (const child of relationTable.elements ?? []) if (child.type === "element" && child.name === "o:rel") {
+			const rel = {};
+			parseVmlAttributes(child, [...EXT_ATTR, ...RELATION_ATTRS], rel);
+			relations.push(rel);
+		}
+		if (relations.length > 0) out.relations = relations;
+	}
+	return out;
+}
+/** Serialize o:complex. */
+function stringifyVmlComplex(opts) {
+	return `<o:complex${stringifyVmlAttributes(opts, EXT_ATTR)}/>`;
+}
+/** Parse an o:complex element. */
+function parseVmlComplex(el) {
+	const out = {};
+	parseVmlAttributes(el, EXT_ATTR, out);
+	return out;
+}
+/** Serialize o:fill. */
+function stringifyVmlOfficeFill(opts) {
+	return `<o:fill${stringifyVmlAttributes(opts, EXT_ATTR)}${opts.type !== void 0 ? ` type="${opts.type}"` : ""}/>`;
+}
+/** Parse an o:fill element. */
+function parseVmlOfficeFill(el) {
+	const out = {};
+	parseVmlAttributes(el, EXT_ATTR, out);
+	if (el.attributes?.type !== void 0) out.type = String(el.attributes.type);
+	return out;
+}
+const OLE_OBJECT_ATTRS = [
+	{
+		field: "Type",
+		attr: "Type",
+		kind: "string"
+	},
+	{
+		field: "ProgID",
+		attr: "ProgID",
+		kind: "string"
+	},
+	{
+		field: "ShapeID",
+		attr: "ShapeID",
+		kind: "string"
+	},
+	{
+		field: "DrawAspect",
+		attr: "DrawAspect",
+		kind: "string"
+	},
+	{
+		field: "ObjectID",
+		attr: "ObjectID",
+		kind: "string"
+	},
+	{
+		field: "relationshipId",
+		attr: "r:id",
+		kind: "string"
+	},
+	{
+		field: "UpdateMode",
+		attr: "UpdateMode",
+		kind: "string"
+	}
+];
+/** Serialize o:OLEObject. */
+function stringifyVmlOleObject(opts) {
+	const children = [];
+	if (opts.linkType !== void 0) children.push(`<o:LinkType>${escapeXml(opts.linkType)}</o:LinkType>`);
+	if (opts.lockedField !== void 0) children.push(`<o:LockedField>${stringifyVmlTrueFalseBlank(opts.lockedField)}</o:LockedField>`);
+	if (opts.fieldCodes !== void 0) children.push(`<o:FieldCodes>${escapeXml(opts.fieldCodes)}</o:FieldCodes>`);
+	const attrStr = stringifyVmlAttributes(opts, OLE_OBJECT_ATTRS);
+	return children.length > 0 ? `<o:OLEObject${attrStr}>${children.join("")}</o:OLEObject>` : `<o:OLEObject${attrStr}/>`;
+}
+/** Read the concatenated text content of an element (LinkType/FieldCodes children). */
+function elementText(el) {
+	return (el.elements ?? []).map((child) => String(child.text ?? "")).join("");
+}
+/** Parse an o:OLEObject element. */
+function parseVmlOleObject(el) {
+	const out = {};
+	parseVmlAttributes(el, OLE_OBJECT_ATTRS, out);
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		if (child.name === "o:LinkType") out.linkType = elementText(child);
+		else if (child.name === "o:LockedField") out.lockedField = parseVmlTrueFalseBlank(elementText(child));
+		else if (child.name === "o:FieldCodes") out.fieldCodes = elementText(child);
+	}
+	return out;
+}
+//#endregion
+//#region src/vector/shape-elements/client-data.ts
+const TRUE_FALSE_BLANK_FIELDS = [
+	"MoveWithCells",
+	"SizeWithCells",
+	"Locked",
+	"DefaultSize",
+	"PrintObject",
+	"Disabled",
+	"AutoFill",
+	"AutoLine",
+	"AutoPict",
+	"LockText",
+	"JustLastX",
+	"SecretEdit",
+	"Default",
+	"Help",
+	"Cancel",
+	"Dismiss",
+	"Visible",
+	"RowHidden",
+	"ColHidden",
+	"MultiLine",
+	"VScroll",
+	"ValidIds",
+	"NoThreeD2",
+	"Colored",
+	"NoThreeD",
+	"FirstButton",
+	"Horiz",
+	"MapOCX",
+	"Camera",
+	"RecalcAlways",
+	"AutoScale",
+	"DDE",
+	"UIObj"
+];
+const INTEGER_FIELDS = [
+	"Accel",
+	"Accel2",
+	"Row",
+	"Column",
+	"VTEdit",
+	"WidthMin",
+	"Sel",
+	"DropLines",
+	"Checked",
+	"Val",
+	"Min",
+	"Max",
+	"Inc",
+	"Page",
+	"Dx",
+	"ScriptLanguage",
+	"ScriptLocation"
+];
+const STRING_FIELDS = [
+	"Anchor",
+	"FmlaMacro",
+	"TextHAlign",
+	"TextVAlign",
+	"FmlaRange",
+	"SelType",
+	"MultiSel",
+	"LCT",
+	"ListItem",
+	"DropStyle",
+	"FmlaLink",
+	"FmlaPict",
+	"FmlaGroup",
+	"ScriptText",
+	"ScriptExtended",
+	"FmlaTxbx",
+	"CF"
+];
+/** Serialize x:ClientData. */
+function stringifyVmlClientData(opts) {
+	const children = [];
+	for (const field of TRUE_FALSE_BLANK_FIELDS) {
+		const value = opts[field];
+		if (value !== void 0) children.push(`<x:${field}>${stringifyVmlTrueFalseBlank(value)}</x:${field}>`);
+	}
+	for (const field of INTEGER_FIELDS) {
+		const value = opts[field];
+		if (value !== void 0) children.push(`<x:${field}>${value}</x:${field}>`);
+	}
+	for (const field of STRING_FIELDS) {
+		const value = opts[field];
+		if (value !== void 0) children.push(`<x:${field}>${escapeXml(value)}</x:${field}>`);
+	}
+	return `<x:ClientData ObjectType="${opts.objectType}">${children.join("")}</x:ClientData>`;
+}
+/** Parse an x:ClientData element. */
+function parseVmlClientData(el) {
+	const out = { objectType: String(el.attributes?.ObjectType ?? "") };
+	const tfbFields = new Set(TRUE_FALSE_BLANK_FIELDS);
+	const intFields = new Set(INTEGER_FIELDS);
+	const extras = {};
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		const local = child.name?.startsWith("x:") ? child.name.slice(2) : null;
+		if (local === null) continue;
+		const text = (child.elements ?? []).map((c) => String(c.text ?? "")).join("");
+		if (tfbFields.has(local)) extras[local] = parseVmlTrueFalseBlank(text);
+		else if (intFields.has(local)) extras[local] = Number(text);
+		else if (STRING_FIELDS.includes(local)) extras[local] = text;
+	}
+	return Object.assign(out, extras);
+}
+//#endregion
+//#region src/vector/shape-elements/fill.ts
+const FILL_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "type",
+		attr: "type",
+		kind: "string"
+	},
+	{
+		field: "on",
+		attr: "on",
+		kind: "trueFalse"
+	},
+	{
+		field: "color",
+		attr: "color",
+		kind: "string"
+	},
+	{
+		field: "opacity",
+		attr: "opacity",
+		kind: "string"
+	},
+	{
+		field: "color2",
+		attr: "color2",
+		kind: "string"
+	},
+	{
+		field: "src",
+		attr: "src",
+		kind: "string"
+	},
+	{
+		field: "size",
+		attr: "size",
+		kind: "string"
+	},
+	{
+		field: "origin",
+		attr: "origin",
+		kind: "string"
+	},
+	{
+		field: "position",
+		attr: "position",
+		kind: "string"
+	},
+	{
+		field: "aspect",
+		attr: "aspect",
+		kind: "string"
+	},
+	{
+		field: "colors",
+		attr: "colors",
+		kind: "string"
+	},
+	{
+		field: "angle",
+		attr: "angle",
+		kind: "number"
+	},
+	{
+		field: "alignshape",
+		attr: "alignshape",
+		kind: "trueFalse"
+	},
+	{
+		field: "focus",
+		attr: "focus",
+		kind: "string"
+	},
+	{
+		field: "focussize",
+		attr: "focussize",
+		kind: "string"
+	},
+	{
+		field: "focusposition",
+		attr: "focusposition",
+		kind: "string"
+	},
+	{
+		field: "method",
+		attr: "method",
+		kind: "string"
+	},
+	{
+		field: "recolor",
+		attr: "recolor",
+		kind: "trueFalse"
+	},
+	{
+		field: "rotate",
+		attr: "rotate",
+		kind: "trueFalse"
+	},
+	{
+		field: "relationshipId",
+		attr: "r:id",
+		kind: "string"
+	},
+	{
+		field: "officeHref",
+		attr: "o:href",
+		kind: "string"
+	},
+	{
+		field: "officeAltHref",
+		attr: "o:althref",
+		kind: "string"
+	},
+	{
+		field: "detectmouseclick",
+		attr: "o:detectmouseclick",
+		kind: "trueFalse"
+	},
+	{
+		field: "officeTitle",
+		attr: "o:title",
+		kind: "string"
+	},
+	{
+		field: "opacity2",
+		attr: "o:opacity2",
+		kind: "string"
+	},
+	{
+		field: "officeRelationshipId",
+		attr: "o:relid",
+		kind: "string"
+	}
+];
+/** Serialize v:fill. */
+function stringifyVmlFill(opts) {
+	const child = opts.officeFill !== void 0 ? stringifyVmlOfficeFill(opts.officeFill) : "";
+	const attrStr = stringifyVmlAttributes(opts, FILL_ATTRS);
+	return child !== "" ? `<v:fill${attrStr}>${child}</v:fill>` : `<v:fill${attrStr}/>`;
+}
+/** Parse a v:fill element. */
+function parseVmlFill(el) {
+	const out = {};
+	parseVmlAttributes(el, FILL_ATTRS, out);
+	for (const child of el.elements ?? []) if (child.type === "element" && child.name === "o:fill") {
+		out.officeFill = parseVmlOfficeFill(child);
+		break;
+	}
+	return out;
+}
+//#endregion
+//#region src/vector/shape-elements/formulas.ts
+/** Serialize v:formulas. */
+function stringifyVmlFormulas(opts) {
+	return `<v:formulas>${(opts.equations ?? []).map((eqn) => `<v:f eqn="${escapeXml(eqn)}"/>`).join("")}</v:formulas>`;
+}
+/** Parse a v:formulas element. */
+function parseVmlFormulas(el) {
+	const equations = [];
+	for (const child of el.elements ?? []) if (child.type === "element" && child.name === "v:f") {
+		const eqn = child.attributes?.eqn;
+		if (eqn !== void 0) equations.push(String(eqn));
+	}
+	return equations.length > 0 ? { equations } : {};
+}
+//#endregion
+//#region src/vector/shape-elements/handles.ts
+const HANDLE_STRING_FIELDS = [
+	"position",
+	"polar",
+	"map",
+	"xrange",
+	"yrange",
+	"radiusrange"
+];
+const HANDLE_BOOLEAN_FIELDS = [
+	"invx",
+	"invy",
+	"switch"
+];
+/** Serialize v:handles. */
+function stringifyVmlHandles(opts) {
+	return `<v:handles>${(opts.handles ?? []).map((handle) => {
+		const attrs = [];
+		for (const field of HANDLE_STRING_FIELDS) {
+			const value = handle[field];
+			if (value !== void 0) attrs.push(`${field}="${escapeXml(value)}"`);
+		}
+		for (const field of HANDLE_BOOLEAN_FIELDS) {
+			const value = handle[field];
+			if (value !== void 0) attrs.push(`${field}="${stringifyVmlTrueFalse(value)}"`);
+		}
+		return `<v:h${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}/>`;
+	}).join("")}</v:handles>`;
+}
+/** Parse a v:handles element. */
+function parseVmlHandles(el) {
+	const handles = [];
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element" || child.name !== "v:h") continue;
+		const handle = {};
+		const attrs = child.attributes ?? {};
+		for (const field of HANDLE_STRING_FIELDS) {
+			const raw = attrs[field];
+			if (raw !== void 0) handle[field] = String(raw);
+		}
+		for (const field of HANDLE_BOOLEAN_FIELDS) {
+			const raw = attrs[field];
+			if (raw !== void 0) handle[field] = parseVmlTrueFalse(String(raw));
+		}
+		handles.push(handle);
+	}
+	return handles.length > 0 ? { handles } : {};
+}
+//#endregion
+//#region src/vector/shape-elements/imagedata.ts
+const IMAGEDATA_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "src",
+		attr: "src",
+		kind: "string"
+	},
+	{
+		field: "cropleft",
+		attr: "cropleft",
+		kind: "string"
+	},
+	{
+		field: "croptop",
+		attr: "croptop",
+		kind: "string"
+	},
+	{
+		field: "cropright",
+		attr: "cropright",
+		kind: "string"
+	},
+	{
+		field: "cropbottom",
+		attr: "cropbottom",
+		kind: "string"
+	},
+	{
+		field: "gain",
+		attr: "gain",
+		kind: "string"
+	},
+	{
+		field: "blacklevel",
+		attr: "blacklevel",
+		kind: "string"
+	},
+	{
+		field: "gamma",
+		attr: "gamma",
+		kind: "string"
+	},
+	{
+		field: "grayscale",
+		attr: "grayscale",
+		kind: "trueFalse"
+	},
+	{
+		field: "bilevel",
+		attr: "bilevel",
+		kind: "trueFalse"
+	},
+	{
+		field: "chromakey",
+		attr: "chromakey",
+		kind: "string"
+	},
+	{
+		field: "embosscolor",
+		attr: "embosscolor",
+		kind: "string"
+	},
+	{
+		field: "recolortarget",
+		attr: "recolortarget",
+		kind: "string"
+	},
+	{
+		field: "relationshipId",
+		attr: "r:id",
+		kind: "string"
+	},
+	{
+		field: "pictRelationshipId",
+		attr: "r:pict",
+		kind: "string"
+	},
+	{
+		field: "hrefRelationshipId",
+		attr: "r:href",
+		kind: "string"
+	},
+	{
+		field: "officeHref",
+		attr: "o:href",
+		kind: "string"
+	},
+	{
+		field: "officeAltHref",
+		attr: "o:althref",
+		kind: "string"
+	},
+	{
+		field: "officeTitle",
+		attr: "o:title",
+		kind: "string"
+	},
+	{
+		field: "oleid",
+		attr: "o:oleid",
+		kind: "number"
+	},
+	{
+		field: "detectmouseclick",
+		attr: "o:detectmouseclick",
+		kind: "trueFalse"
+	},
+	{
+		field: "movie",
+		attr: "o:movie",
+		kind: "number"
+	},
+	{
+		field: "officeRelationshipId",
+		attr: "o:relid",
+		kind: "string"
+	}
+];
+/** Serialize v:imagedata. */
+function stringifyVmlImageData(opts) {
+	return `<v:imagedata${stringifyVmlAttributes(opts, IMAGEDATA_ATTRS)}/>`;
+}
+/** Parse a v:imagedata element. */
+function parseVmlImageData(el) {
+	const out = {};
+	parseVmlAttributes(el, IMAGEDATA_ATTRS, out);
+	return out;
+}
+//#endregion
+//#region src/vector/shape-elements/path.ts
+const PATH_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "v",
+		attr: "v",
+		kind: "string"
+	},
+	{
+		field: "limo",
+		attr: "limo",
+		kind: "string"
+	},
+	{
+		field: "textboxrect",
+		attr: "textboxrect",
+		kind: "string"
+	},
+	{
+		field: "fillok",
+		attr: "fillok",
+		kind: "trueFalse"
+	},
+	{
+		field: "strokeok",
+		attr: "strokeok",
+		kind: "trueFalse"
+	},
+	{
+		field: "shadowok",
+		attr: "shadowok",
+		kind: "trueFalse"
+	},
+	{
+		field: "arrowok",
+		attr: "arrowok",
+		kind: "trueFalse"
+	},
+	{
+		field: "gradientshapeok",
+		attr: "gradientshapeok",
+		kind: "trueFalse"
+	},
+	{
+		field: "textpathok",
+		attr: "textpathok",
+		kind: "trueFalse"
+	},
+	{
+		field: "insetpenok",
+		attr: "insetpenok",
+		kind: "trueFalse"
+	},
+	{
+		field: "connecttype",
+		attr: "o:connecttype",
+		kind: "string"
+	},
+	{
+		field: "connectlocs",
+		attr: "o:connectlocs",
+		kind: "string"
+	},
+	{
+		field: "connectangles",
+		attr: "o:connectangles",
+		kind: "string"
+	},
+	{
+		field: "extrusionok",
+		attr: "o:extrusionok",
+		kind: "trueFalse"
+	}
+];
+/** Serialize v:path. */
+function stringifyVmlPath(opts) {
+	return `<v:path${stringifyVmlAttributes(opts, PATH_ATTRS)}/>`;
+}
+/** Parse a v:path element. */
+function parseVmlPath(el) {
+	const out = {};
+	parseVmlAttributes(el, PATH_ATTRS, out);
+	return out;
+}
+//#endregion
+//#region src/vector/shape-elements/presentation-elements.ts
+/** Serialize pvml:iscomment. */
+function stringifyVmlIsComment(_opts) {
+	return "<pvml:iscomment/>";
+}
+/** Parse a pvml:iscomment element. */
+function parseVmlIsComment(_el) {
+	return {};
+}
+/** Serialize pvml:textdata. */
+function stringifyVmlTextData(opts) {
+	return opts.id !== void 0 ? `<pvml:textdata id="${opts.id}"/>` : "<pvml:textdata/>";
+}
+/** Parse a pvml:textdata element. */
+function parseVmlTextData(el) {
+	const id = el.attributes?.id;
+	return id !== void 0 ? { id: String(id) } : {};
+}
+//#endregion
+//#region src/vector/shape-elements/shadow.ts
+const SHADOW_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "on",
+		attr: "on",
+		kind: "trueFalse"
+	},
+	{
+		field: "type",
+		attr: "type",
+		kind: "string"
+	},
+	{
+		field: "obscured",
+		attr: "obscured",
+		kind: "trueFalse"
+	},
+	{
+		field: "color",
+		attr: "color",
+		kind: "string"
+	},
+	{
+		field: "opacity",
+		attr: "opacity",
+		kind: "string"
+	},
+	{
+		field: "offset",
+		attr: "offset",
+		kind: "string"
+	},
+	{
+		field: "color2",
+		attr: "color2",
+		kind: "string"
+	},
+	{
+		field: "offset2",
+		attr: "offset2",
+		kind: "string"
+	},
+	{
+		field: "origin",
+		attr: "origin",
+		kind: "string"
+	},
+	{
+		field: "matrix",
+		attr: "matrix",
+		kind: "string"
+	}
+];
+/** Serialize v:shadow. */
+function stringifyVmlShadow(opts) {
+	return `<v:shadow${stringifyVmlAttributes(opts, SHADOW_ATTRS)}/>`;
+}
+/** Parse a v:shadow element. */
+function parseVmlShadow(el) {
+	const out = {};
+	parseVmlAttributes(el, SHADOW_ATTRS, out);
+	return out;
+}
+//#endregion
+//#region src/vector/shape-elements/stroke.ts
+const STROKE_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "on",
+		attr: "on",
+		kind: "trueFalse"
+	},
+	{
+		field: "weight",
+		attr: "weight",
+		kind: "string"
+	},
+	{
+		field: "color",
+		attr: "color",
+		kind: "string"
+	},
+	{
+		field: "opacity",
+		attr: "opacity",
+		kind: "string"
+	},
+	{
+		field: "linestyle",
+		attr: "linestyle",
+		kind: "string"
+	},
+	{
+		field: "miterlimit",
+		attr: "miterlimit",
+		kind: "number"
+	},
+	{
+		field: "joinstyle",
+		attr: "joinstyle",
+		kind: "string"
+	},
+	{
+		field: "endcap",
+		attr: "endcap",
+		kind: "string"
+	},
+	{
+		field: "dashstyle",
+		attr: "dashstyle",
+		kind: "string"
+	},
+	{
+		field: "filltype",
+		attr: "filltype",
+		kind: "string"
+	},
+	{
+		field: "src",
+		attr: "src",
+		kind: "string"
+	},
+	{
+		field: "imageaspect",
+		attr: "imageaspect",
+		kind: "string"
+	},
+	{
+		field: "imagesize",
+		attr: "imagesize",
+		kind: "string"
+	},
+	{
+		field: "imagealignshape",
+		attr: "imagealignshape",
+		kind: "trueFalse"
+	},
+	{
+		field: "color2",
+		attr: "color2",
+		kind: "string"
+	},
+	{
+		field: "startarrow",
+		attr: "startarrow",
+		kind: "string"
+	},
+	{
+		field: "startarrowwidth",
+		attr: "startarrowwidth",
+		kind: "string"
+	},
+	{
+		field: "startarrowlength",
+		attr: "startarrowlength",
+		kind: "string"
+	},
+	{
+		field: "endarrow",
+		attr: "endarrow",
+		kind: "string"
+	},
+	{
+		field: "endarrowwidth",
+		attr: "endarrowwidth",
+		kind: "string"
+	},
+	{
+		field: "endarrowlength",
+		attr: "endarrowlength",
+		kind: "string"
+	},
+	{
+		field: "relationshipId",
+		attr: "r:id",
+		kind: "string"
+	},
+	{
+		field: "insetpen",
+		attr: "insetpen",
+		kind: "trueFalse"
+	},
+	{
+		field: "officeHref",
+		attr: "o:href",
+		kind: "string"
+	},
+	{
+		field: "officeAltHref",
+		attr: "o:althref",
+		kind: "string"
+	},
+	{
+		field: "officeTitle",
+		attr: "o:title",
+		kind: "string"
+	},
+	{
+		field: "forcedash",
+		attr: "o:forcedash",
+		kind: "trueFalse"
+	},
+	{
+		field: "officeRelationshipId",
+		attr: "o:relid",
+		kind: "string"
+	}
+];
+const STROKE_CHILD_ATTRS = [
+	{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	},
+	{
+		field: "on",
+		attr: "on",
+		kind: "trueFalse"
+	},
+	{
+		field: "weight",
+		attr: "weight",
+		kind: "string"
+	},
+	{
+		field: "color",
+		attr: "color",
+		kind: "string"
+	},
+	{
+		field: "color2",
+		attr: "color2",
+		kind: "string"
+	},
+	{
+		field: "opacity",
+		attr: "opacity",
+		kind: "string"
+	},
+	{
+		field: "linestyle",
+		attr: "linestyle",
+		kind: "string"
+	},
+	{
+		field: "miterlimit",
+		attr: "miterlimit",
+		kind: "number"
+	},
+	{
+		field: "joinstyle",
+		attr: "joinstyle",
+		kind: "string"
+	},
+	{
+		field: "endcap",
+		attr: "endcap",
+		kind: "string"
+	},
+	{
+		field: "dashstyle",
+		attr: "dashstyle",
+		kind: "string"
+	},
+	{
+		field: "insetpen",
+		attr: "insetpen",
+		kind: "trueFalse"
+	},
+	{
+		field: "filltype",
+		attr: "filltype",
+		kind: "string"
+	},
+	{
+		field: "src",
+		attr: "src",
+		kind: "string"
+	},
+	{
+		field: "imageaspect",
+		attr: "imageaspect",
+		kind: "string"
+	},
+	{
+		field: "imagesize",
+		attr: "imagesize",
+		kind: "string"
+	},
+	{
+		field: "imagealignshape",
+		attr: "imagealignshape",
+		kind: "trueFalse"
+	},
+	{
+		field: "startarrow",
+		attr: "startarrow",
+		kind: "string"
+	},
+	{
+		field: "startarrowwidth",
+		attr: "startarrowwidth",
+		kind: "string"
+	},
+	{
+		field: "startarrowlength",
+		attr: "startarrowlength",
+		kind: "string"
+	},
+	{
+		field: "endarrow",
+		attr: "endarrow",
+		kind: "string"
+	},
+	{
+		field: "endarrowwidth",
+		attr: "endarrowwidth",
+		kind: "string"
+	},
+	{
+		field: "endarrowlength",
+		attr: "endarrowlength",
+		kind: "string"
+	},
+	{
+		field: "officeHref",
+		attr: "o:href",
+		kind: "string"
+	},
+	{
+		field: "officeAltHref",
+		attr: "o:althref",
+		kind: "string"
+	},
+	{
+		field: "officeTitle",
+		attr: "o:title",
+		kind: "string"
+	},
+	{
+		field: "forcedash",
+		attr: "o:forcedash",
+		kind: "trueFalse"
+	}
+];
+/** Serialize an o:left/top/right/bottom/column sub-stroke. */
+function stringifyVmlStrokeChild(tag, opts) {
+	return `<${tag}${stringifyVmlAttributes(opts, STROKE_CHILD_ATTRS)}/>`;
+}
+/** Parse an o: sub-stroke child of v:stroke. */
+function parseVmlStrokeChild(el) {
+	const out = {};
+	parseVmlAttributes(el, STROKE_CHILD_ATTRS, out);
+	return out;
+}
+/** Serialize v:stroke. */
+function stringifyVmlStroke(opts) {
+	const children = [];
+	if (opts.leftStroke !== void 0) children.push(stringifyVmlStrokeChild("o:left", opts.leftStroke));
+	if (opts.topStroke !== void 0) children.push(stringifyVmlStrokeChild("o:top", opts.topStroke));
+	if (opts.rightStroke !== void 0) children.push(stringifyVmlStrokeChild("o:right", opts.rightStroke));
+	if (opts.bottomStroke !== void 0) children.push(stringifyVmlStrokeChild("o:bottom", opts.bottomStroke));
+	if (opts.columnStroke !== void 0) children.push(stringifyVmlStrokeChild("o:column", opts.columnStroke));
+	const attrStr = stringifyVmlAttributes(opts, STROKE_ATTRS);
+	return children.length > 0 ? `<v:stroke${attrStr}>${children.join("")}</v:stroke>` : `<v:stroke${attrStr}/>`;
+}
+/** Parse a v:stroke element. */
+function parseVmlStroke(el) {
+	const out = {};
+	parseVmlAttributes(el, STROKE_ATTRS, out);
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		switch (child.name) {
+			case "o:left":
+				out.leftStroke = parseVmlStrokeChild(child);
+				break;
+			case "o:top":
+				out.topStroke = parseVmlStrokeChild(child);
+				break;
+			case "o:right":
+				out.rightStroke = parseVmlStrokeChild(child);
+				break;
+			case "o:bottom":
+				out.bottomStroke = parseVmlStrokeChild(child);
+				break;
+			case "o:column":
+				out.columnStroke = parseVmlStrokeChild(child);
+				break;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/vector/shape-elements/textbox.ts
+/**
+* Serialize v:textbox. Exactly one content form is emitted when present
+* (txbxContent wins if both are set, matching the XSD choice).
+*/
+function stringifyVmlTextbox(opts) {
+	const attrs = [];
+	if (opts.id !== void 0) attrs.push(`id="${escapeXml(opts.id)}"`);
+	if (opts.style !== void 0) attrs.push(`style="${escapeXml(stringifyVmlStyle(opts.style))}"`);
+	if (opts.inset !== void 0) attrs.push(`inset="${escapeXml(opts.inset)}"`);
+	if (opts.singleclick !== void 0) attrs.push(`o:singleclick="${stringifyVmlTrueFalse(opts.singleclick)}"`);
+	if (opts.insetmode !== void 0) attrs.push(`o:insetmode="${opts.insetmode}"`);
+	const attrStr = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
+	if (opts.txbxContent !== void 0) return `<v:textbox${attrStr}><w:txbxContent>${opts.txbxContent}</w:txbxContent></v:textbox>`;
+	if (opts.content !== void 0) return `<v:textbox${attrStr}>${opts.content}</v:textbox>`;
+	return `<v:textbox${attrStr}/>`;
+}
+/** Parse a v:textbox element. */
+function parseVmlTextbox(el) {
+	const out = {};
+	const attrs = el.attributes ?? {};
+	if (attrs.id !== void 0) out.id = String(attrs.id);
+	if (attrs.style !== void 0) out.style = parseVmlShapeStyle(parseVmlStyle(String(attrs.style)));
+	if (attrs.inset !== void 0) out.inset = String(attrs.inset);
+	if (attrs["o:singleclick"] !== void 0) out.singleclick = parseVmlTrueFalse(String(attrs["o:singleclick"]));
+	if (attrs["o:insetmode"] !== void 0) out.insetmode = String(attrs["o:insetmode"]);
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		if (child.name === "w:txbxContent") {
+			out.txbxContent = (child.elements ?? []).map((e) => stringifyElement(e)).join("");
+			break;
+		}
+		if (!child.name?.includes(":")) {
+			out.content = stringifyElement(child);
+			break;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/vector/shape-elements/textpath.ts
+const TEXT_PATH_STYLE_MAP = {
+	fontFamily: "font-family",
+	fontSize: "font-size",
+	fontWeight: "font-weight",
+	fontStyle: "font-style",
+	fontVariant: "font-variant",
+	textTransform: "text-transform",
+	textDecoration: "text-decoration",
+	letterSpacing: "letter-spacing",
+	vTextAlign: "v-text-align",
+	vTextKern: "v-text-kern",
+	vTextSpacing: "v-text-spacing",
+	vTextSpacingMode: "v-text-spacing-mode"
+};
+/** Serialize a VmlTextPathStyle to its CSS-stream form. */
+function stringifyVmlTextPathStyle(style) {
+	return Object.entries(style).map(([key, value]) => `${TEXT_PATH_STYLE_MAP[key]}:${value}`).join(";");
+}
+/** Parse a CSS stream into a VmlTextPathStyle; unmapped keys drop. */
+function parseVmlTextPathStyle(styleStr) {
+	const reverse = Object.fromEntries(Object.entries(TEXT_PATH_STYLE_MAP).map(([field, key]) => [key, field]));
+	const style = {};
+	for (const part of styleStr.split(";")) {
+		const [key, val] = part.split(":").map((s) => s.trim());
+		if (!key || !val) continue;
+		const field = reverse[key];
+		if (field) style[field] = val;
+	}
+	return style;
+}
+const TEXT_PATH_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "on",
+		attr: "on",
+		kind: "trueFalse"
+	},
+	{
+		field: "fitshape",
+		attr: "fitshape",
+		kind: "trueFalse"
+	},
+	{
+		field: "fitpath",
+		attr: "fitpath",
+		kind: "trueFalse"
+	},
+	{
+		field: "trim",
+		attr: "trim",
+		kind: "trueFalse"
+	},
+	{
+		field: "xscale",
+		attr: "xscale",
+		kind: "trueFalse"
+	},
+	{
+		field: "string",
+		attr: "string",
+		kind: "string"
+	}
+];
+/** Serialize v:textpath. */
+function stringifyVmlTextPath(opts) {
+	const attrStr = stringifyVmlAttributes(opts, TEXT_PATH_ATTRS);
+	if (opts.style !== void 0) return `<v:textpath${attrStr} style="${escapeXml(stringifyVmlTextPathStyle(opts.style))}"/>`;
+	return `<v:textpath${attrStr}/>`;
+}
+/** Parse a v:textpath element. */
+function parseVmlTextPath(el) {
+	const out = {};
+	parseVmlAttributes(el, TEXT_PATH_ATTRS, out);
+	if (el.attributes?.style !== void 0) out.style = parseVmlTextPathStyle(String(el.attributes.style));
+	return out;
+}
+//#endregion
+//#region src/vector/shape-elements/word-elements.ts
+const WRAP_ATTRS = [
+	{
+		field: "type",
+		attr: "type",
+		kind: "string"
+	},
+	{
+		field: "side",
+		attr: "side",
+		kind: "string"
+	},
+	{
+		field: "anchorx",
+		attr: "anchorx",
+		kind: "string"
+	},
+	{
+		field: "anchory",
+		attr: "anchory",
+		kind: "string"
+	}
+];
+/** Serialize w10:wrap. */
+function stringifyVmlWrap(opts) {
+	return `<w10:wrap${stringifyVmlAttributes(opts, WRAP_ATTRS)}/>`;
+}
+/** Parse a w10:wrap element. */
+function parseVmlWrap(el) {
+	const out = {};
+	parseVmlAttributes(el, WRAP_ATTRS, out);
+	return out;
+}
+/** Serialize w10:anchorlock. */
+function stringifyVmlAnchorLock(_opts) {
+	return "<w10:anchorlock/>";
+}
+/** Parse a w10:anchorlock element. */
+function parseVmlAnchorLock(_el) {
+	return {};
+}
+const BORDER_ATTRS = [
+	{
+		field: "type",
+		attr: "type",
+		kind: "string"
+	},
+	{
+		field: "width",
+		attr: "width",
+		kind: "number"
+	},
+	{
+		field: "shadow",
+		attr: "shadow",
+		kind: "trueFalseBlank"
+	}
+];
+/** The four w10: border element names. */
+const VML_BORDER_TAGS = [
+	"w10:bordertop",
+	"w10:borderleft",
+	"w10:borderright",
+	"w10:borderbottom"
+];
+/** Serialize a w10: border element. */
+function stringifyVmlBorder(tag, opts) {
+	return `<${tag}${stringifyVmlAttributes(opts, BORDER_ATTRS)}/>`;
+}
+/** Parse a w10: border element. */
+function parseVmlBorder(el) {
+	const out = {};
+	parseVmlAttributes(el, BORDER_ATTRS, out);
+	return out;
+}
+//#endregion
+//#region src/vector/shapes.ts
+/** Next spid in the `_x0000_s` segment (Word hands out shape ids from 1025). */
+let nextSpid = 1024;
+/**
+* Allocate the next VML shape id (`_x0000_s1025`, `_x0000_s1026`, …).
+* Ids only need to be unique within a document; the counter is process-global
+* so concurrent generations never collide.
+*/
+function nextVmlShapeId() {
+	return `_x0000_s${++nextSpid}`;
+}
+const GROUP_FILL_ATTRS = [{
+	field: "filled",
+	attr: "filled",
+	kind: "trueFalse"
+}, {
+	field: "fillcolor",
+	attr: "fillcolor",
+	kind: "string"
+}];
+const ARC_ATTRS = [{
+	field: "startAngle",
+	attr: "startAngle",
+	kind: "number"
+}, {
+	field: "endAngle",
+	attr: "endAngle",
+	kind: "number"
+}];
+const CURVE_ATTRS = [
+	{
+		field: "from",
+		attr: "from",
+		kind: "string"
+	},
+	{
+		field: "control1",
+		attr: "control1",
+		kind: "string"
+	},
+	{
+		field: "control2",
+		attr: "control2",
+		kind: "string"
+	},
+	{
+		field: "to",
+		attr: "to",
+		kind: "string"
+	}
+];
+const IMAGE_ATTRS = [
+	{
+		field: "src",
+		attr: "src",
+		kind: "string"
+	},
+	{
+		field: "cropleft",
+		attr: "cropleft",
+		kind: "string"
+	},
+	{
+		field: "croptop",
+		attr: "croptop",
+		kind: "string"
+	},
+	{
+		field: "cropright",
+		attr: "cropright",
+		kind: "string"
+	},
+	{
+		field: "cropbottom",
+		attr: "cropbottom",
+		kind: "string"
+	},
+	{
+		field: "gain",
+		attr: "gain",
+		kind: "string"
+	},
+	{
+		field: "blacklevel",
+		attr: "blacklevel",
+		kind: "string"
+	},
+	{
+		field: "gamma",
+		attr: "gamma",
+		kind: "string"
+	},
+	{
+		field: "grayscale",
+		attr: "grayscale",
+		kind: "trueFalse"
+	},
+	{
+		field: "bilevel",
+		attr: "bilevel",
+		kind: "trueFalse"
+	}
+];
+const LINE_ATTRS = [{
+	field: "from",
+	attr: "from",
+	kind: "string"
+}, {
+	field: "to",
+	attr: "to",
+	kind: "string"
+}];
+const POLYLINE_ATTRS = [{
+	field: "points",
+	attr: "points",
+	kind: "string"
+}];
+const ROUNDRECT_ATTRS = [{
+	field: "arcsize",
+	attr: "arcsize",
+	kind: "string"
+}];
+/** The full AG_AllCoreAttributes + AG_AllShapeAttributes table. */
+const ALL_SHAPE_ATTRS = [
+	...VML_CORE_ATTRS,
+	...VML_OFFICE_CORE_ATTRS,
+	...VML_SHAPE_ATTRS,
+	...VML_OFFICE_SHAPE_ATTRS
+];
+/** Serialize the shared attribute vocabulary (style special-cased) plus extras. */
+function stringifyShapeAttrs(opts, extraSpecs = []) {
+	let attrStr = stringifyVmlAttributes(opts, [...ALL_SHAPE_ATTRS, ...extraSpecs]);
+	const style = opts.style;
+	if (style !== void 0) attrStr += ` style="${escapeXml(stringifyVmlStyle(style))}"`;
+	return attrStr;
+}
+/** Serialize the EG_ShapeElements children present on `opts`, in declaration order. */
+function stringifyShapeElements(opts) {
+	const parts = [];
+	if (opts.pathElement !== void 0) parts.push(stringifyVmlPath(opts.pathElement));
+	if (opts.formulas !== void 0) parts.push(stringifyVmlFormulas(opts.formulas));
+	if (opts.handles !== void 0) parts.push(stringifyVmlHandles(opts.handles));
+	if (opts.fill !== void 0) parts.push(stringifyVmlFill(opts.fill));
+	if (opts.stroke !== void 0) parts.push(stringifyVmlStroke(opts.stroke));
+	if (opts.shadow !== void 0) parts.push(stringifyVmlShadow(opts.shadow));
+	if (opts.textbox !== void 0) parts.push(stringifyVmlTextbox(opts.textbox));
+	if (opts.textpath !== void 0) parts.push(stringifyVmlTextPath(opts.textpath));
+	if (opts.imagedata !== void 0) parts.push(stringifyVmlImageData(opts.imagedata));
+	if (opts.skew !== void 0) parts.push(stringifyVmlSkew(opts.skew));
+	if (opts.extrusion !== void 0) parts.push(stringifyVmlExtrusion(opts.extrusion));
+	if (opts.callout !== void 0) parts.push(stringifyVmlCallout(opts.callout));
+	if (opts.lock !== void 0) parts.push(stringifyVmlLock(opts.lock));
+	if (opts.clippath !== void 0) parts.push(stringifyVmlClipPath(opts.clippath));
+	if (opts.signatureline !== void 0) parts.push(stringifyVmlSignatureLine(opts.signatureline));
+	if (opts.wrap !== void 0) parts.push(stringifyVmlWrap(opts.wrap));
+	if (opts.anchorlock !== void 0) parts.push(stringifyVmlAnchorLock(opts.anchorlock));
+	if (opts.bordertop !== void 0) parts.push(stringifyVmlBorder("w10:bordertop", opts.bordertop));
+	if (opts.borderbottom !== void 0) parts.push(stringifyVmlBorder("w10:borderbottom", opts.borderbottom));
+	if (opts.borderleft !== void 0) parts.push(stringifyVmlBorder("w10:borderleft", opts.borderleft));
+	if (opts.borderright !== void 0) parts.push(stringifyVmlBorder("w10:borderright", opts.borderright));
+	if (opts.clientData !== void 0) parts.push(stringifyVmlClientData(opts.clientData));
+	if (opts.textdata !== void 0) parts.push(stringifyVmlTextData(opts.textdata));
+	return parts.join("");
+}
+/** Parse the shared attribute vocabulary plus extras onto `out`. */
+function parseShapeAttrs(el, out, extraSpecs = []) {
+	parseVmlAttributes(el, [...ALL_SHAPE_ATTRS, ...extraSpecs], out);
+	if (el.attributes?.style !== void 0) out.style = parseVmlShapeStyle(parseVmlStyle(String(el.attributes.style)));
+	if (el.attributes?.path !== void 0) out.path = String(el.attributes.path);
+}
+/** Parse the EG_ShapeElements children from `el` onto `out`. */
+function parseShapeElements(el, out) {
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		switch (child.name) {
+			case "v:path":
+				out.pathElement = parseVmlPath(child);
+				break;
+			case "v:formulas":
+				out.formulas = parseVmlFormulas(child);
+				break;
+			case "v:handles":
+				out.handles = parseVmlHandles(child);
+				break;
+			case "v:fill":
+				out.fill = parseVmlFill(child);
+				break;
+			case "v:stroke":
+				out.stroke = parseVmlStroke(child);
+				break;
+			case "v:shadow":
+				out.shadow = parseVmlShadow(child);
+				break;
+			case "v:textbox":
+				out.textbox = parseVmlTextbox(child);
+				break;
+			case "v:textpath":
+				out.textpath = parseVmlTextPath(child);
+				break;
+			case "v:imagedata":
+				out.imagedata = parseVmlImageData(child);
+				break;
+			case "o:skew":
+				out.skew = parseVmlSkew(child);
+				break;
+			case "o:extrusion":
+				out.extrusion = parseVmlExtrusion(child);
+				break;
+			case "o:callout":
+				out.callout = parseVmlCallout(child);
+				break;
+			case "o:lock":
+				out.lock = parseVmlLock(child);
+				break;
+			case "o:clippath":
+				out.clippath = parseVmlClipPath(child);
+				break;
+			case "o:signatureline":
+				out.signatureline = parseVmlSignatureLine(child);
+				break;
+			case "w10:wrap":
+				out.wrap = parseVmlWrap(child);
+				break;
+			case "w10:anchorlock":
+				out.anchorlock = parseVmlAnchorLock(child);
+				break;
+			case "w10:bordertop":
+				out.bordertop = parseVmlBorder(child);
+				break;
+			case "w10:borderbottom":
+				out.borderbottom = parseVmlBorder(child);
+				break;
+			case "w10:borderleft":
+				out.borderleft = parseVmlBorder(child);
+				break;
+			case "w10:borderright":
+				out.borderright = parseVmlBorder(child);
+				break;
+			case "x:ClientData":
+				out.clientData = parseVmlClientData(child);
+				break;
+			case "pvml:textdata":
+				out.textdata = parseVmlTextData(child);
+				break;
+			case "pvml:iscomment":
+				out.iscomment = parseVmlIsComment(child);
+				break;
+		}
+	}
+}
+/** Generic shape element serializer: tag + shared/extra attrs + @path + children. */
+function stringifyShapeElement(tag, opts, extraSpecs = [], extraAttrStrings = [], childrenXml = "") {
+	const attrStr = stringifyShapeAttrs(opts, extraSpecs) + (extraAttrStrings.length > 0 ? " " + extraAttrStrings.join(" ") : "");
+	return childrenXml !== "" ? `<${tag}${attrStr}>${childrenXml}</${tag}>` : `<${tag}${attrStr}/>`;
+}
+const SHAPE_EXTRA_ATTRS = [
+	{
+		field: "type",
+		attr: "type",
+		kind: "string"
+	},
+	{
+		field: "adj",
+		attr: "adj",
+		kind: "string"
+	},
+	{
+		field: "gfxdata",
+		attr: "o:gfxdata",
+		kind: "string"
+	},
+	{
+		field: "equationxml",
+		attr: "equationxml",
+		kind: "string"
+	}
+];
+/** Serialize v:shape. */
+function stringifyVmlShape(opts) {
+	const extra = opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [];
+	let children = stringifyShapeElements(opts);
+	if (opts.ink !== void 0) children += stringifyVmlInk(opts.ink);
+	if (opts.equationxmlElement !== void 0) children += stringifyVmlEquationXml(opts.equationxmlElement);
+	if (opts.iscomment !== void 0) children += stringifyVmlIsComment(opts.iscomment);
+	return stringifyShapeElement("v:shape", opts, SHAPE_EXTRA_ATTRS, extra, children);
+}
+/** Parse a v:shape element. */
+function parseVmlShape(el) {
+	const out = {};
+	parseShapeAttrs(el, out, SHAPE_EXTRA_ATTRS);
+	parseShapeElements(el, out);
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		if (child.name === "o:ink") out.ink = parseVmlInk(child);
+		else if (child.name === "o:equationxml") out.equationxmlElement = parseVmlEquationXml(child);
+	}
+	return out;
+}
+const SHAPETYPE_EXTRA_ATTRS = [{
+	field: "adj",
+	attr: "adj",
+	kind: "string"
+}, {
+	field: "master",
+	attr: "o:master",
+	kind: "string"
+}];
+/** Serialize v:shapetype. */
+function stringifyVmlShapetype(opts) {
+	const extra = opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [];
+	let children = stringifyShapeElements(opts);
+	if (opts.complex !== void 0) children += stringifyVmlComplex(opts.complex);
+	return stringifyShapeElement("v:shapetype", opts, SHAPETYPE_EXTRA_ATTRS, extra, children);
+}
+/** Parse a v:shapetype element. */
+function parseVmlShapetype(el) {
+	const out = {};
+	parseShapeAttrs(el, out, SHAPETYPE_EXTRA_ATTRS);
+	parseShapeElements(el, out);
+	for (const child of el.elements ?? []) if (child.type === "element" && child.name === "o:complex") {
+		out.complex = parseVmlComplex(child);
+		break;
+	}
+	return out;
+}
+/** Serialize one VmlGroupChild. */
+function stringifyGroupChild(child) {
+	if ("shape" in child) return stringifyVmlShape(child.shape);
+	if ("shapetype" in child) return stringifyVmlShapetype(child.shapetype);
+	if ("group" in child) return stringifyVmlGroup(child.group);
+	if ("arc" in child) return stringifyVmlArc(child.arc);
+	if ("curve" in child) return stringifyVmlCurve(child.curve);
+	if ("image" in child) return stringifyVmlImage(child.image);
+	if ("line" in child) return stringifyVmlLine(child.line);
+	if ("oval" in child) return stringifyVmlOval(child.oval);
+	if ("polyline" in child) return stringifyVmlPolyline(child.polyline);
+	if ("rect" in child) return stringifyVmlRect(child.rect);
+	return stringifyVmlRoundRect(child.roundrect);
+}
+/** CT_Group attribute table — AG_AllCoreAttributes + AG_Fill + editas + table props. */
+const GROUP_ATTRS = [
+	...VML_CORE_ATTRS,
+	...VML_OFFICE_CORE_ATTRS,
+	...GROUP_FILL_ATTRS,
+	{
+		field: "editas",
+		attr: "editas",
+		kind: "string"
+	},
+	{
+		field: "tableproperties",
+		attr: "o:tableproperties",
+		kind: "string"
+	},
+	{
+		field: "tablelimits",
+		attr: "o:tablelimits",
+		kind: "string"
+	}
+];
+/** Serialize v:group. */
+function stringifyVmlGroup(opts) {
+	let children = (opts.children ?? []).map(stringifyGroupChild).join("") + stringifyShapeElements(opts);
+	if (opts.diagram !== void 0) children += stringifyVmlDiagram(opts.diagram);
+	const attrStr = stringifyVmlAttributes(opts, GROUP_ATTRS) + (opts.path !== void 0 ? ` path="${escapeXml(opts.path)}"` : "");
+	const style = opts.style;
+	const styleStr = style !== void 0 ? ` style="${escapeXml(stringifyVmlStyle(style))}"` : "";
+	return children !== "" ? `<v:group${attrStr}${styleStr}>${children}</v:group>` : `<v:group${attrStr}${styleStr}/>`;
+}
+/** Parse a v:group element. */
+function parseVmlGroup(el) {
+	const out = {};
+	parseVmlAttributes(el, GROUP_ATTRS, out);
+	if (el.attributes?.style !== void 0) out.style = parseVmlShapeStyle(parseVmlStyle(String(el.attributes.style)));
+	if (el.attributes?.path !== void 0 && out.path === void 0) out.path = String(el.attributes.path);
+	parseShapeElements(el, out);
+	const children = [];
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		switch (child.name) {
+			case "v:shape":
+				children.push({ shape: parseVmlShape(child) });
+				break;
+			case "v:shapetype":
+				children.push({ shapetype: parseVmlShapetype(child) });
+				break;
+			case "v:group":
+				children.push({ group: parseVmlGroup(child) });
+				break;
+			case "v:arc":
+				children.push({ arc: parseVmlArc(child) });
+				break;
+			case "v:curve":
+				children.push({ curve: parseVmlCurve(child) });
+				break;
+			case "v:image":
+				children.push({ image: parseVmlImage(child) });
+				break;
+			case "v:line":
+				children.push({ line: parseVmlLine(child) });
+				break;
+			case "v:oval":
+				children.push({ oval: parseVmlOval(child) });
+				break;
+			case "v:polyline":
+				children.push({ polyline: parseVmlPolyline(child) });
+				break;
+			case "v:rect":
+				children.push({ rect: parseVmlRect(child) });
+				break;
+			case "v:roundrect":
+				children.push({ roundrect: parseVmlRoundRect(child) });
+				break;
+			case "o:diagram":
+				out.diagram = parseVmlDiagram(child);
+				break;
+		}
+	}
+	if (children.length > 0) out.children = children;
+	return out;
+}
+const BACKGROUND_ATTRS = [
+	{
+		field: "id",
+		attr: "id",
+		kind: "string"
+	},
+	{
+		field: "filled",
+		attr: "filled",
+		kind: "trueFalse"
+	},
+	{
+		field: "fillcolor",
+		attr: "fillcolor",
+		kind: "string"
+	},
+	{
+		field: "bwmode",
+		attr: "o:bwmode",
+		kind: "string"
+	},
+	{
+		field: "bwpure",
+		attr: "o:bwpure",
+		kind: "string"
+	},
+	{
+		field: "bwnormal",
+		attr: "o:bwnormal",
+		kind: "string"
+	},
+	{
+		field: "targetscreensize",
+		attr: "o:targetscreensize",
+		kind: "string"
+	}
+];
+/** Serialize v:background. */
+function stringifyVmlBackground(opts) {
+	const attrStr = stringifyVmlAttributes(opts, BACKGROUND_ATTRS);
+	const fillXml = opts.fill !== void 0 ? stringifyVmlFill(opts.fill) : "";
+	return fillXml !== "" ? `<v:background${attrStr}>${fillXml}</v:background>` : `<v:background${attrStr}/>`;
+}
+/** Parse a v:background element. */
+function parseVmlBackground(el) {
+	const out = {};
+	parseVmlAttributes(el, BACKGROUND_ATTRS, out);
+	for (const child of el.elements ?? []) if (child.type === "element" && child.name === "v:fill") {
+		out.fill = parseVmlFill(child);
+		break;
+	}
+	return out;
+}
+/** Serialize v:arc. */
+function stringifyVmlArc(opts) {
+	return stringifyShapeElement("v:arc", opts, ARC_ATTRS, opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [], stringifyShapeElements(opts));
+}
+/** Parse a v:arc element. */
+function parseVmlArc(el) {
+	const out = {};
+	parseShapeAttrs(el, out, ARC_ATTRS);
+	parseShapeElements(el, out);
+	return out;
+}
+/** Serialize v:curve. */
+function stringifyVmlCurve(opts) {
+	return stringifyShapeElement("v:curve", opts, CURVE_ATTRS, opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [], stringifyShapeElements(opts));
+}
+/** Parse a v:curve element. */
+function parseVmlCurve(el) {
+	const out = {};
+	parseShapeAttrs(el, out, CURVE_ATTRS);
+	parseShapeElements(el, out);
+	return out;
+}
+/** Serialize v:image. */
+function stringifyVmlImage(opts) {
+	return stringifyShapeElement("v:image", opts, IMAGE_ATTRS, opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [], stringifyShapeElements(opts));
+}
+/** Parse a v:image element. */
+function parseVmlImage(el) {
+	const out = {};
+	parseShapeAttrs(el, out, IMAGE_ATTRS);
+	parseShapeElements(el, out);
+	return out;
+}
+/** Serialize v:line. */
+function stringifyVmlLine(opts) {
+	return stringifyShapeElement("v:line", opts, LINE_ATTRS, opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [], stringifyShapeElements(opts));
+}
+/** Parse a v:line element. */
+function parseVmlLine(el) {
+	const out = {};
+	parseShapeAttrs(el, out, LINE_ATTRS);
+	parseShapeElements(el, out);
+	return out;
+}
+/** Serialize v:oval. */
+function stringifyVmlOval(opts) {
+	return stringifyShapeElement("v:oval", opts, [], opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [], stringifyShapeElements(opts));
+}
+/** Parse a v:oval element. */
+function parseVmlOval(el) {
+	const out = {};
+	parseShapeAttrs(el, out);
+	parseShapeElements(el, out);
+	return out;
+}
+/** Serialize v:polyline. */
+function stringifyVmlPolyline(opts) {
+	const children = stringifyShapeElements(opts) + (opts.ink !== void 0 ? stringifyVmlInk(opts.ink) : "");
+	return stringifyShapeElement("v:polyline", opts, POLYLINE_ATTRS, opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [], children);
+}
+/** Parse a v:polyline element. */
+function parseVmlPolyline(el) {
+	const out = {};
+	parseShapeAttrs(el, out, POLYLINE_ATTRS);
+	parseShapeElements(el, out);
+	for (const child of el.elements ?? []) if (child.type === "element" && child.name === "o:ink") {
+		out.ink = parseVmlInk(child);
+		break;
+	}
+	return out;
+}
+/** Serialize v:rect. */
+function stringifyVmlRect(opts) {
+	return stringifyShapeElement("v:rect", opts, [], opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [], stringifyShapeElements(opts));
+}
+/** Parse a v:rect element. */
+function parseVmlRect(el) {
+	const out = {};
+	parseShapeAttrs(el, out);
+	parseShapeElements(el, out);
+	return out;
+}
+/** Serialize v:roundrect. */
+function stringifyVmlRoundRect(opts) {
+	return stringifyShapeElement("v:roundrect", opts, ROUNDRECT_ATTRS, opts.path !== void 0 ? [`path="${escapeXml(opts.path)}"`] : [], stringifyShapeElements(opts));
+}
+/** Parse a v:roundrect element. */
+function parseVmlRoundRect(el) {
+	const out = {};
+	parseShapeAttrs(el, out, ROUNDRECT_ATTRS);
+	parseShapeElements(el, out);
+	return out;
+}
+//#endregion
+//#region src/vector/office-shape-defaults.ts
+const SHAPEDEFAULTS_ATTRS = [
+	{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	},
+	{
+		field: "spidmax",
+		attr: "spidmax",
+		kind: "number"
+	},
+	{
+		field: "style",
+		attr: "style",
+		kind: "string"
+	},
+	{
+		field: "fill",
+		attr: "fill",
+		kind: "trueFalse"
+	},
+	{
+		field: "fillcolor",
+		attr: "fillcolor",
+		kind: "string"
+	},
+	{
+		field: "stroke",
+		attr: "stroke",
+		kind: "trueFalse"
+	},
+	{
+		field: "strokecolor",
+		attr: "strokecolor",
+		kind: "string"
+	},
+	{
+		field: "allowincell",
+		attr: "o:allowincell",
+		kind: "trueFalse"
+	}
+];
+/** Serialize o:shapedefaults. */
+function stringifyVmlShapeDefaults(opts) {
+	const children = [];
+	if (opts.fillElement !== void 0) children.push(stringifyVmlFill(opts.fillElement));
+	if (opts.strokeElement !== void 0) children.push(stringifyVmlStroke(opts.strokeElement));
+	if (opts.textbox !== void 0) children.push(stringifyVmlTextbox(opts.textbox));
+	if (opts.shadow !== void 0) children.push(stringifyVmlShadow(opts.shadow));
+	if (opts.skew !== void 0) children.push(stringifyVmlSkew(opts.skew));
+	if (opts.extrusion !== void 0) children.push(stringifyVmlExtrusion(opts.extrusion));
+	if (opts.callout !== void 0) children.push(stringifyVmlCallout(opts.callout));
+	if (opts.lock !== void 0) children.push(stringifyVmlLock(opts.lock));
+	if (opts.colormru !== void 0) children.push(stringifyVmlColorMru(opts.colormru));
+	if (opts.colormenu !== void 0) children.push(stringifyVmlColorMenu(opts.colormenu));
+	const attrStr = stringifyVmlAttributes(opts, SHAPEDEFAULTS_ATTRS);
+	return children.length > 0 ? `<o:shapedefaults${attrStr}>${children.join("")}</o:shapedefaults>` : `<o:shapedefaults${attrStr}/>`;
+}
+/** Parse an o:shapedefaults element. */
+function parseVmlShapeDefaults(el) {
+	const out = {};
+	parseVmlAttributes(el, SHAPEDEFAULTS_ATTRS, out);
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		switch (child.name) {
+			case "v:fill":
+				out.fillElement = parseVmlFill(child);
+				break;
+			case "v:stroke":
+				out.strokeElement = parseVmlStroke(child);
+				break;
+			case "v:textbox":
+				out.textbox = parseVmlTextbox(child);
+				break;
+			case "v:shadow":
+				out.shadow = parseVmlShadow(child);
+				break;
+			case "o:skew":
+				out.skew = parseVmlSkew(child);
+				break;
+			case "o:extrusion":
+				out.extrusion = parseVmlExtrusion(child);
+				break;
+			case "o:callout":
+				out.callout = parseVmlCallout(child);
+				break;
+			case "o:lock":
+				out.lock = parseVmlLock(child);
+				break;
+			case "o:colormru":
+				out.colormru = parseVmlColorMru(child);
+				break;
+			case "o:colormenu":
+				out.colormenu = parseVmlColorMenu(child);
+				break;
+		}
+	}
+	return out;
+}
+/** Serialize o:colormru. */
+function stringifyVmlColorMru(opts) {
+	return `<o:colormru${stringifyVmlAttributes(opts, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}, {
+		field: "colors",
+		attr: "colors",
+		kind: "string"
+	}])}/>`;
+}
+/** Parse an o:colormru element. */
+function parseVmlColorMru(el) {
+	const out = {};
+	parseVmlAttributes(el, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}, {
+		field: "colors",
+		attr: "colors",
+		kind: "string"
+	}], out);
+	return out;
+}
+const COLORMENU_ATTRS = [
+	{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	},
+	{
+		field: "strokecolor",
+		attr: "strokecolor",
+		kind: "string"
+	},
+	{
+		field: "fillcolor",
+		attr: "fillcolor",
+		kind: "string"
+	},
+	{
+		field: "shadowcolor",
+		attr: "shadowcolor",
+		kind: "string"
+	},
+	{
+		field: "extrusioncolor",
+		attr: "extrusioncolor",
+		kind: "string"
+	}
+];
+/** Serialize o:colormenu. */
+function stringifyVmlColorMenu(opts) {
+	return `<o:colormenu${stringifyVmlAttributes(opts, COLORMENU_ATTRS)}/>`;
+}
+/** Parse an o:colormenu element. */
+function parseVmlColorMenu(el) {
+	const out = {};
+	parseVmlAttributes(el, COLORMENU_ATTRS, out);
+	return out;
+}
+const ENTRY_ATTRS = [{
+	field: "new",
+	attr: "new",
+	kind: "number"
+}, {
+	field: "old",
+	attr: "old",
+	kind: "number"
+}];
+/** Serialize an o:idmap. */
+function stringifyVmlIdMap(opts) {
+	return `<o:idmap${stringifyVmlAttributes(opts, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}, {
+		field: "data",
+		attr: "data",
+		kind: "string"
+	}])}/>`;
+}
+/** Parse an o:idmap element. */
+function parseVmlIdMap(el) {
+	const out = {};
+	parseVmlAttributes(el, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}, {
+		field: "data",
+		attr: "data",
+		kind: "string"
+	}], out);
+	return out;
+}
+/** Serialize an o:regrouptable. */
+function stringifyVmlRegroupTable(opts) {
+	const entries = (opts.entries ?? []).map((entry) => `<o:entry${stringifyVmlAttributes(entry, ENTRY_ATTRS)}/>`).join("");
+	return `<o:regrouptable${stringifyVmlAttributes(opts, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}])}>${entries}</o:regrouptable>`;
+}
+/** Parse an o:regrouptable element. */
+function parseVmlRegroupTable(el) {
+	const out = {};
+	parseVmlAttributes(el, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}], out);
+	const entries = [];
+	for (const child of el.elements ?? []) if (child.type === "element" && child.name === "o:entry") {
+		const entry = {};
+		parseVmlAttributes(child, ENTRY_ATTRS, entry);
+		entries.push(entry);
+	}
+	if (entries.length > 0) out.entries = entries;
+	return out;
+}
+/** Serialize a proxy child inside an o:r. */
+function stringifyVmlRuleProxy(proxy) {
+	const attrs = [];
+	if (proxy.start !== void 0) attrs.push(`start="${proxy.start === "" ? "" : proxy.start ? "t" : "f"}"`);
+	if (proxy.end !== void 0) attrs.push(`end="${proxy.end === "" ? "" : proxy.end ? "t" : "f"}"`);
+	if (proxy.idref !== void 0) attrs.push(`idref="${proxy.idref}"`);
+	if (proxy.connectloc !== void 0) attrs.push(`connectloc="${proxy.connectloc}"`);
+	return `<o:proxy${attrs.length > 0 ? " " + attrs.join(" ") : ""}/>`;
+}
+/** Parse an o:proxy element. */
+function parseVmlRuleProxy(el) {
+	const out = {};
+	const attrs = el.attributes ?? {};
+	if (attrs.start !== void 0) {
+		const raw = String(attrs.start);
+		out.start = raw === "" ? "" : raw === "t" || raw === "true" || raw === "1";
+	}
+	if (attrs.end !== void 0) {
+		const raw = String(attrs.end);
+		out.end = raw === "" ? "" : raw === "t" || raw === "true" || raw === "1";
+	}
+	if (attrs.idref !== void 0) out.idref = String(attrs.idref);
+	if (attrs.connectloc !== void 0) out.connectloc = Number(attrs.connectloc);
+	return out;
+}
+/** Serialize an o:r (hand-written — `id` is required, so no table-driven cast). */
+function stringifyVmlRule(rule) {
+	const attrs = [`id="${rule.id}"`];
+	if (rule.type !== void 0) attrs.push(`type="${rule.type}"`);
+	if (rule.how !== void 0) attrs.push(`how="${rule.how}"`);
+	if (rule.idref !== void 0) attrs.push(`idref="${rule.idref}"`);
+	const proxies = (rule.proxies ?? []).map(stringifyVmlRuleProxy).join("");
+	return `<o:r${attrs.length > 0 ? " " + attrs.join(" ") : ""}>${proxies}</o:r>`;
+}
+/** Parse an o:r element. */
+function parseVmlRule(el) {
+	const attrs = el.attributes ?? {};
+	const out = { id: String(attrs.id ?? "") };
+	if (attrs.type !== void 0) out.type = String(attrs.type);
+	if (attrs.how !== void 0) out.how = String(attrs.how);
+	if (attrs.idref !== void 0) out.idref = String(attrs.idref);
+	const proxies = [];
+	for (const child of el.elements ?? []) if (child.type === "element" && child.name === "o:proxy") proxies.push(parseVmlRuleProxy(child));
+	if (proxies.length > 0) out.proxies = proxies;
+	return out;
+}
+/** Serialize an o:rules block. */
+function stringifyVmlRulesBlock(opts) {
+	const rules = (opts.rules ?? []).map(stringifyVmlRule).join("");
+	return `<o:rules${stringifyVmlAttributes(opts, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}])}>${rules}</o:rules>`;
+}
+/** Parse an o:rules element. */
+function parseVmlRulesBlock(el) {
+	const out = {};
+	parseVmlAttributes(el, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}], out);
+	const rules = [];
+	for (const child of el.elements ?? []) if (child.type === "element" && child.name === "o:r") rules.push(parseVmlRule(child));
+	if (rules.length > 0) out.rules = rules;
+	return out;
+}
+/** Serialize o:shapelayout. */
+function stringifyVmlShapeLayout(opts) {
+	const children = [];
+	if (opts.idmap !== void 0) children.push(stringifyVmlIdMap(opts.idmap));
+	if (opts.regrouptable !== void 0) children.push(stringifyVmlRegroupTable(opts.regrouptable));
+	if (opts.rules !== void 0) children.push(stringifyVmlRulesBlock(opts.rules));
+	const attrStr = stringifyVmlAttributes(opts, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}]);
+	return children.length > 0 ? `<o:shapelayout${attrStr}>${children.join("")}</o:shapelayout>` : `<o:shapelayout${attrStr}/>`;
+}
+/** Parse an o:shapelayout element. */
+function parseVmlShapeLayout(el) {
+	const out = {};
+	parseVmlAttributes(el, [{
+		field: "ext",
+		attr: "v:ext",
+		kind: "string"
+	}], out);
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		if (child.name === "o:idmap") out.idmap = parseVmlIdMap(child);
+		else if (child.name === "o:regrouptable") out.regrouptable = parseVmlRegroupTable(child);
+		else if (child.name === "o:rules") out.rules = parseVmlRulesBlock(child);
+	}
+	return out;
+}
+//#endregion
+export { parseVmlPath as $, stringifyVmlRect as A, stringifyVmlLock as At, stringifyVmlWrap as B, parseVmlTrueFalse as Bt, stringifyVmlBackground as C, stringifyVmlCallout as Ct, stringifyVmlLine as D, stringifyVmlEquationXml as Dt, stringifyVmlImage as E, stringifyVmlDiagram as Et, parseVmlAnchorLock as F, VML_CORE_ATTRS as Ft, parseVmlStroke as G, parseVmlShapeStyle as Gt, stringifyVmlTextPath as H, stringifyVmlAttributes as Ht, parseVmlBorder as I, VML_OFFICE_CORE_ATTRS as It, stringifyVmlShadow as J, styleToKeyMap as Jt, stringifyVmlStroke as K, parseVmlStyle as Kt, parseVmlWrap as L, VML_OFFICE_SHAPE_ATTRS as Lt, stringifyVmlShape as M, stringifyVmlOleObject as Mt, stringifyVmlShapetype as N, stringifyVmlSignatureLine as Nt, stringifyVmlOval as O, stringifyVmlExtrusion as Ot, VML_BORDER_TAGS as P, stringifyVmlSkew as Pt, stringifyVmlTextData as Q, stringifyVmlAnchorLock as R, VML_SHAPE_ATTRS as Rt, stringifyVmlArc as S, parseVmlSkew as St, stringifyVmlGroup as T, stringifyVmlComplex as Tt, parseVmlTextbox as U, stringifyVmlTrueFalse as Ut, parseVmlTextPath as V, parseVmlTrueFalseBlank as Vt, stringifyVmlTextbox as W, stringifyVmlTrueFalseBlank as Wt, parseVmlTextData as X, parseVmlIsComment as Y, stringifyVmlIsComment as Z, parseVmlPolyline as _, parseVmlInk as _t, stringifyVmlColorMenu as a, parseVmlFormulas as at, parseVmlShape as b, parseVmlOleObject as bt, stringifyVmlShapeLayout as c, stringifyVmlFill as ct, parseVmlBackground as d, parseVmlCallout as dt, stringifyVmlPath as et, parseVmlCurve as f, parseVmlClipPath as ft, parseVmlOval as g, parseVmlExtrusion as gt, parseVmlLine as h, parseVmlEquationXml as ht, parseVmlShapeLayout as i, stringifyVmlHandles as it, stringifyVmlRoundRect as j, stringifyVmlOfficeFill as jt, stringifyVmlPolyline as k, stringifyVmlInk as kt, nextVmlShapeId as l, parseVmlClientData as lt, parseVmlImage as m, parseVmlDiagram as mt, parseVmlColorMru as n, stringifyVmlImageData as nt, stringifyVmlColorMru as o, stringifyVmlFormulas as ot, parseVmlGroup as p, parseVmlComplex as pt, parseVmlShadow as q, stringifyVmlStyle as qt, parseVmlShapeDefaults as r, parseVmlHandles as rt, stringifyVmlShapeDefaults as s, parseVmlFill as st, parseVmlColorMenu as t, parseVmlImageData as tt, parseVmlArc as u, stringifyVmlClientData as ut, parseVmlRect as v, parseVmlLock as vt, stringifyVmlCurve as w, stringifyVmlClipPath as wt, parseVmlShapetype as x, parseVmlSignatureLine as xt, parseVmlRoundRect as y, parseVmlOfficeFill as yt, stringifyVmlBorder as z, parseVmlAttributes as zt };
+
+//# sourceMappingURL=vector-TpjW6ZSc.mjs.map