ooxml-core 0.2.0

package/dist/diagram/index.cjs

@@ -0,0 +1,1193 @@
+'use strict';
+
+var xmldom = require('@xmldom/xmldom');
+
+// src/diagram/attributes.ts
+var optionalString = (value) => {
+  const text = (value ?? "").trim();
+  return text.length > 0 ? text : void 0;
+};
+var optionalInteger = (value) => {
+  const parsed = Number.parseInt(value ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+};
+function optionalBoolean(value) {
+  const text = (value ?? "").trim();
+  if (text.length === 0) return void 0;
+  return text === "1" || text.toLowerCase() === "true";
+}
+function optionalScaled(value, divisor) {
+  const text = (value ?? "").trim();
+  if (text.length === 0) return void 0;
+  const parsed = Number.parseFloat(text);
+  return Number.isFinite(parsed) ? parsed / divisor : void 0;
+}
+function parseConnectionAttributes(get) {
+  const sourceId = optionalString(get("srcId"));
+  const destId = optionalString(get("destId"));
+  if (!sourceId || !destId) return void 0;
+  const parsed = { sourceId, destId };
+  const modelId = optionalString(get("modelId"));
+  const type = optionalString(get("type"));
+  const srcOrd = optionalInteger(get("srcOrd"));
+  const destOrd = optionalInteger(get("destOrd"));
+  const parentTransitionId = optionalString(get("parTransId"));
+  const siblingTransitionId = optionalString(get("sibTransId"));
+  const presentationId = optionalString(get("presId"));
+  if (modelId !== void 0) parsed.modelId = modelId;
+  if (type !== void 0) parsed.type = type;
+  if (srcOrd !== void 0) parsed.srcOrd = srcOrd;
+  if (destOrd !== void 0) parsed.destOrd = destOrd;
+  if (parentTransitionId !== void 0) parsed.parentTransitionId = parentTransitionId;
+  if (siblingTransitionId !== void 0) parsed.siblingTransitionId = siblingTransitionId;
+  if (presentationId !== void 0) parsed.presentationId = presentationId;
+  return parsed;
+}
+var CUSTOM_LAYOUT_ATTRIBUTES = [
+  ["angle", "custAng", "angle"],
+  ["scaleX", "custScaleX", "ratio"],
+  ["scaleY", "custScaleY", "ratio"],
+  ["sizeX", "custSzX", "ratio"],
+  ["sizeY", "custSzY", "ratio"],
+  ["linearFactorX", "custLinFactX", "ratio"],
+  ["linearFactorY", "custLinFactY", "ratio"],
+  ["linearFactorNeighborX", "custLinFactNeighborX", "ratio"],
+  ["linearFactorNeighborY", "custLinFactNeighborY", "ratio"],
+  ["radialScaleRadius", "custRadScaleRad", "ratio"],
+  ["radialScaleIncrement", "custRadScaleInc", "ratio"],
+  ["flipHorizontal", "custFlipHor", "flag"],
+  ["flipVertical", "custFlipVert", "flag"],
+  ["hasCustomTransform", "custT", "flag"]
+];
+function parseCustomLayoutAttributes(get) {
+  const custom = {};
+  for (const [key, attribute, kind] of CUSTOM_LAYOUT_ATTRIBUTES) {
+    const raw = get(attribute);
+    const value = kind === "flag" ? optionalBoolean(raw) : optionalScaled(raw, kind === "angle" ? 6e4 : 1e5);
+    if (value !== void 0) custom[key] = value;
+  }
+  return Object.keys(custom).length > 0 ? custom : void 0;
+}
+var RELATIONSHIP_ATTRIBUTES = [
+  ["dataRelId", "dm"],
+  ["layoutRelId", "lo"],
+  ["styleRelId", "qs"],
+  ["colorsRelId", "cs"]
+];
+function parseRelationshipIdAttributes(get) {
+  const result = {};
+  for (const [property, attribute] of RELATIONSHIP_ATTRIBUTES) {
+    const value = optionalString(get(attribute));
+    if (value) result[property] = value;
+  }
+  return result;
+}
+
+// src/diagram/layout-category.ts
+var CATEGORY_FAMILY = {
+  list: "list",
+  process: "process",
+  cycle: "cycle",
+  hierarchy: "hierarchy",
+  relationship: "relationship",
+  matrix: "matrix",
+  pyramid: "pyramid"
+};
+var UNIQUE_ID_KEYWORDS = [
+  [/hier|org/u, "hierarchy"],
+  [/cycle|radial|circular/u, "cycle"],
+  [/process|flow|chevron|arrow|equation/u, "process"],
+  [/timeline/u, "timeline"],
+  [/matrix|grid/u, "matrix"],
+  [/pyramid/u, "pyramid"],
+  [/venn/u, "venn"],
+  [/funnel/u, "funnel"],
+  [/gear/u, "gear"],
+  [/target/u, "target"],
+  [/list/u, "list"]
+];
+function resolveDiagramLayoutCategory(uniqueId, categories) {
+  for (const category of categories) {
+    const family = CATEGORY_FAMILY[category.trim().toLowerCase()];
+    if (family) return family;
+  }
+  const lowerId = uniqueId.toLowerCase();
+  if (lowerId.length > 0) {
+    for (const [pattern, family] of UNIQUE_ID_KEYWORDS) if (pattern.test(lowerId)) return family;
+  }
+  return void 0;
+}
+
+// src/opc/relationship-types.ts
+var BASE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+var RELATIONSHIP_TYPES = {
+  diagramData: `${BASE}/diagramData`,
+  diagramLayout: `${BASE}/diagramLayout`,
+  diagramQuickStyle: `${BASE}/diagramQuickStyle`,
+  diagramColors: `${BASE}/diagramColors`,
+  diagramDrawing: "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing"};
+
+// src/xml/namespaces.ts
+var NS = {
+  /** DrawingML main. */
+  a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+  /** DrawingML diagram (SmartArt) main. */
+  dgm: "http://schemas.openxmlformats.org/drawingml/2006/diagram",
+  /** Office 2007+ diagram drawing (`dsp`). */
+  dsp: "http://schemas.microsoft.com/office/drawing/2008/diagram",
+  /** Relationships (`r:id`, `r:embed`). */
+  r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"};
+function parseXml(xml, options = {}) {
+  const label = options.label ?? "OOXML";
+  if (/<!DOCTYPE|<!ENTITY/i.test(xml))
+    throw new Error(`${label} XML with DTD or entity declarations is not supported`);
+  let parseError = "";
+  let parsed;
+  try {
+    parsed = new xmldom.DOMParser({
+      onError: (level, message) => {
+        if (level !== "warning") parseError = message;
+      }
+    }).parseFromString(xml, "application/xml");
+  } catch (error) {
+    throw new Error(
+      `Invalid ${label} XML: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (parseError || !parsed.documentElement)
+    throw new Error(`Invalid ${label} XML: ${parseError || "missing root element"}`);
+  return parsed;
+}
+var isElement = (node) => node.nodeType === 1;
+var elements = (parent) => Array.from(parent.childNodes).filter(isElement);
+function named(element, local, ns, lenient = true) {
+  if (!element || element.localName !== local) return false;
+  return element.namespaceURI === ns || lenient && !element.namespaceURI;
+}
+var children = (parent, local, ns, lenient = true) => elements(parent).filter((element) => named(element, local, ns, lenient));
+var first = (parent, local, ns, lenient = true) => parent ? children(parent, local, ns, lenient)[0] : void 0;
+
+// src/diagram/relationships.ts
+function diagramRelationshipsPart(partPath) {
+  const dir = partPath.replace(/\/[^/]+$/u, "");
+  const file = partPath.split("/").pop() ?? "";
+  return `${dir}/_rels/${file}.rels`;
+}
+async function resolveDiagramDrawingPart(hostPart, dataRelId, drawingExtensionRelId, host) {
+  if (dataRelId.length === 0) return void 0;
+  const hostRels = host.hostRelationships(hostPart);
+  const declared = drawingExtensionRelId ? hostRels?.get(drawingExtensionRelId) : void 0;
+  if (declared) return { relId: drawingExtensionRelId, path: host.resolvePath(hostPart, declared) };
+  const inferred = [...hostRels?.entries() ?? []].find(
+    ([, target2]) => /(?:^|\/)diagrams\/drawing\d+\.xml$/u.test(target2.replaceAll("\\", "/"))
+  );
+  if (inferred) return { relId: inferred[0], path: host.resolvePath(hostPart, inferred[1]) };
+  const dataTarget = hostRels?.get(dataRelId);
+  if (!dataTarget) return void 0;
+  const dataPath = host.resolvePath(hostPart, dataTarget);
+  const entries = await host.readRelationshipEntries(diagramRelationshipsPart(dataPath));
+  if (!entries) return void 0;
+  const drawing = entries.find(
+    (entry) => (!drawingExtensionRelId || entry.id.trim() === drawingExtensionRelId) && entry.type.endsWith("/diagramDrawing")
+  );
+  const id = drawing?.id.trim() ?? "";
+  const target = drawing?.target.trim() ?? "";
+  if (id.length === 0 || target.length === 0) return void 0;
+  return { relId: id, path: host.resolvePath(dataPath, target) };
+}
+var DIAGRAM_RELATIONSHIP_TYPES = {
+  data: RELATIONSHIP_TYPES.diagramData,
+  layout: RELATIONSHIP_TYPES.diagramLayout,
+  quickStyle: RELATIONSHIP_TYPES.diagramQuickStyle,
+  colors: RELATIONSHIP_TYPES.diagramColors,
+  drawing: RELATIONSHIP_TYPES.diagramDrawing
+};
+
+// src/diagram/dom.ts
+function attributeReader(element) {
+  return (name) => {
+    if (!element) return void 0;
+    const direct = element.getAttribute(name);
+    if (direct !== null) return direct;
+    const attributes = element.attributes;
+    for (let index = 0; index < attributes.length; index++) {
+      const candidate = attributes.item(index);
+      if (candidate && candidate.localName === name) return candidate.value;
+    }
+    return void 0;
+  };
+}
+function stringAttribute(element, name) {
+  const value = attributeReader(element)(name)?.trim();
+  return value ? value : void 0;
+}
+function integerAttribute(element, name) {
+  const parsed = Number.parseInt(attributeReader(element)(name) ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function booleanAttribute(element, name) {
+  const value = attributeReader(element)(name)?.trim().toLowerCase();
+  if (value === "1" || value === "true") return true;
+  if (value === "0" || value === "false") return false;
+  return void 0;
+}
+function descendants(root, local) {
+  const result = [];
+  const visit = (node) => {
+    for (const child of Array.from(node.childNodes)) {
+      if (!isElement(child)) continue;
+      if (child.localName === local) result.push(child);
+      visit(child);
+    }
+  };
+  visit(root);
+  return result;
+}
+
+// src/diagram/data-model.ts
+var TRANSITION_TYPES = /* @__PURE__ */ new Set(["parTrans", "sibTrans"]);
+var STRUCTURAL_TYPES = /* @__PURE__ */ new Set(["doc", "pres", "parTrans", "sibTrans"]);
+function collectTransitionText(points, describe, text) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const point of points) {
+    const { type, modelId } = describe(point);
+    if (!TRANSITION_TYPES.has((type ?? "").trim())) continue;
+    const id = (modelId ?? "").trim();
+    if (!id) continue;
+    const value = text(point).trim();
+    if (value.length > 0) byId.set(id, value);
+  }
+  return byId;
+}
+function connectionLabel(connection, transitionText) {
+  const parent = connection.parentTransitionId ? transitionText.get(connection.parentTransitionId) : void 0;
+  const sibling = connection.siblingTransitionId ? transitionText.get(connection.siblingTransitionId) : void 0;
+  return parent ?? sibling;
+}
+function textBodyParagraphs(body) {
+  if (!body) return [];
+  return children(body, "p", NS.a).map(
+    (paragraph) => descendants(paragraph, "t").map((run) => run.textContent ?? "").join("")
+  );
+}
+function parsePoint(element) {
+  const modelId = stringAttribute(element, "modelId");
+  if (!modelId) return void 0;
+  const paragraphs = textBodyParagraphs(first(element, "t", NS.dgm));
+  const prSet = first(element, "prSet", NS.dgm);
+  const point = {
+    modelId,
+    type: stringAttribute(element, "type") ?? "node",
+    paragraphs,
+    text: paragraphs.join("\n")
+  };
+  const optional = [
+    ["connectionId", stringAttribute(element, "cxnId")],
+    ["presAssocId", stringAttribute(prSet, "presAssocID")],
+    ["presName", stringAttribute(prSet, "presName")],
+    ["presStyleLabel", stringAttribute(prSet, "presStyleLbl")],
+    ["presStyleIndex", integerAttribute(prSet, "presStyleIdx")],
+    ["presStyleCount", integerAttribute(prSet, "presStyleCnt")],
+    ["layoutTypeId", stringAttribute(prSet, "loTypeId")],
+    ["layoutCategoryId", stringAttribute(prSet, "loCatId")],
+    ["quickStyleTypeId", stringAttribute(prSet, "qsTypeId")],
+    ["colorsTypeId", stringAttribute(prSet, "csTypeId")]
+  ];
+  for (const [key, value] of optional)
+    if (value !== void 0) point[key] = value;
+  const customLayout = prSet ? parseCustomLayoutAttributes(attributeReader(prSet)) : void 0;
+  if (customLayout) point.customLayout = customLayout;
+  return point;
+}
+function parseDiagramDataModel(source, part) {
+  const root = (typeof source === "string" ? parseXml(source, { label: "DiagramML" }) : source).documentElement;
+  const issues = [];
+  const report = (code, message) => issues.push({ code, message, ...part ? { part } : {} });
+  const points = [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const element of children(first(root, "ptLst", NS.dgm) ?? root, "pt", NS.dgm)) {
+    const point = parsePoint(element);
+    if (!point) {
+      report("POINT_ID_REQUIRED", "dgm:pt requires modelId.");
+      continue;
+    }
+    if (ids.has(point.modelId))
+      report("POINT_ID_DUPLICATE", `Duplicate dgm:pt modelId: ${point.modelId}.`);
+    ids.add(point.modelId);
+    points.push(point);
+  }
+  const transitionText = collectTransitionText(
+    points,
+    (point) => ({ type: point.type, modelId: point.modelId }),
+    (point) => point.text
+  );
+  const connections = [];
+  const parentById = /* @__PURE__ */ new Map();
+  const connectionIds = /* @__PURE__ */ new Set();
+  for (const element of children(first(root, "cxnLst", NS.dgm) ?? root, "cxn", NS.dgm)) {
+    const connection = parseConnectionAttributes(attributeReader(element));
+    if (!connection) {
+      report("CONNECTION_ATTRIBUTE_REQUIRED", "dgm:cxn requires srcId and destId.");
+      continue;
+    }
+    if (connection.modelId && connectionIds.has(connection.modelId))
+      report("CONNECTION_ID_DUPLICATE", `Duplicate dgm:cxn modelId: ${connection.modelId}.`);
+    if (connection.modelId) connectionIds.add(connection.modelId);
+    for (const [attribute, id] of [
+      ["srcId", connection.sourceId],
+      ["destId", connection.destId]
+    ])
+      if (!ids.has(id))
+        report(
+          "CONNECTION_ENDPOINT_MISSING",
+          `dgm:cxn ${attribute} references missing point: ${id}.`
+        );
+    const label = connectionLabel(connection, transitionText);
+    connections.push(label ? { ...connection, label } : connection);
+    if ((!connection.type || connection.type === "parOf") && !parentById.has(connection.destId))
+      parentById.set(connection.destId, connection.sourceId);
+  }
+  const ext = descendants(root, "dataModelExt")[0];
+  const drawingRelId = stringAttribute(ext, "relId");
+  return {
+    points,
+    connections,
+    nodes: points.filter((point) => !STRUCTURAL_TYPES.has(point.type)),
+    parentById,
+    ...drawingRelId ? { drawingRelId } : {},
+    issues
+  };
+}
+
+// src/color/color-primitives.ts
+function clampUnitInterval(value) {
+  return Math.min(1, Math.max(0, value));
+}
+function hexToRgbChannels(color) {
+  const normalized = color.replace("#", "");
+  if (!/^[0-9a-fA-F]{6}$/.test(normalized)) {
+    return null;
+  }
+  return {
+    r: Number.parseInt(normalized.slice(0, 2), 16),
+    g: Number.parseInt(normalized.slice(2, 4), 16),
+    b: Number.parseInt(normalized.slice(4, 6), 16)
+  };
+}
+function percentDivisorFor(text) {
+  return text.endsWith("%") ? 100 : 1e5;
+}
+function parseOoxmlPercent(value) {
+  const text = String(value ?? "").trim();
+  const divisor = percentDivisorFor(text);
+  const magnitude = Number.parseFloat(divisor === 100 ? text.slice(0, -1) : text);
+  if (!Number.isFinite(magnitude)) {
+    return void 0;
+  }
+  return magnitude / divisor;
+}
+function parseDrawingPercent(value) {
+  const parsed = parseOoxmlPercent(value);
+  return parsed === void 0 ? void 0 : clampUnitInterval(parsed);
+}
+function scrgbLinearToSrgb8(linear) {
+  const l = Math.min(1, Math.max(0, linear));
+  const companded = l <= 31308e-7 ? 12.92 * l : 1.055 * l ** (1 / 2.4) - 0.055;
+  return Math.min(255, Math.max(0, Math.round(companded * 255)));
+}
+function toHex(value) {
+  return Math.min(255, Math.max(0, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+}
+function rgbToHsl(r, g, b) {
+  const rN = r / 255;
+  const gN = g / 255;
+  const bN = b / 255;
+  const cMax = Math.max(rN, gN, bN);
+  const cMin = Math.min(rN, gN, bN);
+  const delta = cMax - cMin;
+  const l = (cMax + cMin) / 2;
+  let s = 0;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+  }
+  let h = 0;
+  if (delta !== 0) {
+    if (cMax === rN) {
+      h = 60 * ((gN - bN) / delta % 6);
+    } else if (cMax === gN) {
+      h = 60 * ((bN - rN) / delta + 2);
+    } else {
+      h = 60 * ((rN - gN) / delta + 4);
+    }
+  }
+  if (h < 0) {
+    h += 360;
+  }
+  return { h, s: clampUnitInterval(s), l: clampUnitInterval(l) };
+}
+function hslToRgb(h, s, l) {
+  const sC = clampUnitInterval(s);
+  const lC = clampUnitInterval(l);
+  const hN = (h % 360 + 360) % 360;
+  const c = (1 - Math.abs(2 * lC - 1)) * sC;
+  const x = c * (1 - Math.abs(hN / 60 % 2 - 1));
+  const m = lC - c / 2;
+  let rP = 0;
+  let gP = 0;
+  let bP = 0;
+  if (hN < 60) {
+    rP = c;
+    gP = x;
+    bP = 0;
+  } else if (hN < 120) {
+    rP = x;
+    gP = c;
+    bP = 0;
+  } else if (hN < 180) {
+    rP = 0;
+    gP = c;
+    bP = x;
+  } else if (hN < 240) {
+    rP = 0;
+    gP = x;
+    bP = c;
+  } else if (hN < 300) {
+    rP = x;
+    gP = 0;
+    bP = c;
+  } else {
+    rP = c;
+    gP = 0;
+    bP = x;
+  }
+  return {
+    r: Math.round((rP + m) * 255),
+    g: Math.round((gP + m) * 255),
+    b: Math.round((bP + m) * 255)
+  };
+}
+function parseDrawingFraction(value) {
+  return parseOoxmlPercent(value);
+}
+function parseDrawingHueDegrees(value) {
+  const parsed = Number.parseFloat(String(value ?? "").trim());
+  if (!Number.isFinite(parsed)) {
+    return void 0;
+  }
+  return parsed / 6e4;
+}
+
+// src/color/color-linear.ts
+function srgb255ToLinear(channel) {
+  const c = clampUnitInterval(channel / 255);
+  return c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function linearToSrgb255(linear) {
+  const c = clampUnitInterval(linear);
+  return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
+}
+
+// src/diagram/drawing-color.ts
+var COLOR_ELEMENTS = {
+  srgbClr: "srgb",
+  schemeClr: "scheme",
+  sysClr: "system",
+  prstClr: "preset",
+  scrgbClr: "scrgb",
+  hslClr: "hsl"
+};
+function colorValue(kind, element) {
+  const attribute = (name) => element.getAttribute(name) ?? "";
+  if (kind === "scrgb") return `${attribute("r")},${attribute("g")},${attribute("b")}`;
+  if (kind === "hsl") return `${attribute("hue")},${attribute("sat")},${attribute("lum")}`;
+  return attribute("val");
+}
+function parseDrawingColorIn(container) {
+  if (!container) return void 0;
+  for (const element of elements(container)) {
+    const kind = COLOR_ELEMENTS[element.localName];
+    if (!kind || element.namespaceURI && element.namespaceURI !== NS.a) continue;
+    return parseDrawingColor(element);
+  }
+  return void 0;
+}
+function parseDrawingColor(element) {
+  const kind = COLOR_ELEMENTS[element.localName];
+  if (!kind) return void 0;
+  const color = {
+    kind,
+    value: colorValue(kind, element),
+    transforms: elements(element).map((child) => ({
+      name: child.localName,
+      value: child.getAttribute("val") ?? ""
+    }))
+  };
+  const fallback = kind === "system" ? element.getAttribute("lastClr") : null;
+  if (fallback) color.fallback = fallback;
+  return color;
+}
+function parseDrawingColorList(container) {
+  if (!container) return [];
+  return elements(container).flatMap((element) => {
+    const color = parseDrawingColor(element);
+    return color ? [color] : [];
+  });
+}
+var PRESET_COLORS = {
+  black: "#000000",
+  white: "#FFFFFF",
+  red: "#FF0000",
+  green: "#008000",
+  blue: "#0000FF",
+  yellow: "#FFFF00",
+  gray: "#808080",
+  grey: "#808080"
+};
+function baseHex(color, theme) {
+  switch (color.kind) {
+    case "srgb":
+      return /^[0-9a-f]{6}$/i.test(color.value) ? `#${color.value.toUpperCase()}` : void 0;
+    case "scheme":
+      return theme?.scheme(color.value);
+    case "system":
+      return color.fallback && /^[0-9a-f]{6}$/i.test(color.fallback) ? `#${color.fallback.toUpperCase()}` : void 0;
+    case "preset":
+      return PRESET_COLORS[color.value];
+    case "scrgb": {
+      const [r, g, b] = color.value.split(",").map((part) => parseDrawingFraction(part));
+      if (r === void 0 || g === void 0 || b === void 0) return void 0;
+      return `#${toHex(scrgbLinearToSrgb8(r))}${toHex(scrgbLinearToSrgb8(g))}${toHex(scrgbLinearToSrgb8(b))}`;
+    }
+    case "hsl": {
+      const [h, s, l] = color.value.split(",");
+      const hue = parseDrawingHueDegrees(h);
+      const sat = parseDrawingFraction(s);
+      const lum = parseDrawingFraction(l);
+      if (hue === void 0 || sat === void 0 || lum === void 0) return void 0;
+      const { r, g, b } = hslToRgb(hue, sat, lum);
+      return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+    }
+  }
+}
+var APPLIED = /* @__PURE__ */ new Set([
+  "alpha",
+  "alphaMod",
+  "alphaOff",
+  "comp",
+  "inv",
+  "gray",
+  "shade",
+  "tint",
+  "hue",
+  "hueMod",
+  "hueOff",
+  "sat",
+  "satMod",
+  "satOff",
+  "lum",
+  "lumMod",
+  "lumOff"
+]);
+function resolveDrawingColor(color, theme) {
+  const base = baseHex(color, theme);
+  const rgb = base ? hexToRgbChannels(base) : null;
+  if (!rgb) return void 0;
+  let { r, g, b } = rgb;
+  const find = (name) => color.transforms.find((entry) => entry.name === name)?.value;
+  const has = (name) => color.transforms.some((entry) => entry.name === name);
+  if (has("comp")) {
+    const hsl = rgbToHsl(r, g, b);
+    ({ r, g, b } = hslToRgb((hsl.h + 180) % 360, hsl.s, hsl.l));
+  }
+  if (has("inv")) [r, g, b] = [255 - r, 255 - g, 255 - b];
+  if (has("gray")) r = g = b = Math.round(0.299 * r + 0.587 * g + 0.114 * b);
+  const shade = parseDrawingPercent(find("shade"));
+  if (shade !== void 0) {
+    r = linearToSrgb255(srgb255ToLinear(r) * shade);
+    g = linearToSrgb255(srgb255ToLinear(g) * shade);
+    b = linearToSrgb255(srgb255ToLinear(b) * shade);
+  }
+  const tint = parseDrawingPercent(find("tint"));
+  if (tint !== void 0) {
+    r = linearToSrgb255(1 - (1 - srgb255ToLinear(r)) * tint);
+    g = linearToSrgb255(1 - (1 - srgb255ToLinear(g)) * tint);
+    b = linearToSrgb255(1 - (1 - srgb255ToLinear(b)) * tint);
+  }
+  if (["hue", "hueMod", "hueOff", "sat", "satMod", "satOff", "lum", "lumMod", "lumOff"].some(has)) {
+    const hsl = rgbToHsl(r, g, b);
+    const wrap = (degrees) => (degrees % 360 + 360) % 360;
+    const hueAbs = parseDrawingHueDegrees(find("hue"));
+    if (hueAbs !== void 0) hsl.h = wrap(hueAbs);
+    const hueMod = parseDrawingFraction(find("hueMod"));
+    if (hueMod !== void 0) hsl.h = wrap(hsl.h * hueMod);
+    const hueOff = parseDrawingHueDegrees(find("hueOff"));
+    if (hueOff !== void 0) hsl.h = wrap(hsl.h + hueOff);
+    const satAbs = parseDrawingFraction(find("sat"));
+    if (satAbs !== void 0) hsl.s = clampUnitInterval(satAbs);
+    const satMod = parseDrawingFraction(find("satMod"));
+    if (satMod !== void 0) hsl.s = clampUnitInterval(hsl.s * satMod);
+    const satOff = parseDrawingFraction(find("satOff"));
+    if (satOff !== void 0) hsl.s = clampUnitInterval(hsl.s + satOff);
+    const lumAbs = parseDrawingFraction(find("lum"));
+    if (lumAbs !== void 0) hsl.l = clampUnitInterval(lumAbs);
+    const lumMod = parseDrawingFraction(find("lumMod"));
+    if (lumMod !== void 0) hsl.l = clampUnitInterval(hsl.l * lumMod);
+    const lumOff = parseDrawingFraction(find("lumOff"));
+    if (lumOff !== void 0) hsl.l = clampUnitInterval(hsl.l + lumOff);
+    ({ r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l));
+  }
+  let alpha = parseDrawingPercent(find("alpha")) ?? 1;
+  const alphaMod = parseDrawingFraction(find("alphaMod"));
+  if (alphaMod !== void 0) alpha = clampUnitInterval(alpha * alphaMod);
+  const alphaOff = parseDrawingFraction(find("alphaOff"));
+  if (alphaOff !== void 0) alpha = clampUnitInterval(alpha + alphaOff);
+  return {
+    hex: `#${toHex(r)}${toHex(g)}${toHex(b)}`,
+    alpha,
+    unapplied: [...new Set(color.transforms.map((entry) => entry.name))].filter(
+      (name) => !APPLIED.has(name)
+    )
+  };
+}
+
+// src/diagram/definitions.ts
+var rootOf = (source) => (typeof source === "string" ? parseXml(source, { label: "DiagramML" }) : source).documentElement;
+function parseDefinitionHeader(root) {
+  const header = {
+    uniqueId: stringAttribute(root, "uniqueId") ?? "",
+    categories: children(first(root, "catLst", NS.dgm) ?? root, "cat", NS.dgm).flatMap((cat) => {
+      const type = stringAttribute(cat, "type");
+      const priority = Number.parseInt(cat.getAttribute("pri") ?? "", 10);
+      return type ? [{ type, ...Number.isFinite(priority) ? { priority } : {} }] : [];
+    })
+  };
+  const title = stringAttribute(first(root, "title", NS.dgm), "val");
+  const description = stringAttribute(first(root, "desc", NS.dgm), "val");
+  if (title) header.title = title;
+  if (description) header.description = description;
+  return header;
+}
+function colorList(container) {
+  const method = stringAttribute(container, "meth");
+  return { ...method ? { method } : {}, colors: parseDrawingColorList(container) };
+}
+function parseDiagramColors(source) {
+  const root = rootOf(source);
+  const labels = children(root, "styleLbl", NS.dgm).map((label) => ({
+    name: stringAttribute(label, "name") ?? "",
+    fill: colorList(first(label, "fillClrLst", NS.dgm)),
+    line: colorList(first(label, "linClrLst", NS.dgm)),
+    effect: colorList(first(label, "effectClrLst", NS.dgm)),
+    textLine: colorList(first(label, "txLinClrLst", NS.dgm)),
+    textFill: colorList(first(label, "txFillClrLst", NS.dgm)),
+    textEffect: colorList(first(label, "txEffectClrLst", NS.dgm))
+  }));
+  return { ...parseDefinitionHeader(root), labels };
+}
+function styleRef(element) {
+  if (!element) return void 0;
+  const raw = element.getAttribute("idx");
+  const ref = {};
+  if (element.localName === "fontRef") {
+    if (raw) ref.fontIndex = raw;
+  } else {
+    const index = Number.parseInt(raw ?? "", 10);
+    if (Number.isFinite(index)) ref.index = index;
+  }
+  const color = parseDrawingColorIn(element);
+  if (color) ref.color = color;
+  return ref;
+}
+function parseStyleReferences(style) {
+  const refs = {};
+  const line = styleRef(first(style, "lnRef", NS.a));
+  const fill = styleRef(first(style, "fillRef", NS.a));
+  const effect = styleRef(first(style, "effectRef", NS.a));
+  const font = styleRef(first(style, "fontRef", NS.a));
+  if (line) refs.line = line;
+  if (fill) refs.fill = fill;
+  if (effect) refs.effect = effect;
+  if (font) refs.font = font;
+  return refs;
+}
+var hasContent = (element) => Boolean(element && (element.attributes.length > 0 || elements(element).length > 0));
+function parseDiagramQuickStyle(source) {
+  const root = rootOf(source);
+  const labels = children(root, "styleLbl", NS.dgm).map((label) => ({
+    name: stringAttribute(label, "name") ?? "",
+    ...parseStyleReferences(first(label, "style", NS.dgm)),
+    hasScene3d: Boolean(first(label, "scene3d", NS.dgm)),
+    hasShape3d: hasContent(first(label, "sp3d", NS.dgm))
+  }));
+  return {
+    ...parseDefinitionHeader(root),
+    labels,
+    has3d: labels.some((label) => label.hasShape3d)
+  };
+}
+function parseDiagramLayoutSummary(source) {
+  const root = rootOf(source);
+  const header = parseDefinitionHeader(root);
+  const family = resolveDiagramLayoutCategory(
+    header.uniqueId,
+    header.categories.map((category) => category.type)
+  );
+  const rootNode = first(root, "layoutNode", NS.dgm);
+  const rootAlgorithm = stringAttribute(first(rootNode, "alg", NS.dgm), "type");
+  return {
+    ...header,
+    ...family ? { family } : {},
+    ...rootAlgorithm ? { rootAlgorithm } : {},
+    layoutNodeCount: descendants(root, "layoutNode").length
+  };
+}
+
+// src/diagram/drawing-fill.ts
+var FILL_ELEMENTS = /* @__PURE__ */ new Set([
+  "noFill",
+  "solidFill",
+  "gradFill",
+  "pattFill",
+  "blipFill",
+  "grpFill"
+]);
+function fillElementOf(properties) {
+  return properties ? elements(properties).find(
+    (element) => FILL_ELEMENTS.has(element.localName) && (!element.namespaceURI || element.namespaceURI === NS.a)
+  ) : void 0;
+}
+function parseDrawingFill(properties) {
+  const fill = fillElementOf(properties);
+  if (!fill) return void 0;
+  switch (fill.localName) {
+    case "noFill":
+      return { kind: "none" };
+    case "solidFill": {
+      const color = parseDrawingColorIn(fill);
+      return color ? { kind: "solid", color } : { kind: "unsupported", element: "solidFill" };
+    }
+    case "gradFill": {
+      const stops = children(first(fill, "gsLst", NS.a) ?? fill, "gs", NS.a).flatMap((stop) => {
+        const color = parseDrawingColorIn(stop);
+        const position = Number.parseInt(stop.getAttribute("pos") ?? "", 10);
+        return color && Number.isFinite(position) ? [{ position: position / 1e3, color }] : [];
+      });
+      const angle = Number.parseInt(first(fill, "lin", NS.a)?.getAttribute("ang") ?? "", 10);
+      const path = first(fill, "path", NS.a)?.getAttribute("path");
+      return {
+        kind: "gradient",
+        stops,
+        ...Number.isFinite(angle) ? { angle: angle / 6e4 } : {},
+        ...path ? { path } : {}
+      };
+    }
+    case "pattFill": {
+      const foreground = parseDrawingColorIn(first(fill, "fgClr", NS.a));
+      const background = parseDrawingColorIn(first(fill, "bgClr", NS.a));
+      return {
+        kind: "pattern",
+        preset: fill.getAttribute("prst") ?? "",
+        ...foreground ? { foreground } : {},
+        ...background ? { background } : {}
+      };
+    }
+    case "blipFill": {
+      const blip = first(fill, "blip", NS.a);
+      const relId = blip?.getAttributeNS(NS.r, "embed") || blip?.getAttribute("r:embed") || void 0;
+      return { kind: "picture", ...relId ? { relId } : {} };
+    }
+    default:
+      return { kind: "unsupported", element: fill.localName };
+  }
+}
+function parseDrawingLine(ln) {
+  if (!ln) return void 0;
+  const line = {};
+  const width = Number.parseInt(ln.getAttribute("w") ?? "", 10);
+  if (Number.isFinite(width)) line.widthEmu = width;
+  const fill = parseDrawingFill(ln);
+  if (fill) line.fill = fill;
+  const dash = first(ln, "prstDash", NS.a)?.getAttribute("val");
+  if (dash) line.dash = dash;
+  const cap = ln.getAttribute("cap");
+  if (cap) line.cap = cap;
+  return line;
+}
+
+// src/diagram/drawing-text.ts
+function parseRun(run) {
+  const properties = first(run, "rPr", NS.a);
+  const parsed = { text: first(run, "t", NS.a)?.textContent ?? "" };
+  const size = Number.parseInt(properties?.getAttribute("sz") ?? "", 10);
+  if (Number.isFinite(size)) parsed.sizePt = size / 100;
+  const bold = booleanAttribute(properties, "b");
+  if (bold !== void 0) parsed.bold = bold;
+  const italic = booleanAttribute(properties, "i");
+  if (italic !== void 0) parsed.italic = italic;
+  const underline = properties?.getAttribute("u");
+  if (underline) parsed.underline = underline !== "none";
+  const color = parseDrawingColorIn(first(properties, "solidFill", NS.a));
+  if (color) parsed.color = color;
+  const typeface = first(properties, "latin", NS.a)?.getAttribute("typeface");
+  if (typeface) parsed.typeface = typeface;
+  return parsed;
+}
+function parseParagraph(paragraph) {
+  const runs = [];
+  for (const child of children(paragraph, "r", NS.a)) runs.push(parseRun(child));
+  for (const field of children(paragraph, "fld", NS.a)) runs.push(parseRun(field));
+  const align = first(paragraph, "pPr", NS.a)?.getAttribute("algn");
+  return { ...align ? { align } : {}, runs };
+}
+function parseDrawingTextBody(body) {
+  if (!body) return void 0;
+  const properties = first(body, "bodyPr", NS.a);
+  const paragraphs = children(body, "p", NS.a).map(parseParagraph);
+  const result = {
+    paragraphs,
+    text: paragraphs.map((paragraph) => paragraph.runs.map((run) => run.text).join("")).join("\n")
+  };
+  const anchor = properties?.getAttribute("anchor");
+  if (anchor) result.anchor = anchor;
+  const insets = {};
+  for (const [key, attribute] of [
+    ["left", "lIns"],
+    ["top", "tIns"],
+    ["right", "rIns"],
+    ["bottom", "bIns"]
+  ]) {
+    const value = Number.parseInt(properties?.getAttribute(attribute) ?? "", 10);
+    if (Number.isFinite(value)) insets[key] = value;
+  }
+  if (Object.keys(insets).length > 0) result.insetsEmu = insets;
+  return result;
+}
+
+// src/diagram/drawing-geometry.ts
+var int = (element, name) => Number.parseInt(element?.getAttribute(name) ?? "", 10);
+function parseFrame(container) {
+  const off = first(container, "off", NS.a);
+  const ext = first(container, "ext", NS.a);
+  if (!off || !ext) return void 0;
+  return {
+    x: int(off, "x") || 0,
+    y: int(off, "y") || 0,
+    width: int(ext, "cx") || 0,
+    height: int(ext, "cy") || 0
+  };
+}
+function parseTransform(xfrm) {
+  const frame = parseFrame(xfrm);
+  if (!frame || !xfrm) return void 0;
+  const rot = int(xfrm, "rot");
+  return {
+    frame,
+    ...Number.isFinite(rot) && rot !== 0 ? { rotation: rot / 6e4 } : {},
+    ...booleanAttribute(xfrm, "flipH") ? { flipHorizontal: true } : {},
+    ...booleanAttribute(xfrm, "flipV") ? { flipVertical: true } : {}
+  };
+}
+function parsePathCommands(path) {
+  const commands = [];
+  const point = (element) => {
+    const x = int(element, "x");
+    const y = int(element, "y");
+    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : void 0;
+  };
+  for (const element of Array.from(path.childNodes)) {
+    if (element.nodeType !== 1) continue;
+    const node = element;
+    const points = children(node, "pt", NS.a).map(point);
+    if (points.some((entry) => entry === void 0)) return void 0;
+    const [p0, p1, p2] = points;
+    switch (node.localName) {
+      case "moveTo":
+      case "lnTo":
+        if (!p0) return void 0;
+        commands.push({ op: node.localName === "moveTo" ? "M" : "L", ...p0 });
+        break;
+      case "cubicBezTo":
+        if (!p0 || !p1 || !p2) return void 0;
+        commands.push({ op: "C", x1: p0.x, y1: p0.y, x2: p1.x, y2: p1.y, x: p2.x, y: p2.y });
+        break;
+      case "quadBezTo":
+        if (!p0 || !p1) return void 0;
+        commands.push({ op: "Q", x1: p0.x, y1: p0.y, x: p1.x, y: p1.y });
+        break;
+      case "arcTo": {
+        const wR = int(node, "wR");
+        const hR = int(node, "hR");
+        const startAngle = int(node, "stAng");
+        const swingAngle = int(node, "swAng");
+        if (![wR, hR, startAngle, swingAngle].every(Number.isFinite)) return void 0;
+        commands.push({
+          op: "A",
+          wR,
+          hR,
+          startAngle: startAngle / 6e4,
+          swingAngle: swingAngle / 6e4
+        });
+        break;
+      }
+      case "close":
+        commands.push({ op: "Z" });
+        break;
+    }
+  }
+  return commands;
+}
+function parseDrawingGeometry(spPr) {
+  const preset = first(spPr, "prstGeom", NS.a);
+  const custom = first(spPr, "custGeom", NS.a);
+  if (custom) {
+    const paths = [];
+    for (const path of children(first(custom, "pathLst", NS.a) ?? custom, "path", NS.a)) {
+      const commands = parsePathCommands(path);
+      if (!commands) return { geometry: "custom", issue: "CUSTOM_GEOMETRY_GUIDES_UNSUPPORTED" };
+      const width = int(path, "w");
+      const height = int(path, "h");
+      paths.push({
+        commands,
+        ...Number.isFinite(width) ? { width } : {},
+        ...Number.isFinite(height) ? { height } : {},
+        ...path.getAttribute("fill") ? { fill: path.getAttribute("fill") } : {},
+        ...path.getAttribute("stroke") === "0" || path.getAttribute("stroke") === "false" ? { stroke: false } : {}
+      });
+    }
+    return { geometry: "custom", paths };
+  }
+  const geometry = preset?.getAttribute("prst") || "rect";
+  const adjustments = {};
+  const avLst = first(preset, "avLst", NS.a);
+  if (avLst)
+    for (const guide of children(avLst, "gd", NS.a)) {
+      const name = guide.getAttribute("name");
+      const match = /^val\s+(-?\d+)/u.exec(guide.getAttribute("fmla") ?? "");
+      if (name && match?.[1]) adjustments[name] = Number.parseInt(match[1], 10);
+    }
+  return { geometry, ...Object.keys(adjustments).length > 0 ? { adjustments } : {} };
+}
+
+// src/diagram/drawing.ts
+var IDENTITY = { offsetX: 0, offsetY: 0, scaleX: 1, scaleY: 1 };
+function applyGroup(frame, group) {
+  return {
+    x: Math.round(group.offsetX + frame.x * group.scaleX),
+    y: Math.round(group.offsetY + frame.y * group.scaleY),
+    width: Math.round(frame.width * group.scaleX),
+    height: Math.round(frame.height * group.scaleY)
+  };
+}
+function groupTransform(group, parent) {
+  const xfrm = first(first(group, "grpSpPr", NS.dsp), "xfrm", NS.a);
+  const off = first(xfrm, "off", NS.a);
+  const ext = first(xfrm, "ext", NS.a);
+  const chOff = first(xfrm, "chOff", NS.a);
+  const chExt = first(xfrm, "chExt", NS.a);
+  const num = (element, name) => Number.parseInt(element?.getAttribute(name) ?? "", 10);
+  const cx = num(ext, "cx");
+  const cy = num(ext, "cy");
+  const chCx = num(chExt, "cx");
+  const chCy = num(chExt, "cy");
+  if (!off || ![cx, cy, chCx, chCy].every(Number.isFinite) || chCx === 0 || chCy === 0)
+    return parent;
+  const scaleX = cx / chCx;
+  const scaleY = cy / chCy;
+  const local = {
+    offsetX: num(off, "x") - (num(chOff, "x") || 0) * scaleX,
+    offsetY: num(off, "y") - (num(chOff, "y") || 0) * scaleY,
+    scaleX,
+    scaleY
+  };
+  return {
+    offsetX: parent.offsetX + local.offsetX * parent.scaleX,
+    offsetY: parent.offsetY + local.offsetY * parent.scaleY,
+    scaleX: parent.scaleX * local.scaleX,
+    scaleY: parent.scaleY * local.scaleY
+  };
+}
+function parseShape(sp, index, group, issues) {
+  const spPr = first(sp, "spPr", NS.dsp);
+  const transform = parseTransform(first(spPr, "xfrm", NS.a));
+  if (!transform) return void 0;
+  const modelId = stringAttribute(sp, "modelId") ?? stringAttribute(first(first(sp, "nvSpPr", NS.dsp), "cNvPr", NS.dsp), "id") ?? `dsp-${index}`;
+  const { geometry, adjustments, paths, issue } = parseDrawingGeometry(spPr);
+  if (issue) issues.push({ code: issue, message: `Shape ${modelId}: ${issue}.` });
+  const frame = applyGroup(transform.frame, group);
+  if ((frame.width <= 0 || frame.height <= 0) && geometry !== "line") return void 0;
+  const shape = {
+    modelId,
+    frame,
+    geometry,
+    has3d: Boolean(first(spPr, "scene3d", NS.a) || first(spPr, "sp3d", NS.a))
+  };
+  if (transform.rotation !== void 0) shape.rotation = transform.rotation;
+  if (transform.flipHorizontal) shape.flipHorizontal = true;
+  if (transform.flipVertical) shape.flipVertical = true;
+  if (adjustments) shape.adjustments = adjustments;
+  if (paths) shape.paths = paths;
+  const fill = parseDrawingFill(spPr);
+  if (fill) shape.fill = fill;
+  const line = parseDrawingLine(first(spPr, "ln", NS.a));
+  if (line) shape.line = line;
+  const style = first(sp, "style", NS.dsp);
+  if (style) shape.style = parseStyleReferences(style);
+  const text = parseDrawingTextBody(first(sp, "txBody", NS.dsp));
+  if (text) shape.text = text;
+  const textFrame = parseFrame(first(sp, "txXfrm", NS.dsp));
+  if (textFrame) shape.textFrame = applyGroup(textFrame, group);
+  return shape;
+}
+function parseDiagramDrawing(source, part) {
+  const root = (typeof source === "string" ? parseXml(source, { label: "DiagramML" }) : source).documentElement;
+  const issues = [];
+  const shapes = [];
+  const tree = root.localName === "spTree" ? root : first(root, "spTree", NS.dsp);
+  let counter = 0;
+  const visit = (container, group) => {
+    for (const child of Array.from(container.childNodes)) {
+      if (child.nodeType !== 1) continue;
+      const element = child;
+      if (element.localName === "sp") {
+        const shape = parseShape(element, counter++, group, issues);
+        if (shape) shapes.push(shape);
+      } else if (element.localName === "grpSp") visit(element, groupTransform(element, group));
+      else if (element.localName === "pic")
+        issues.push({
+          code: "DIAGRAM_DRAWING_PICTURE_SKIPPED",
+          message: "A dsp:pic in the cached drawing is not modelled; the part still holds it."
+        });
+    }
+  };
+  if (tree) visit(tree, IDENTITY);
+  else
+    issues.push({ code: "DIAGRAM_DRAWING_EMPTY", message: "The drawing part has no dsp:spTree." });
+  const withPart = part ? issues.map((issue) => ({ ...issue, part })) : issues;
+  return { shapes, issues: withPart };
+}
+var drawingHas3d = (drawing) => drawing.shapes.some((shape) => shape.has3d);
+
+// src/diagram/load.ts
+var slot = [
+  ["data", "dataRelId"],
+  ["layout", "layoutRelId"],
+  ["quickStyle", "styleRelId"],
+  ["colors", "colorsRelId"]
+];
+async function loadDiagram(hostPart, relationshipIds, host) {
+  const issues = [];
+  const paths = {};
+  const hostRels = host.hostRelationships(hostPart);
+  for (const [name, key] of slot) {
+    const relId = relationshipIds[key];
+    if (!relId) {
+      issues.push({
+        code: "DIAGRAM_RELATIONSHIP_MISSING",
+        message: `The diagram has no ${name} relationship id.`
+      });
+      continue;
+    }
+    const target = hostRels?.get(relId);
+    if (target === void 0)
+      issues.push({
+        code: "DIAGRAM_RELATIONSHIP_UNRESOLVED",
+        message: `Relationship ${relId} (${name}) is not in ${hostPart}.`
+      });
+    else paths[name] = host.resolvePath(hostPart, target);
+  }
+  const read = async (name, parse) => {
+    const part = paths[name];
+    if (!part) return void 0;
+    try {
+      const xml = await host.readText(part);
+      if (xml === void 0) {
+        issues.push({
+          code: "DIAGRAM_PART_MISSING",
+          message: `Part ${part} is not in the package.`,
+          part
+        });
+        return void 0;
+      }
+      return parse(xml, part);
+    } catch (error) {
+      issues.push({
+        code: "DIAGRAM_PART_UNREADABLE",
+        message: `Part ${part} could not be parsed: ${error instanceof Error ? error.message : String(error)}`,
+        part
+      });
+      return void 0;
+    }
+  };
+  const data = await read("data", (xml, part) => parseDiagramDataModel(xml, part));
+  if (data) issues.push(...data.issues);
+  const layout = await read("layout", (xml) => parseDiagramLayoutSummary(xml));
+  const colors = await read("colors", (xml) => parseDiagramColors(xml));
+  const quickStyle = await read("quickStyle", (xml) => parseDiagramQuickStyle(xml));
+  let drawingResolution;
+  try {
+    drawingResolution = await resolveDiagramDrawingPart(
+      hostPart,
+      relationshipIds.dataRelId ?? "",
+      data?.drawingRelId ?? "",
+      host
+    );
+  } catch (error) {
+    issues.push({
+      code: "DIAGRAM_DRAWING_UNRESOLVED",
+      message: `The cached drawing could not be located: ${error instanceof Error ? error.message : String(error)}`
+    });
+  }
+  let drawing;
+  if (drawingResolution) {
+    paths.drawing = drawingResolution.path;
+    drawing = await read("drawing", (xml, part) => parseDiagramDrawing(xml, part));
+    if (drawing) issues.push(...drawing.issues);
+  } else if (data)
+    issues.push({
+      code: "DIAGRAM_DRAWING_ABSENT",
+      message: "The package has no cached drawing for this diagram; its layout can only be recomputed from the layout definition."
+    });
+  return {
+    relationshipIds,
+    paths,
+    ...drawingResolution ? { drawingRelId: drawingResolution.relId } : {},
+    ...data ? { data } : {},
+    ...layout ? { layout } : {},
+    ...colors ? { colors } : {},
+    ...quickStyle ? { quickStyle } : {},
+    ...drawing ? { drawing } : {},
+    issues
+  };
+}
+
+exports.DIAGRAM_RELATIONSHIP_TYPES = DIAGRAM_RELATIONSHIP_TYPES;
+exports.attributeReader = attributeReader;
+exports.collectTransitionText = collectTransitionText;
+exports.connectionLabel = connectionLabel;
+exports.diagramRelationshipsPart = diagramRelationshipsPart;
+exports.drawingHas3d = drawingHas3d;
+exports.fillElementOf = fillElementOf;
+exports.loadDiagram = loadDiagram;
+exports.parseConnectionAttributes = parseConnectionAttributes;
+exports.parseCustomLayoutAttributes = parseCustomLayoutAttributes;
+exports.parseDefinitionHeader = parseDefinitionHeader;
+exports.parseDiagramColors = parseDiagramColors;
+exports.parseDiagramDataModel = parseDiagramDataModel;
+exports.parseDiagramDrawing = parseDiagramDrawing;
+exports.parseDiagramLayoutSummary = parseDiagramLayoutSummary;
+exports.parseDiagramQuickStyle = parseDiagramQuickStyle;
+exports.parseDrawingColor = parseDrawingColor;
+exports.parseDrawingColorIn = parseDrawingColorIn;
+exports.parseDrawingColorList = parseDrawingColorList;
+exports.parseDrawingFill = parseDrawingFill;
+exports.parseDrawingGeometry = parseDrawingGeometry;
+exports.parseDrawingLine = parseDrawingLine;
+exports.parseDrawingTextBody = parseDrawingTextBody;
+exports.parseFrame = parseFrame;
+exports.parseRelationshipIdAttributes = parseRelationshipIdAttributes;
+exports.parseStyleReferences = parseStyleReferences;
+exports.parseTransform = parseTransform;
+exports.resolveDiagramDrawingPart = resolveDiagramDrawingPart;
+exports.resolveDiagramLayoutCategory = resolveDiagramLayoutCategory;
+exports.resolveDrawingColor = resolveDrawingColor;
+exports.textBodyParagraphs = textBodyParagraphs;