ooxml-core 1.0.0 → 1.2.0

package/dist/drawingml/index.cjs

@@ -0,0 +1,1545 @@
+'use strict';
+
+var xmldom = require('@xmldom/xmldom');
+
+// xml/namespaces.ts
+var NS = {
+  /** DrawingML main. */
+  a: "http://schemas.openxmlformats.org/drawingml/2006/main",
+  /** 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)}`,
+      { cause: error }
+    );
+  }
+  if (parseError || !parsed.documentElement)
+    throw new Error(`Invalid ${label} XML: ${parseError || "missing root element"}`);
+  return parsed;
+}
+var buildXml = (node) => new xmldom.XMLSerializer().serializeToString(node);
+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;
+
+// drawingml/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;
+}
+
+// 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, roundChannel = Math.round, options) {
+  const sC = options?.clampSaturation === false ? s : 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: roundChannel((rP + m) * 255),
+    g: roundChannel((gP + m) * 255),
+    b: roundChannel((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;
+}
+
+// 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);
+}
+
+// drawingml/ordered-color-transforms.ts
+function orderedColorTransforms(channels, transforms) {
+  let { r, g, b } = channels;
+  let alpha = 1;
+  const wrap = (value) => (value % 360 + 360) % 360;
+  for (const transform of transforms) {
+    const { name, value } = transform;
+    const fraction = parseDrawingFraction(value);
+    if (name === "alpha" && fraction !== void 0) alpha = clampUnitInterval(fraction);
+    else if (name === "alphaMod" && fraction !== void 0)
+      alpha = clampUnitInterval(alpha * fraction);
+    else if (name === "alphaOff" && fraction !== void 0)
+      alpha = clampUnitInterval(alpha + fraction);
+    else if (name === "inv") [r, g, b] = [255 - r, 255 - g, 255 - b];
+    else if (name === "gray") r = g = b = 0.299 * r + 0.587 * g + 0.114 * b;
+    else if ((name === "shade" || name === "tint") && fraction !== void 0) {
+      const mix = (channel) => linearToSrgb255(
+        name === "shade" ? srgb255ToLinear(channel) * fraction : 1 - (1 - srgb255ToLinear(channel)) * fraction
+      );
+      [r, g, b] = [mix(r), mix(g), mix(b)];
+    } else {
+      const hsl = rgbToHsl(r, g, b);
+      if (name === "comp") hsl.h = wrap(hsl.h + 180);
+      else if (name === "hue") {
+        const hue = parseDrawingHueDegrees(value);
+        if (hue !== void 0) hsl.h = wrap(hue);
+      } else if (name === "hueOff") {
+        const hue = parseDrawingHueDegrees(value);
+        if (hue !== void 0) hsl.h = wrap(hsl.h + hue);
+      } else if (name === "hueMod" && fraction !== void 0) hsl.h = wrap(hsl.h * fraction);
+      else if (name === "sat" && fraction !== void 0) hsl.s = clampUnitInterval(fraction);
+      else if (name === "satMod" && fraction !== void 0) hsl.s *= fraction;
+      else if (name === "satOff" && fraction !== void 0)
+        hsl.s = clampUnitInterval(hsl.s + fraction);
+      else if (name === "lum" && fraction !== void 0) hsl.l = clampUnitInterval(fraction);
+      else if (name === "lumMod" && fraction !== void 0)
+        hsl.l = clampUnitInterval(hsl.l * fraction);
+      else if (name === "lumOff" && fraction !== void 0)
+        hsl.l = clampUnitInterval(hsl.l + fraction);
+      else continue;
+      ({ r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l, (channel) => channel, {
+        clampSaturation: false
+      }));
+    }
+  }
+  return { r, g, b, alpha };
+}
+
+// drawingml/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, options) {
+  const base = baseHex(color, theme);
+  const rgb = base ? hexToRgbChannels(base) : null;
+  if (!rgb) return void 0;
+  if (options?.transformOrder === "document") {
+    const value = orderedColorTransforms(rgb, color.transforms);
+    const round = options.hslRounding === "halfDown" ? (channel) => Math.ceil(channel - 0.5) : Math.round;
+    return {
+      hex: `#${toHex(round(value.r))}${toHex(round(value.g))}${toHex(round(value.b))}`,
+      alpha: value.alpha,
+      unapplied: [...new Set(color.transforms.map((transform) => transform.name))].filter(
+        (name) => !APPLIED.has(name)
+      )
+    };
+  }
+  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);
+    const round = options?.hslRounding === "halfDown" ? (value) => Math.ceil(value - 0.5) : Math.round;
+    ({ r, g, b } = hslToRgb(hsl.h, hsl.s, hsl.l, round));
+  }
+  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)
+    )
+  };
+}
+
+// drawingml/drawing-color-css.ts
+function drawingColorCss(value) {
+  if (!value || value.alpha === 1) return value?.hex;
+  const channels = [1, 3, 5].map(
+    (offset) => Number.parseInt(value.hex.slice(offset, offset + 2), 16)
+  );
+  return `rgba(${channels.join(",")},${value.alpha})`;
+}
+
+// drawingml/drawing-color-brightness.ts
+function drawingColorBrightness(color) {
+  const transforms = color.transforms.filter(
+    (item) => ["lum", "lumMod", "lumOff"].includes(item.name)
+  );
+  if (!transforms.length) return 0;
+  const mod = transforms.find((item) => item.name === "lumMod");
+  const off = transforms.find((item) => item.name === "lumOff");
+  if (!mod || transforms[0] !== mod || transforms.length !== (off ? 2 : 1)) return void 0;
+  const multiplier = Number(mod.value);
+  const offset = off ? Number(off.value) : 0;
+  if (!mod.value || off && !off.value || !Number.isFinite(multiplier) || !Number.isFinite(offset) || multiplier < 0 || multiplier > 1e5 || offset < 0 || offset > 1e5)
+    return void 0;
+  if (off && multiplier + offset !== 1e5) return void 0;
+  return Math.round(off ? offset : multiplier - 1e5) / 1e3;
+}
+function withDrawingColorBrightness(color, percent) {
+  if (!Number.isFinite(percent) || percent < -100 || percent > 100)
+    throw new RangeError("Brightness must be from -100 to 100");
+  const result = structuredClone(color);
+  result.transforms = result.transforms.filter((item) => !["lumMod", "lumOff"].includes(item.name));
+  result.transforms.push({
+    name: "lumMod",
+    value: String(Math.round((100 - Math.abs(percent)) * 1e3))
+  });
+  if (percent > 0)
+    result.transforms.push({ name: "lumOff", value: String(Math.round(percent * 1e3)) });
+  return result;
+}
+
+// drawingml/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 scaled = first(fill, "lin", NS.a)?.getAttribute("scaled");
+      const path = first(fill, "path", NS.a)?.getAttribute("path");
+      const focus = first(first(fill, "path", NS.a), "fillToRect", NS.a);
+      const tile = first(fill, "tileRect", NS.a);
+      const tileRect = tile ? {
+        l: Number(tile.getAttribute("l") ?? 0) / 1e5,
+        t: Number(tile.getAttribute("t") ?? 0) / 1e5,
+        r: Number(tile.getAttribute("r") ?? 0) / 1e5,
+        b: Number(tile.getAttribute("b") ?? 0) / 1e5
+      } : void 0;
+      const fillToRect = focus ? {
+        l: Number(focus.getAttribute("l") ?? 0) / 1e5,
+        t: Number(focus.getAttribute("t") ?? 0) / 1e5,
+        r: Number(focus.getAttribute("r") ?? 0) / 1e5,
+        b: Number(focus.getAttribute("b") ?? 0) / 1e5
+      } : void 0;
+      return {
+        kind: "gradient",
+        sourceXml: buildXml(fill),
+        stops,
+        ...Number.isFinite(angle) ? { angle: angle / 6e4 } : {},
+        ...scaled === "1" || scaled === "true" ? { scaled: true } : {},
+        ...scaled === "0" || scaled === "false" ? { scaled: false } : {},
+        ...path ? { path } : {},
+        ...fillToRect && Object.values(fillToRect).every(Number.isFinite) ? { fillToRect } : {},
+        ...tileRect && Object.values(tileRect).every(Number.isFinite) ? { tileRect } : {}
+      };
+    }
+    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;
+}
+
+// drawingml/drawing-text.ts
+function parseSpacing(parent) {
+  for (const [name, unit, divisor] of [
+    ["spcPts", "points", 100],
+    ["spcPct", "percent", 1e5]
+  ]) {
+    const raw = first(parent, name, NS.a)?.getAttribute("val");
+    if (raw == null || !/^\d+$/.test(raw)) continue;
+    const value = Number(raw) / divisor;
+    if (Number.isFinite(value)) return { unit, value };
+  }
+  return void 0;
+}
+function parseProperties(properties) {
+  const parsed = {};
+  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 parseRun(run) {
+  return {
+    text: run.localName === "br" ? "\n" : first(run, "t", NS.a)?.textContent ?? "",
+    ...parseProperties(first(run, "rPr", NS.a))
+  };
+}
+function parseParagraph(paragraph) {
+  const runs = [];
+  for (const child of elements(paragraph))
+    if (child.namespaceURI === NS.a && ["r", "fld", "br"].includes(child.localName))
+      runs.push(parseRun(child));
+  const properties = first(paragraph, "pPr", NS.a);
+  const align = properties?.getAttribute("algn");
+  const defaults = parseProperties(first(properties, "defRPr", NS.a));
+  const lineSpacing = parseSpacing(first(properties, "lnSpc", NS.a));
+  const spaceBefore = parseSpacing(first(properties, "spcBef", NS.a));
+  const spaceAfter = parseSpacing(first(properties, "spcAft", NS.a));
+  return {
+    ...align ? { align } : {},
+    ...Object.keys(defaults).length ? { defaultProperties: defaults } : {},
+    ...lineSpacing ? { lineSpacing } : {},
+    ...spaceBefore ? { spaceBefore } : {},
+    ...spaceAfter ? { spaceAfter } : {},
+    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;
+}
+
+// drawingml/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 } : {} };
+}
+
+// units/constants.ts
+var EMU_PER_PIXEL = 9525;
+
+// drawingml/drawing-shadow.ts
+function resolveDrawingShadow(effects, theme) {
+  const node = first(effects, "outerShdw", NS.a);
+  if (!node) return void 0;
+  const value = (key, fallback) => Number(node.getAttribute(key) ?? fallback);
+  if (value("sx", 1e5) !== 1e5 || value("sy", 1e5) !== 1e5 || value("kx", 0) !== 0 || value("ky", 0) !== 0)
+    return void 0;
+  const color = parseDrawingColorIn(node);
+  const resolved = color && resolveDrawingColor(color, theme, { transformOrder: "document" });
+  const blur = value("blurRad", 0) / EMU_PER_PIXEL;
+  const distance = value("dist", 0) / EMU_PER_PIXEL;
+  const angle = value("dir", 0) / 6e4 * Math.PI / 180;
+  if (!resolved || ![blur, distance, angle].every(Number.isFinite) || blur < 0 || distance < 0)
+    return void 0;
+  return {
+    color: resolved.hex,
+    opacity: resolved.alpha,
+    blur,
+    dx: Math.cos(angle) * distance,
+    dy: Math.sin(angle) * distance
+  };
+}
+function resolveDrawingShadowXml(xml, theme) {
+  return xml ? resolveDrawingShadow(parseXml(xml).documentElement, theme) : void 0;
+}
+function svgDropShadowElement(s, format) {
+  const num = format.number;
+  return `<feDropShadow dx="${num(s.dx)}" dy="${num(s.dy)}" stdDeviation="${num(s.blur / 2)}" flood-color="${format.color(s.color, "#000000")}" flood-opacity="${num(s.opacity)}" result="shadow"/>`;
+}
+
+// drawingml/write-color.ts
+var ELEMENTS = {
+  srgb: "srgbClr",
+  scheme: "schemeClr",
+  system: "sysClr",
+  preset: "prstClr",
+  scrgb: "scrgbClr",
+  hsl: "hslClr"
+};
+function drawingColorXml(color) {
+  const local = ELEMENTS[color.kind];
+  const doc = parseXml(`<a:${local} xmlns:a="${NS.a}"/>`);
+  const root = doc.documentElement;
+  if (color.kind === "scrgb" || color.kind === "hsl") {
+    const keys = color.kind === "scrgb" ? ["r", "g", "b"] : ["hue", "sat", "lum"];
+    const values = color.value.split(",");
+    keys.forEach((key, i) => root.setAttribute(key, values[i] ?? "0"));
+  } else root.setAttribute("val", color.value);
+  if (color.fallback !== void 0 && color.kind === "system")
+    root.setAttribute("lastClr", color.fallback);
+  for (const transform of color.transforms) {
+    if (!/^[A-Za-z_][\w.-]*$/.test(transform.name))
+      throw new Error(`Invalid DrawingML transform ${transform.name}`);
+    const node = doc.createElementNS(NS.a, `a:${transform.name}`);
+    if (transform.value !== "") node.setAttribute("val", transform.value);
+    root.appendChild(node);
+  }
+  return buildXml(doc);
+}
+
+// drawingml/write-fill.ts
+function setDrawingFillXml(properties, xml) {
+  const doc = properties.ownerDocument;
+  const wrapper = parseXml(`<w xmlns:a="${NS.a}">${xml}</w>`);
+  const fill = elements(wrapper.documentElement)[0];
+  const names = ["solidFill", "gradFill", "pattFill", "blipFill", "grpFill", "noFill"];
+  if (elements(wrapper.documentElement).length !== 1 || !fill || fill.namespaceURI !== NS.a || !names.includes(fill.localName))
+    throw new Error("Invalid DrawingML fill XML");
+  const existing = elements(properties).filter(
+    (node) => node.namespaceURI === NS.a && names.includes(node.localName)
+  );
+  const next = doc.importNode(fill, true);
+  if (existing[0]) properties.replaceChild(next, existing[0]);
+  else
+    properties.insertBefore(
+      next,
+      elements(properties).find(
+        (node) => node.namespaceURI === NS.a && ["ln", "effectLst", "effectDag", "scene3d", "sp3d", "extLst"].includes(node.localName)
+      ) ?? null
+    );
+  for (const extra of existing.slice(1)) properties.removeChild(extra);
+}
+function drawingFillXml(fill) {
+  if (fill.kind === "none") return "<a:noFill/>";
+  if (fill.kind === "solid") return `<a:solidFill>${drawingColorXml(fill.color)}</a:solidFill>`;
+  if (fill.kind !== "gradient") return void 0;
+  const doc = parseXml(fill.sourceXml ?? `<a:gradFill xmlns:a="${NS.a}"/>`);
+  const root = doc.documentElement;
+  if (root.namespaceURI !== NS.a || root.localName !== "gradFill")
+    throw new Error("Invalid gradient source XML");
+  const fragment = (xml) => doc.importNode(elements(parseXml(`<w xmlns:a="${NS.a}">${xml}</w>`).documentElement)[0], true);
+  let list = first(root, "gsLst", NS.a);
+  if (!list) {
+    list = doc.createElementNS(NS.a, "a:gsLst");
+    root.insertBefore(list, root.firstChild);
+  }
+  const stops = children(list, "gs", NS.a).filter(
+    (node) => parseDrawingColorIn(node) && Number.isFinite(Number.parseInt(node.getAttribute("pos") ?? "", 10))
+  );
+  fill.stops.forEach((stop, index) => {
+    const node = stops[index] ?? doc.createElementNS(NS.a, "a:gs");
+    if (!node.parentNode) list.appendChild(node);
+    node.setAttribute("pos", String(Math.round(stop.position * 1e3)));
+    for (const old of elements(node))
+      if (old.namespaceURI === NS.a && old.localName.endsWith("Clr")) node.removeChild(old);
+    node.insertBefore(fragment(drawingColorXml(stop.color)), node.firstChild);
+  });
+  for (const stop of stops.slice(fill.stops.length)) list.removeChild(stop);
+  for (const node of elements(root))
+    if (node.namespaceURI === NS.a && (node.localName === "lin" && (fill.angle === void 0 || fill.path !== void 0) || node.localName === "path" && fill.path === void 0))
+      root.removeChild(node);
+  if (fill.angle !== void 0 && fill.path === void 0) {
+    let linear = first(root, "lin", NS.a);
+    if (!linear) {
+      linear = doc.createElementNS(NS.a, "a:lin");
+      root.insertBefore(
+        linear,
+        first(root, "tileRect", NS.a) ?? first(root, "extLst", NS.a) ?? null
+      );
+    }
+    linear.setAttribute("ang", String(Math.round(fill.angle * 6e4)));
+    if (fill.scaled !== void 0) linear.setAttribute("scaled", fill.scaled ? "1" : "0");
+  }
+  if (fill.path !== void 0) {
+    let path = first(root, "path", NS.a);
+    if (!path) {
+      path = doc.createElementNS(NS.a, "a:path");
+      root.insertBefore(path, first(root, "tileRect", NS.a) ?? first(root, "extLst", NS.a) ?? null);
+    }
+    path.setAttribute("path", fill.path);
+    if (!fill.fillToRect) {
+      const old = first(path, "fillToRect", NS.a);
+      if (old) path.removeChild(old);
+    } else {
+      let focus = first(path, "fillToRect", NS.a);
+      if (!focus) {
+        focus = doc.createElementNS(NS.a, "a:fillToRect");
+        path.appendChild(focus);
+      }
+      for (const [key, value] of Object.entries(fill.fillToRect))
+        focus.setAttribute(key, String(Math.round(value * 1e5)));
+    }
+  }
+  if (fill.tileRect) {
+    let tile = first(root, "tileRect", NS.a);
+    if (!tile) {
+      tile = doc.createElementNS(NS.a, "a:tileRect");
+      root.insertBefore(tile, first(root, "extLst", NS.a) ?? null);
+    }
+    for (const [key, value] of Object.entries(fill.tileRect))
+      tile.setAttribute(key, String(Math.round(value * 1e5)));
+  }
+  return buildXml(doc);
+}
+
+// drawingml/gradient-preset-data.ts
+var OFFICE_GRADIENT_PRESET_DATA = [
+  [
+    "Early Sunset",
+    [
+      [0, "000082"],
+      [3e4, "66008F"],
+      [64999, "BA0066"],
+      [89999, "FF0000"],
+      [1e5, "FF8200"]
+    ]
+  ],
+  [
+    "Late Sunset",
+    [
+      [0, "000000"],
+      [2e4, "000040"],
+      [5e4, "400040"],
+      [75e3, "8F0040"],
+      [89999, "F27300"],
+      [1e5, "FFBF00"]
+    ]
+  ],
+  [
+    "Nightfall",
+    [
+      [0, "000000"],
+      [39999, "0A128C"],
+      [7e4, "181CC7"],
+      [88e3, "7005D4"],
+      [1e5, "8C3D91"]
+    ]
+  ],
+  [
+    "Daybreak",
+    [
+      [0, "5E9EFF"],
+      [39999, "85C2FF"],
+      [7e4, "C4D6EB"],
+      [1e5, "FFEBFA"]
+    ]
+  ],
+  [
+    "Horizon",
+    [
+      [0, "DCEBF5"],
+      [8e3, "83A7C3"],
+      [13e3, "768FB9"],
+      [21001, "83A7C3"],
+      [52e3, "FFFFFF"],
+      [56e3, "9C6563"],
+      [58e3, "80302D"],
+      [71001, "C0524E"],
+      [94e3, "EBDAD4"],
+      [1e5, "55261C"]
+    ]
+  ],
+  [
+    "Desert",
+    [
+      [0, "FC9FCB"],
+      [13e3, "F8B049"],
+      [21001, "F8B049"],
+      [63e3, "FEE7F2"],
+      [67e3, "F952A0"],
+      [69e3, "C50849"],
+      [82001, "B43E85"],
+      [1e5, "F8B049"]
+    ]
+  ],
+  [
+    "Ocean",
+    [
+      [0, "03D4A8"],
+      [25e3, "21D6E0"],
+      [75e3, "0087E6"],
+      [1e5, "005CBF"]
+    ]
+  ],
+  [
+    "Calm Water",
+    [
+      [0, "CCCCFF"],
+      [17999, "99CCFF"],
+      [36e3, "9966FF"],
+      [61e3, "CC99FF"],
+      [82001, "99CCFF"],
+      [1e5, "CCCCFF"]
+    ]
+  ],
+  [
+    "Fire",
+    [
+      [0, "FFF200"],
+      [45e3, "FF7A00"],
+      [7e4, "FF0300"],
+      [1e5, "4D0808"]
+    ]
+  ],
+  [
+    "Fog",
+    [
+      [0, "8488C4"],
+      [53e3, "D4DEFF"],
+      [83e3, "D4DEFF"],
+      [1e5, "96AB94"]
+    ]
+  ],
+  [
+    "Moss",
+    [
+      [0, "DDEBCF"],
+      [5e4, "9CB86E"],
+      [1e5, "156B13"]
+    ]
+  ],
+  [
+    "Peacock",
+    [
+      [0, "3399FF"],
+      [16e3, "00CCCC"],
+      [47e3, "9999FF"],
+      [60001, "2E6792"],
+      [71001, "3333CC"],
+      [81e3, "1170FF"],
+      [1e5, "006699"]
+    ]
+  ],
+  [
+    "Wheat",
+    [
+      [0, "FBEAC7"],
+      [17999, "FEE7F2"],
+      [36e3, "FAC77D"],
+      [61e3, "FBA97D"],
+      [82001, "FBD49C"],
+      [1e5, "FEE7F2"]
+    ]
+  ],
+  [
+    "Parchment",
+    [
+      [0, "FFEFD1"],
+      [64999, "F0EBD5"],
+      [1e5, "D1C39F"]
+    ]
+  ],
+  [
+    "Mahogany",
+    [
+      [0, "D6B19C"],
+      [3e4, "D49E6C"],
+      [7e4, "A65528"],
+      [1e5, "663012"]
+    ]
+  ],
+  [
+    "Rainbow",
+    [
+      [0, "A603AB"],
+      [21001, "0819FB"],
+      [35001, "1A8D48"],
+      [52e3, "FFFF00"],
+      [73e3, "EE3F17"],
+      [88e3, "E81766"],
+      [1e5, "A603AB"]
+    ]
+  ],
+  [
+    "Rainbow II",
+    [
+      [0, "FF3399"],
+      [25e3, "FF6633"],
+      [5e4, "FFFF00"],
+      [75e3, "01A78F"],
+      [1e5, "3366FF"]
+    ]
+  ],
+  [
+    "Gold",
+    [
+      [0, "E6DCAC"],
+      [12e3, "E6D78A"],
+      [3e4, "C7AC4C"],
+      [45e3, "E6D78A"],
+      [77e3, "C7AC4C"],
+      [1e5, "E6DCAC"]
+    ]
+  ],
+  [
+    "Gold II",
+    [
+      [0, "FBE4AE"],
+      [13e3, "BD922A"],
+      [21001, "BD922A"],
+      [63e3, "FBE4AE"],
+      [67e3, "BD922A"],
+      [69e3, "835E17"],
+      [82001, "A28949"],
+      [1e5, "FAE3B7"]
+    ]
+  ],
+  [
+    "Brass",
+    [
+      [0, "825600"],
+      [13e3, "FFA800"],
+      [28e3, "825600"],
+      [42999, "FFA800"],
+      [58e3, "825600"],
+      [72e3, "FFA800"],
+      [87e3, "825600"],
+      [1e5, "FFA800"]
+    ]
+  ],
+  [
+    "Chrome",
+    [
+      [0, "FFFFFF"],
+      [16e3, "1F1F1F"],
+      [17999, "FFFFFF"],
+      [42e3, "636363"],
+      [53e3, "CFCFCF"],
+      [66e3, "CFCFCF"],
+      [75999, "1F1F1F"],
+      [78999, "FFFFFF"],
+      [1e5, "7F7F7F"]
+    ]
+  ],
+  [
+    "Chrome II",
+    [
+      [0, "CBCBCB"],
+      [13e3, "5F5F5F"],
+      [21001, "5F5F5F"],
+      [63e3, "FFFFFF"],
+      [67e3, "B2B2B2"],
+      [69e3, "292929"],
+      [82001, "777777"],
+      [1e5, "EAEAEA"]
+    ]
+  ],
+  [
+    "Silver",
+    [
+      [0, "FFFFFF"],
+      [7001, "E6E6E6"],
+      [32001, "7D8496"],
+      [47e3, "E6E6E6"],
+      [85001, "7D8496"],
+      [1e5, "E6E6E6"]
+    ]
+  ],
+  [
+    "Sapphire",
+    [
+      [0, "000082"],
+      [13e3, "0047FF"],
+      [28e3, "000082"],
+      [42999, "0047FF"],
+      [58e3, "000082"],
+      [72e3, "0047FF"],
+      [87e3, "000082"],
+      [1e5, "0047FF"]
+    ]
+  ]
+];
+
+// drawingml/gradient-presets.ts
+var OFFICE_GRADIENT_PRESETS = OFFICE_GRADIENT_PRESET_DATA.map(([label], index) => ({
+  id: index + 1,
+  label
+}));
+function officeGradientPresetFill(id) {
+  const data = Number.isInteger(id) && OFFICE_GRADIENT_PRESET_DATA[id - 1];
+  if (!data) throw new RangeError(`Unknown Office gradient preset ${id}`);
+  return {
+    kind: "gradient",
+    angle: 90,
+    scaled: true,
+    sourceXml: `<a:gradFill xmlns:a="${NS.a}" flip="none" rotWithShape="1"><a:tileRect/></a:gradFill>`,
+    stops: data[1].map(([position, color]) => ({
+      position: position / 1e3,
+      color: { kind: "srgb", value: color, transforms: [] }
+    }))
+  };
+}
+function officeGradientPresetId(fill) {
+  if (fill.kind !== "gradient" || fill.path || fill.angle !== 90 || fill.scaled !== true)
+    return void 0;
+  const index = OFFICE_GRADIENT_PRESET_DATA.findIndex(
+    ([, stops]) => stops.length === fill.stops.length && stops.every(([position, color], index2) => {
+      const stop = fill.stops[index2];
+      return stop?.position === position / 1e3 && stop.color.kind === "srgb" && stop.color.value.toUpperCase() === color && stop.color.transforms.length === 0;
+    })
+  );
+  return index < 0 ? void 0 : index + 1;
+}
+
+// drawingml/gradient-geometry.ts
+var RECT_GRADIENT_DIRECTIONS = [
+  { id: "center", label: "From Center", x: 0.5, y: 0.5 },
+  { id: "top-left", label: "From Top Left Corner", x: 0, y: 0 },
+  { id: "top-right", label: "From Top Right Corner", x: 1, y: 0 },
+  { id: "bottom-left", label: "From Bottom Left Corner", x: 0, y: 1 },
+  { id: "bottom-right", label: "From Bottom Right Corner", x: 1, y: 1 }
+];
+function rectGradientFocus(id) {
+  const direction = RECT_GRADIENT_DIRECTIONS.find((direction2) => direction2.id === id);
+  if (!direction) throw new RangeError(`Unknown rectangular gradient direction ${id}`);
+  return { l: direction.x, t: direction.y, r: 1 - direction.x, b: 1 - direction.y };
+}
+function rectGradientDirection(focus) {
+  return RECT_GRADIENT_DIRECTIONS.find(
+    ({ x, y }) => focus?.l === x && focus.t === y && focus.r === 1 - x && focus.b === 1 - y
+  )?.id;
+}
+function withDrawingGradientGeometry(fill, type, direction = "center") {
+  const next = structuredClone(fill);
+  next.tileRect = { l: 0, t: 0, r: 0, b: 0 };
+  if (type === "linear") {
+    delete next.path;
+    delete next.fillToRect;
+    next.angle ??= 90;
+    next.scaled = true;
+  } else if (type === "rect" || type === "circle" || type === "shape") {
+    next.path = type;
+    next.fillToRect = rectGradientFocus(direction);
+    delete next.angle;
+    delete next.scaled;
+    if (direction !== "center") {
+      const { l, t } = next.fillToRect;
+      next.tileRect = {
+        l: l === 0 ? -1 : 0,
+        t: t === 0 ? -1 : 0,
+        r: l === 1 ? -1 : 0,
+        b: t === 1 ? -1 : 0
+      };
+    }
+  } else throw new RangeError(`Unknown gradient type ${type}`);
+  return next;
+}
+
+// drawingml/rect-path-gradient.ts
+var BAND_COUNT = 40;
+function hexToRgb(color) {
+  const parsed = hexToRgbChannels(color);
+  if (parsed) return parsed;
+  const hex = color.replace("#", "");
+  return {
+    r: Number.parseInt(hex.slice(0, 2), 16) || 0,
+    g: Number.parseInt(hex.slice(2, 4), 16) || 0,
+    b: Number.parseInt(hex.slice(4, 6), 16) || 0
+  };
+}
+function toHexChannel(value) {
+  return toHex(value).toLowerCase();
+}
+function lerpStops(a, b, t) {
+  const ca = hexToRgb(a.color);
+  const cb = hexToRgb(b.color);
+  const oa = a.opacity ?? 1;
+  const ob = b.opacity ?? 1;
+  return {
+    color: `#${toHexChannel(ca.r + (cb.r - ca.r) * t)}${toHexChannel(ca.g + (cb.g - ca.g) * t)}${toHexChannel(ca.b + (cb.b - ca.b) * t)}`,
+    opacity: oa + (ob - oa) * t
+  };
+}
+function colorAt(stops, position) {
+  const first2 = stops[0];
+  const last = stops[stops.length - 1];
+  if (position <= first2.position) {
+    return { color: first2.color, opacity: first2.opacity ?? 1 };
+  }
+  if (position >= last.position) {
+    return { color: last.color, opacity: last.opacity ?? 1 };
+  }
+  for (let i = 0; i < stops.length - 1; i += 1) {
+    const from = stops[i];
+    const to = stops[i + 1];
+    if (position >= from.position && position <= to.position) {
+      const span = to.position - from.position;
+      const t = span > 0 ? (position - from.position) / span : 0;
+      return lerpStops(from, to, t);
+    }
+  }
+  return { color: last.color, opacity: last.opacity ?? 1 };
+}
+function resolveInnerRect(fillToRect, focalPoint) {
+  let centerX = 50;
+  let centerY = 50;
+  let width = 0;
+  let height = 0;
+  if (fillToRect) {
+    const { l, t, r, b } = fillToRect;
+    centerX = (l + (1 - r)) / 2 * 100;
+    centerY = (t + (1 - b)) / 2 * 100;
+    width = Math.max(0, Math.min(1, 1 - l - r)) * 100;
+    height = Math.max(0, Math.min(1, 1 - t - b)) * 100;
+    if (focalPoint) {
+      centerX = (centerX + focalPoint.x * 100) / 2;
+      centerY = (centerY + focalPoint.y * 100) / 2;
+    }
+  } else if (focalPoint) {
+    centerX = focalPoint.x * 100;
+    centerY = focalPoint.y * 100;
+  }
+  return {
+    left: centerX - width / 2,
+    top: centerY - height / 2,
+    right: centerX + width / 2,
+    bottom: centerY + height / 2
+  };
+}
+function lerpEdge(inner, outer, t) {
+  return inner + (outer - inner) * t;
+}
+function buildRectPathGradientSvg(stops, focalPoint, fillToRect, options) {
+  if (stops.length === 0) {
+    return '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100"/>';
+  }
+  const sorted = [...stops].sort((a, b) => a.position - b.position);
+  const inner = resolveInnerRect(fillToRect, focalPoint);
+  const rects = [];
+  const alphaRects = [];
+  const masked = options?.independentOpacity && sorted.some((stop) => (stop.opacity ?? 1) < 1);
+  const bands = options?.bands ?? BAND_COUNT;
+  if (!Number.isInteger(bands) || bands < 1) throw new RangeError("Invalid gradient band count");
+  for (let i = bands; i >= 0; i -= 1) {
+    const t = i / bands;
+    const { color, opacity } = colorAt(sorted, t * 100);
+    const left = lerpEdge(inner.left, 0, t);
+    const top = lerpEdge(inner.top, 0, t);
+    const right = lerpEdge(inner.right, 100, t);
+    const bottom = lerpEdge(inner.bottom, 100, t);
+    const opacityAttr = !masked && opacity < 1 ? ` fill-opacity="${Math.max(0, opacity).toFixed(3)}"` : "";
+    rects.push(
+      `<rect x="${left.toFixed(2)}" y="${top.toFixed(2)}" width="${(right - left).toFixed(2)}" height="${(bottom - top).toFixed(2)}" fill="${color}"${opacityAttr}/>`
+    );
+    if (masked) {
+      const channel = toHexChannel(opacity * 255);
+      alphaRects.push(
+        `<rect x="${left.toFixed(2)}" y="${top.toFixed(2)}" width="${(right - left).toFixed(2)}" height="${(bottom - top).toFixed(2)}" fill="#${channel}${channel}${channel}"/>`
+      );
+    }
+  }
+  const paint = masked ? `<defs><mask id="alpha" maskUnits="userSpaceOnUse" x="0" y="0" width="100" height="100" mask-type="luminance" color-interpolation="sRGB">${alphaRects.join("")}</mask></defs><g mask="url(#alpha)">${rects.join("")}</g>` : rects.join("");
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100" preserveAspectRatio="none">${paint}</svg>`;
+}
+function buildRectPathGradientImage(stops, focalPoint, fillToRect) {
+  const markup = buildRectPathGradientSvg(stops, focalPoint, fillToRect);
+  return `url("data:image/svg+xml,${encodeURIComponent(markup)}")`;
+}
+
+// drawingml/theme-model.ts
+var THEME_COLOR_SLOTS = [
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var DEFAULT_THEME_COLOR_MAP = {
+  bg1: "lt1",
+  tx1: "dk1",
+  bg2: "lt2",
+  tx2: "dk2"
+};
+
+// drawingml/theme.ts
+var MAP_KEYS = [
+  "bg1",
+  "tx1",
+  "bg2",
+  "tx2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+var SLOT_SET = new Set(THEME_COLOR_SLOTS);
+function isThemeColorSlot(value) {
+  return SLOT_SET.has(value);
+}
+function nonEmpty(value) {
+  return value ? value : void 0;
+}
+function parseThemeColorScheme(scheme) {
+  const result = { colors: {} };
+  if (!scheme) return result;
+  const name = nonEmpty(scheme.getAttribute("name"));
+  if (name) result.name = name;
+  for (const slot of THEME_COLOR_SLOTS) {
+    const color = parseDrawingColorIn(first(scheme, slot, NS.a));
+    if (color) result.colors[slot] = color;
+  }
+  return result;
+}
+function parseFontCollection(collection) {
+  const result = { scripts: {} };
+  if (!collection) return result;
+  const typeface = (local) => nonEmpty(first(collection, local, NS.a)?.getAttribute("typeface"));
+  const latin = typeface("latin");
+  const eastAsia = typeface("ea");
+  const complexScript = typeface("cs");
+  if (latin) result.latin = latin;
+  if (eastAsia) result.eastAsia = eastAsia;
+  if (complexScript) result.complexScript = complexScript;
+  for (const font of elements(collection)) {
+    if (font.localName !== "font") continue;
+    const script = nonEmpty(font.getAttribute("script"));
+    const face = nonEmpty(font.getAttribute("typeface"));
+    if (script && face && !Object.hasOwn(result.scripts, script)) result.scripts[script] = face;
+  }
+  return result;
+}
+function parseThemeFontScheme(scheme) {
+  const result = {
+    major: parseFontCollection(first(scheme, "majorFont", NS.a)),
+    minor: parseFontCollection(first(scheme, "minorFont", NS.a))
+  };
+  const name = nonEmpty(scheme?.getAttribute("name"));
+  if (name) result.name = name;
+  return result;
+}
+function rootOf(source) {
+  return "documentElement" in source ? source.documentElement : source;
+}
+function parseTheme(source) {
+  const root = rootOf(source);
+  const holder = first(root, "themeElements", NS.a) ?? root;
+  const theme = {
+    colorScheme: parseThemeColorScheme(first(holder, "clrScheme", NS.a)),
+    fontScheme: parseThemeFontScheme(first(holder, "fontScheme", NS.a))
+  };
+  const name = nonEmpty(root.getAttribute("name"));
+  if (name) theme.name = name;
+  return theme;
+}
+function parseThemeXml(xml, label = "DrawingML theme") {
+  return parseTheme(parseXml(xml, { label }));
+}
+function parseThemeColorMap(element) {
+  const map = {};
+  if (!element) return map;
+  for (const key of MAP_KEYS) {
+    const value = element.getAttribute(key);
+    if (value && isThemeColorSlot(value)) map[key] = value;
+  }
+  return map;
+}
+
+// drawingml/theme-color.ts
+function isLogical(name) {
+  return Object.hasOwn(DEFAULT_THEME_COLOR_MAP, name);
+}
+function themeColorSlotFor(name, colorMap = {}) {
+  if (isLogical(name)) return colorMap[name] ?? DEFAULT_THEME_COLOR_MAP[name];
+  if (!isThemeColorSlot(name)) return void 0;
+  if (name === "dk1" || name === "lt1" || name === "dk2" || name === "lt2") return name;
+  return colorMap[name] ?? name;
+}
+function resolveSchemeColor(scheme, name, colorMap) {
+  const slot = themeColorSlotFor(name, colorMap);
+  return slot ? scheme.colors[slot] : void 0;
+}
+function themeSlotHex(color) {
+  if (!color) return void 0;
+  const value = color.kind === "srgb" ? color.value : color.kind === "system" ? color.fallback : void 0;
+  return value ? value.toUpperCase() : void 0;
+}
+function themeDrawingColorTheme(scheme, colorMap) {
+  return {
+    scheme(name) {
+      const hex = scheme && themeSlotHex(resolveSchemeColor(scheme, name, colorMap));
+      return hex ? `#${hex.replace(/^#/, "")}` : void 0;
+    }
+  };
+}
+
+exports.DEFAULT_THEME_COLOR_MAP = DEFAULT_THEME_COLOR_MAP;
+exports.OFFICE_GRADIENT_PRESETS = OFFICE_GRADIENT_PRESETS;
+exports.RECT_GRADIENT_DIRECTIONS = RECT_GRADIENT_DIRECTIONS;
+exports.THEME_COLOR_SLOTS = THEME_COLOR_SLOTS;
+exports.attributeReader = attributeReader;
+exports.booleanAttribute = booleanAttribute;
+exports.buildRectPathGradientImage = buildRectPathGradientImage;
+exports.buildRectPathGradientSvg = buildRectPathGradientSvg;
+exports.descendants = descendants;
+exports.drawingColorBrightness = drawingColorBrightness;
+exports.drawingColorCss = drawingColorCss;
+exports.drawingColorXml = drawingColorXml;
+exports.drawingFillXml = drawingFillXml;
+exports.fillElementOf = fillElementOf;
+exports.integerAttribute = integerAttribute;
+exports.isThemeColorSlot = isThemeColorSlot;
+exports.officeGradientPresetFill = officeGradientPresetFill;
+exports.officeGradientPresetId = officeGradientPresetId;
+exports.orderedColorTransforms = orderedColorTransforms;
+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.parseTheme = parseTheme;
+exports.parseThemeColorMap = parseThemeColorMap;
+exports.parseThemeColorScheme = parseThemeColorScheme;
+exports.parseThemeFontScheme = parseThemeFontScheme;
+exports.parseThemeXml = parseThemeXml;
+exports.parseTransform = parseTransform;
+exports.rectGradientDirection = rectGradientDirection;
+exports.rectGradientFocus = rectGradientFocus;
+exports.resolveDrawingColor = resolveDrawingColor;
+exports.resolveDrawingShadow = resolveDrawingShadow;
+exports.resolveDrawingShadowXml = resolveDrawingShadowXml;
+exports.resolveSchemeColor = resolveSchemeColor;
+exports.setDrawingFillXml = setDrawingFillXml;
+exports.stringAttribute = stringAttribute;
+exports.svgDropShadowElement = svgDropShadowElement;
+exports.themeColorSlotFor = themeColorSlotFor;
+exports.themeDrawingColorTheme = themeDrawingColorTheme;
+exports.themeSlotHex = themeSlotHex;
+exports.withDrawingColorBrightness = withDrawingColorBrightness;
+exports.withDrawingGradientGeometry = withDrawingGradientGeometry;