@office-open/core 0.10.15 → 0.12.0

package/dist/vector-DhLGZjP5.mjs

@@ -0,0 +1,3049 @@
+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"
+];
+const TRUE_FALSE_BLANK_FIELD_SET = new Set(TRUE_FALSE_BLANK_FIELDS);
+const INTEGER_FIELD_SET = new Set(INTEGER_FIELDS);
+const STRING_FIELD_SET = new Set(STRING_FIELDS);
+/** 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 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 (TRUE_FALSE_BLANK_FIELD_SET.has(local)) extras[local] = parseVmlTrueFalseBlank(text);
+		else if (INTEGER_FIELD_SET.has(local)) extras[local] = Number(text);
+		else if (STRING_FIELD_SET.has(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);
+		}
+	}
+	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"
+};
+const KEY_TO_TEXT_PATH_FIELD = Object.fromEntries(Object.entries(TEXT_PATH_STYLE_MAP).map(([field, key]) => [key, field]));
+/** 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 style = {};
+	for (const part of styleStr.split(";")) {
+		const [key, val] = part.split(":").map((s) => s.trim());
+		if (!key || !val) continue;
+		const field = KEY_TO_TEXT_PATH_FIELD[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
+];
+/** The AG_Path attribute — always emitted after the shared vocabulary. */
+const PATH_ATTR = [{
+	field: "path",
+	attr: "path",
+	kind: "string"
+}];
+/** Serialize the shared attribute vocabulary (style special-cased) plus extras. */
+function stringifyShapeAttrs(opts, extraSpecs = []) {
+	let attrStr = stringifyVmlAttributes(opts, [
+		...ALL_SHAPE_ATTRS,
+		...extraSpecs,
+		...PATH_ATTR
+	]);
+	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));
+	if (opts.rawChildrenXml) parts.push(opts.rawChildrenXml);
+	return parts.join("");
+}
+/** Parse the shared attribute vocabulary plus extras onto `out`. */
+function parseShapeAttrs(el, out, extraSpecs = []) {
+	parseVmlAttributes(el, [
+		...ALL_SHAPE_ATTRS,
+		...extraSpecs,
+		...PATH_ATTR
+	], out);
+	if (el.attributes?.style !== void 0) out.style = parseVmlShapeStyle(parseVmlStyle(String(el.attributes.style)));
+}
+/** Child shape element names — collected by the group child loop, never by
+* the EG_ShapeElements switch (their slots are group members, not shared
+* shape-element children). */
+const NESTED_SHAPE_NAMES = /* @__PURE__ */ new Set([
+	"v:shape",
+	"v:shapetype",
+	"v:group",
+	"v:rect",
+	"v:roundrect",
+	"v:oval",
+	"v:line",
+	"v:image",
+	"v:arc",
+	"v:curve",
+	"v:polyline"
+]);
+/** 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;
+			default:
+				if (child.name === "o:complex" || child.name === "o:ink" || child.name === "o:equationxml" || child.name !== void 0 && NESTED_SHAPE_NAMES.has(child.name)) break;
+				out.rawChildrenXml = (typeof out.rawChildrenXml === "string" ? out.rawChildrenXml : "") + stringifyElement(child);
+		}
+	}
+}
+/** Generic shape element serializer: tag + shared/extra attrs + children. */
+function stringifyShapeElement(tag, opts, extraSpecs = [], childrenXml = "") {
+	const attrStr = stringifyShapeAttrs(opts, extraSpecs);
+	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) {
+	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, 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) {
+	let children = stringifyShapeElements(opts);
+	if (opts.complex !== void 0) children += stringifyVmlComplex(opts.complex);
+	return stringifyShapeElement("v:shapetype", opts, SHAPETYPE_EXTRA_ATTRS, 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 VmlShapeChild. */
+function stringifyVmlShapeChild(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"
+	},
+	...PATH_ATTR
+];
+/** Parse one shape element into its VmlShapeChild wrapper, or undefined when
+*  the element is not part of the shape vocabulary. */
+function parseVmlShapeChild(el) {
+	switch (el.name) {
+		case "v:shape": return { shape: parseVmlShape(el) };
+		case "v:shapetype": return { shapetype: parseVmlShapetype(el) };
+		case "v:group": return { group: parseVmlGroup(el) };
+		case "v:arc": return { arc: parseVmlArc(el) };
+		case "v:curve": return { curve: parseVmlCurve(el) };
+		case "v:image": return { image: parseVmlImage(el) };
+		case "v:line": return { line: parseVmlLine(el) };
+		case "v:oval": return { oval: parseVmlOval(el) };
+		case "v:polyline": return { polyline: parseVmlPolyline(el) };
+		case "v:rect": return { rect: parseVmlRect(el) };
+		case "v:roundrect": return { roundrect: parseVmlRoundRect(el) };
+		default: return;
+	}
+}
+/** Serialize v:group. */
+function stringifyVmlGroup(opts) {
+	let children = (opts.children ?? []).map(stringifyVmlShapeChild).join("") + stringifyShapeElements(opts);
+	if (opts.diagram !== void 0) children += stringifyVmlDiagram(opts.diagram);
+	const attrStr = stringifyVmlAttributes(opts, GROUP_ATTRS);
+	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)));
+	parseShapeElements(el, out);
+	const children = [];
+	for (const child of el.elements ?? []) {
+		if (child.type !== "element") continue;
+		const shapeChild = parseVmlShapeChild(child);
+		if (shapeChild !== void 0) children.push(shapeChild);
+		else if (child.name === "o:diagram") out.diagram = parseVmlDiagram(child);
+	}
+	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, 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, 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, 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, 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, [], 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, 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, [], 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, 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 = [
+	...EXT_ATTR,
+	{
+		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);
+		}
+	}
+	return out;
+}
+/** Serialize o:colormru. */
+function stringifyVmlColorMru(opts) {
+	return `<o:colormru${stringifyVmlAttributes(opts, [...EXT_ATTR, {
+		field: "colors",
+		attr: "colors",
+		kind: "string"
+	}])}/>`;
+}
+/** Parse an o:colormru element. */
+function parseVmlColorMru(el) {
+	const out = {};
+	parseVmlAttributes(el, [...EXT_ATTR, {
+		field: "colors",
+		attr: "colors",
+		kind: "string"
+	}], out);
+	return out;
+}
+const COLORMENU_ATTRS = [
+	...EXT_ATTR,
+	{
+		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, [...EXT_ATTR, {
+		field: "data",
+		attr: "data",
+		kind: "string"
+	}])}/>`;
+}
+/** Parse an o:idmap element. */
+function parseVmlIdMap(el) {
+	const out = {};
+	parseVmlAttributes(el, [...EXT_ATTR, {
+		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, EXT_ATTR)}>${entries}</o:regrouptable>`;
+}
+/** Parse an o:regrouptable element. */
+function parseVmlRegroupTable(el) {
+	const out = {};
+	parseVmlAttributes(el, EXT_ATTR, 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="${stringifyVmlTrueFalseBlank(proxy.start)}"`);
+	if (proxy.end !== void 0) attrs.push(`end="${stringifyVmlTrueFalseBlank(proxy.end)}"`);
+	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) out.start = parseVmlTrueFalseBlank(String(attrs.start));
+	if (attrs.end !== void 0) out.end = parseVmlTrueFalseBlank(String(attrs.end));
+	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, EXT_ATTR)}>${rules}</o:rules>`;
+}
+/** Parse an o:rules element. */
+function parseVmlRulesBlock(el) {
+	const out = {};
+	parseVmlAttributes(el, EXT_ATTR, 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, EXT_ATTR);
+	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, EXT_ATTR, 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 { stringifyVmlIsComment as $, stringifyVmlPolyline as A, stringifyVmlEquationXml as At, stringifyVmlAnchorLock as B, VML_OFFICE_SHAPE_ATTRS as Bt, stringifyVmlArc as C, parseVmlOleObject as Ct, stringifyVmlImage as D, stringifyVmlClipPath as Dt, stringifyVmlGroup as E, stringifyVmlCallout as Et, stringifyVmlShapetype as F, stringifyVmlOleObject as Ft, parseVmlTextbox as G, stringifyVmlAttributes as Gt, stringifyVmlWrap as H, parseVmlAttributes as Ht, VML_BORDER_TAGS as I, stringifyVmlSignatureLine as It, stringifyVmlStroke as J, parseVmlShapeStyle as Jt, stringifyVmlTextbox as K, stringifyVmlTrueFalse as Kt, parseVmlAnchorLock as L, stringifyVmlSkew as Lt, stringifyVmlRoundRect as M, stringifyVmlInk as Mt, stringifyVmlShape as N, stringifyVmlLock as Nt, stringifyVmlLine as O, stringifyVmlComplex as Ot, stringifyVmlShapeChild as P, stringifyVmlOfficeFill as Pt, parseVmlTextData as Q, parseVmlBorder as R, VML_CORE_ATTRS as Rt, parseVmlShapetype as S, parseVmlOfficeFill as St, stringifyVmlCurve as T, parseVmlSkew as Tt, parseVmlTextPath as U, parseVmlTrueFalse as Ut, stringifyVmlBorder as V, VML_SHAPE_ATTRS as Vt, stringifyVmlTextPath as W, parseVmlTrueFalseBlank as Wt, stringifyVmlShadow as X, stringifyVmlStyle as Xt, parseVmlShadow as Y, parseVmlStyle as Yt, parseVmlIsComment as Z, styleToKeyMap as Zt, parseVmlPolyline as _, parseVmlDiagram as _t, stringifyVmlColorMenu as a, parseVmlHandles as at, parseVmlShape as b, parseVmlInk as bt, stringifyVmlShapeLayout as c, stringifyVmlFormulas as ct, parseVmlBackground as d, parseVmlClientData as dt, stringifyVmlTextData as et, parseVmlCurve as f, stringifyVmlClientData as ft, parseVmlOval as g, parseVmlComplex as gt, parseVmlLine as h, parseVmlClipPath as ht, parseVmlShapeLayout as i, stringifyVmlImageData as it, stringifyVmlRect as j, stringifyVmlExtrusion as jt, stringifyVmlOval as k, stringifyVmlDiagram as kt, nextVmlShapeId as l, parseVmlFill as lt, parseVmlImage as m, parseVmlCallout as mt, parseVmlColorMru as n, stringifyVmlPath as nt, stringifyVmlColorMru as o, stringifyVmlHandles as ot, parseVmlGroup as p, EXT_ATTR as pt, parseVmlStroke as q, stringifyVmlTrueFalseBlank as qt, parseVmlShapeDefaults as r, parseVmlImageData as rt, stringifyVmlShapeDefaults as s, parseVmlFormulas as st, parseVmlColorMenu as t, parseVmlPath as tt, parseVmlArc as u, stringifyVmlFill as ut, parseVmlRect as v, parseVmlEquationXml as vt, stringifyVmlBackground as w, parseVmlSignatureLine as wt, parseVmlShapeChild as x, parseVmlLock as xt, parseVmlRoundRect as y, parseVmlExtrusion as yt, parseVmlWrap as z, VML_OFFICE_CORE_ATTRS as zt };
+
+//# sourceMappingURL=vector-DhLGZjP5.mjs.map