ooxml-core 1.1.0 → 1.2.0

package/dist/visio/index.mjs

@@ -3,6 +3,8 @@ import JSZip from 'jszip';
 
 // 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",
   /** Extended (app) properties. */
@@ -2019,7 +2021,7 @@ function checkVectorGraph(scene, limits) {
     if (depth > limits.maxDepth) limit("Expanded vector depth limit exceeded.");
     if (++expandedNodes > limits.maxExpandedNodes) limit("Expanded vector node limit exceeded.");
   }
-  function content(target, parent, depth) {
+  function content2(target, parent, depth) {
     charge(depth);
     const matrix3 = compose(parent, target.matrix, limits.maxCoordinate);
     if ("commands" in target) {
@@ -2035,11 +2037,11 @@ function checkVectorGraph(scene, limits) {
         finite(extent * (Math.abs(matrix3[0]) + Math.abs(matrix3[2])), limits.maxCoordinate);
         finite(extent * (Math.abs(matrix3[1]) + Math.abs(matrix3[3])), limits.maxCoordinate);
       }
-    } else for (const child2 of target.items) content(child2, matrix3, depth + 1);
-    if (target.clipIndex !== void 0) content(scene.clips[target.clipIndex], matrix3, depth + 1);
+    } else for (const child2 of target.items) content2(child2, matrix3, depth + 1);
+    if (target.clipIndex !== void 0) content2(scene.clips[target.clipIndex], matrix3, depth + 1);
   }
-  for (const clip of scene.clips) content(clip, IDENTITY, 1);
-  for (const item of scene.items) content(item, IDENTITY, 1);
+  for (const clip of scene.clips) content2(clip, IDENTITY, 1);
+  for (const item of scene.items) content2(item, IDENTITY, 1);
 }
 
 // visio/foreign-vector-validation.ts
@@ -2693,13 +2695,13 @@ function gif(bytes, limits) {
 }
 function jpeg(bytes, limits) {
   const view2 = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  let at2 = 2, width = 0, height = 0, scan = false;
+  let at2 = 2, width = 0, height = 0, scan2 = false;
   while (at2 < bytes.length) {
     if (bytes[at2++] !== 255) invalid("JPEG has an invalid segment marker.");
     while (bytes[at2] === 255) at2++;
     const marker2 = bytes[at2++];
     if (marker2 === 217) {
-      if (!width || !scan || at2 !== bytes.length) invalid("JPEG has an invalid image terminator.");
+      if (!width || !scan2 || at2 !== bytes.length) invalid("JPEG has an invalid image terminator.");
       return [width, height];
     }
     if (marker2 === void 0 || marker2 === 0 || marker2 === 216 || marker2 === 1 || marker2 >= 208 && marker2 <= 215)
@@ -2721,7 +2723,7 @@ function jpeg(bytes, limits) {
     if (marker2 === 218) {
       if (!width || length < 8 || length !== 6 + 2 * bytes[end - length + 2])
         invalid("JPEG has an invalid scan header.");
-      scan = true;
+      scan2 = true;
       while (at2 < bytes.length) {
         if (bytes[at2] !== 255) {
           at2++;
@@ -3225,6 +3227,104 @@ function hexToRgbChannels(color2) {
     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 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) {
@@ -3236,6 +3336,239 @@ function linearToSrgb255(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 transform2 of transforms) {
+    const { name, value } = transform2;
+    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 attribute3 = (name) => element.getAttribute(name) ?? "";
+  if (kind === "scrgb") return `${attribute3("r")},${attribute3("g")},${attribute3("b")}`;
+  if (kind === "hsl") return `${attribute3("hue")},${attribute3("sat")},${attribute3("lum")}`;
+  return attribute3("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 color2 = {
+    kind,
+    value: colorValue(kind, element),
+    transforms: elements(element).map((child2) => ({
+      name: child2.localName,
+      value: child2.getAttribute("val") ?? ""
+    }))
+  };
+  const fallback = kind === "system" ? element.getAttribute("lastClr") : null;
+  if (fallback) color2.fallback = fallback;
+  return color2;
+}
+var PRESET_COLORS = {
+  black: "#000000",
+  white: "#FFFFFF",
+  red: "#FF0000",
+  green: "#008000",
+  blue: "#0000FF",
+  yellow: "#FFFF00",
+  gray: "#808080",
+  grey: "#808080"
+};
+function baseHex(color2, theme) {
+  switch (color2.kind) {
+    case "srgb":
+      return /^[0-9a-f]{6}$/i.test(color2.value) ? `#${color2.value.toUpperCase()}` : void 0;
+    case "scheme":
+      return theme?.scheme(color2.value);
+    case "system":
+      return color2.fallback && /^[0-9a-f]{6}$/i.test(color2.fallback) ? `#${color2.fallback.toUpperCase()}` : void 0;
+    case "preset":
+      return PRESET_COLORS[color2.value];
+    case "scrgb": {
+      const [r, g, b] = color2.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] = color2.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(color2, theme, options) {
+  const base = baseHex(color2, theme);
+  const rgb = base ? hexToRgbChannels(base) : null;
+  if (!rgb) return void 0;
+  {
+    const value = orderedColorTransforms(rgb, color2.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(color2.transforms.map((transform2) => transform2.name))].filter(
+        (name) => !APPLIED.has(name)
+      )
+    };
+  }
+}
+
+// drawingml/theme-model.ts
+var THEME_COLOR_SLOTS = [
+  "dk1",
+  "lt1",
+  "dk2",
+  "lt2",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6",
+  "hlink",
+  "folHlink"
+];
+
+// drawingml/theme.ts
+new Set(THEME_COLOR_SLOTS);
+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 color2 = parseDrawingColorIn(first(scheme, slot, NS.a));
+    if (color2) result.colors[slot] = color2;
+  }
+  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 font2 of elements(collection)) {
+    if (font2.localName !== "font") continue;
+    const script = nonEmpty(font2.getAttribute("script"));
+    const face = nonEmpty(font2.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;
+}
+
 // visio/theme-color.ts
 var DRAWING_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
 var THEME_NS = "http://schemas.microsoft.com/office/visio/2012/theme";
@@ -3256,40 +3589,48 @@ function colorChoice(node) {
   const choices = (node ? elements(node) : []).filter((item) => item.namespaceURI === DRAWING_NS);
   return choices.length === 1 ? choices[0] : void 0;
 }
+var isParsed = (source) => typeof source.kind === "string";
+function visioColor(source) {
+  if (!source) return void 0;
+  if (isParsed(source)) return source;
+  if (source.namespaceURI !== DRAWING_NS) return void 0;
+  if (elements(source).some((transform2) => transform2.namespaceURI !== DRAWING_NS)) return void 0;
+  return parseDrawingColor(source);
+}
+function parsedColorChoice(node) {
+  return visioColor(colorChoice(node));
+}
+var SUPPORTED_TRANSFORMS = /* @__PURE__ */ new Set(["shade", "tint", "alpha"]);
 function drawingPaint(node, colors, placeholder, depth = 0) {
-  if (!node || depth > 8 || node.namespaceURI !== DRAWING_NS) return void 0;
+  if (depth > 8) return void 0;
+  const color2 = visioColor(node);
+  if (!color2 || color2.transforms.length > 32) return void 0;
+  const transforms = color2.transforms.filter((transform2) => transform2.name !== "hueMod");
+  if (transforms.some(
+    (transform2) => !SUPPORTED_TRANSFORMS.has(transform2.name) || (integer(transform2.value) ?? 100001) > 1e5
+  ))
+    return void 0;
   let rgb;
-  let opacity2 = 1;
-  if (node.localName === "srgbClr") rgb = node.getAttribute("val") ?? void 0;
-  else if (node.localName === "sysClr") rgb = node.getAttribute("lastClr") ?? void 0;
-  else if (node.localName === "schemeClr") {
-    const name = node.getAttribute("val") ?? "";
-    const inherited = name === "phClr" ? void 0 : drawingPaint(colors.get(name), colors, placeholder, depth + 1);
-    rgb = name === "phClr" ? placeholder : inherited?.color;
-    opacity2 = inherited?.opacity ?? 1;
+  let inherited;
+  if (color2.kind === "srgb") rgb = color2.value;
+  else if (color2.kind === "system") rgb = color2.fallback;
+  else if (color2.kind === "scheme") {
+    if (color2.value === "phClr") rgb = placeholder;
+    else {
+      inherited = drawingPaint(colors.get(color2.value), colors, placeholder, depth + 1);
+      rgb = inherited?.color;
+    }
   }
   if (!rgb || !/^#?[\da-f]{6}$/i.test(rgb)) return void 0;
-  rgb = rgb.replace(/^#/, "");
-  let channels = [0, 2, 4].map(
-    (offset) => srgb255ToLinear(parseInt(rgb.slice(offset, offset + 2), 16))
+  const resolved = resolveDrawingColor(
+    { kind: "srgb", value: rgb.replace(/^#/, ""), transforms },
+    void 0,
+    { }
   );
-  const transforms = elements(node);
-  if (transforms.length > 32) return void 0;
-  for (const transform2 of transforms) {
-    if (transform2.namespaceURI === DRAWING_NS && transform2.localName === "hueMod") continue;
-    const value = integer(transform2.getAttribute("val"));
-    if (transform2.namespaceURI !== DRAWING_NS || value === void 0 || value > 1e5)
-      return void 0;
-    const ratio = value / 1e5;
-    if (transform2.localName === "shade") channels = channels.map((channel) => channel * ratio);
-    else if (transform2.localName === "tint")
-      channels = channels.map((channel) => channel * ratio + 1 - ratio);
-    else if (transform2.localName === "alpha") opacity2 = ratio;
-    else return void 0;
-  }
+  if (!resolved) return void 0;
   return {
-    opacity: opacity2,
-    color: `#${channels.map((channel) => Math.round(linearToSrgb255(channel)).toString(16).padStart(2, "0")).join("")}`
+    opacity: transforms.some((transform2) => transform2.name === "alpha") ? resolved.alpha : inherited?.opacity ?? 1,
+    color: resolved.hex.toLowerCase()
   };
 }
 function drawingColor(node, colors, placeholder) {
@@ -3388,9 +3729,9 @@ function themeColor(cells3, name, resources, report, gradientRendered = false) {
   const { selected, colors, base } = context;
   if (category === "Font")
     return drawingColor(colorChoice(themeChild(selected, "color", THEME_NS)), colors, base);
-  const fill2 = category === "Fill" ? selected : themeChild(selected, "solidFill") ?? themeChild(selected, "noFill") ?? themeChild(selected, "gradFill");
-  if (fill2?.localName === "solidFill") return drawingColor(colorChoice(fill2), colors, base);
-  if (fill2?.localName === "gradFill" && base) {
+  const fill = category === "Fill" ? selected : themeChild(selected, "solidFill") ?? themeChild(selected, "noFill") ?? themeChild(selected, "gradFill");
+  if (fill?.localName === "solidFill") return drawingColor(colorChoice(fill), colors, base);
+  if (fill?.localName === "gradFill" && base) {
     if (!gradientRendered)
       report(
         "unsupported-theme-gradient",
@@ -3437,16 +3778,16 @@ function themeLinearGradient(sheet, resources, width, height, report) {
     (row) => [...row.cells.values()].some((cell) => cell.value !== "Themed")
   ))
     return reject2();
-  const fill2 = context.selected;
-  const lin = themeChild(fill2, "lin");
+  const fill = context.selected;
+  const lin = themeChild(fill, "lin");
   const rawAngle = lin?.getAttribute("ang") ?? "0";
   const angle = /^\d{1,8}$/.test(rawAngle) ? Number(rawAngle) : NaN;
-  if (!lin || !Number.isInteger(angle) || angle < 0 || angle >= 216e5 || !["1", "true"].includes(fill2.getAttribute("rotWithShape") ?? "1") || elements(fill2).some(
+  if (!lin || !Number.isInteger(angle) || angle < 0 || angle >= 216e5 || !["1", "true"].includes(fill.getAttribute("rotWithShape") ?? "1") || elements(fill).some(
     (node) => node.namespaceURI !== DRAWING_NS || !["gsLst", "lin", "tileRect"].includes(node.localName)
-  ) || themeChildren(fill2, "lin").length !== 1 || themeChildren(fill2, "gsLst").length !== 1)
+  ) || themeChildren(fill, "lin").length !== 1 || themeChildren(fill, "gsLst").length !== 1)
     return reject2();
-  const nodes = themeChildren(themeChild(fill2, "gsLst"), "gs");
-  if (nodes.length < 2 || nodes.length > 32 || elements(themeChild(fill2, "gsLst")).length !== nodes.length)
+  const nodes = themeChildren(themeChild(fill, "gsLst"), "gs");
+  if (nodes.length < 2 || nodes.length > 32 || elements(themeChild(fill, "gsLst")).length !== nodes.length)
     return reject2();
   const stops = [];
   for (const node of nodes) {
@@ -5083,7 +5424,7 @@ function indexLayers(layers) {
 }
 function pageLayers(sheet, resources, report) {
   return sectionRows(sheet, "Layer").map((row) => {
-    const colorValue = row.cells.get("Color")?.value;
+    const colorValue2 = row.cells.get("Color")?.value;
     return {
       id: row.index,
       name: metadata(
@@ -5094,7 +5435,7 @@ function pageLayers(sheet, resources, report) {
       visible: number(row.cells, "Visible", 1, report) !== 0,
       printable: number(row.cells, "Print", 1, report) !== 0,
       locked: number(row.cells, "Lock", 0, report) !== 0,
-      ...colorValue === void 0 || colorValue === "255" ? {} : {
+      ...colorValue2 === void 0 || colorValue2 === "255" ? {} : {
         color: color(row.cells, "Color", "#000000", resources, report),
         colorOpacity: Math.max(0, Math.min(1, 1 - number(row.cells, "ColorTrans", 0, report)))
       }
@@ -5145,6 +5486,16 @@ function shapeLayers(sheet, layers, report, budget = createLayerBudget()) {
 }
 
 // visio/theme.ts
+var VISIO_SCHEME_SLOTS = [
+  "dk1",
+  "lt1",
+  "accent1",
+  "accent2",
+  "accent3",
+  "accent4",
+  "accent5",
+  "accent6"
+];
 var componentId = (node) => integer(themeChild(node, "schemeID", THEME_NS)?.getAttribute("schemeEnum"));
 async function loadVisioThemes(pkg, source, report) {
   const result = [];
@@ -5160,21 +5511,13 @@ async function loadVisioThemes(pkg, source, report) {
     }
     const base = themeChild(root, "themeElements");
     const palette = themeChild(base, "clrScheme");
+    const scheme = parseTheme(root).colorScheme.colors;
     const colors = /* @__PURE__ */ new Map();
-    for (const name of [
-      "dk1",
-      "lt1",
-      "accent1",
-      "accent2",
-      "accent3",
-      "accent4",
-      "accent5",
-      "accent6"
-    ]) {
-      const choice2 = colorChoice(themeChild(palette, name));
-      if (choice2) colors.set(name, choice2);
+    for (const name of VISIO_SCHEME_SLOTS) {
+      const color2 = scheme[name];
+      if (color2 && parsedColorChoice(themeChild(palette, name))) colors.set(name, color2);
     }
-    const background2 = colorChoice(extension(palette, "bkgnd"));
+    const background2 = parsedColorChoice(extension(palette, "bkgnd"));
     if (background2) colors.set("bkgnd", background2);
     const variants = themeChildren(
       extension(palette, "variationClrSchemeLst"),
@@ -5183,7 +5526,7 @@ async function loadVisioThemes(pkg, source, report) {
     ).slice(0, 4).map((variant) => {
       const entries = /* @__PURE__ */ new Map();
       for (let index = 1; index <= 7; index++) {
-        const choice2 = colorChoice(themeChild(variant, `varColor${index}`, THEME_NS));
+        const choice2 = parsedColorChoice(themeChild(variant, `varColor${index}`, THEME_NS));
         if (choice2) entries.set(String(index), choice2);
       }
       return entries;
@@ -9928,7 +10271,7 @@ function parseXf(data, palette, formatCode) {
   r.skip(1);
   const border1 = r.u32();
   const border2 = r.u32();
-  const fill2 = r.u16();
+  const fill = r.u16();
   const diag = border1 >>> 30;
   const xf = {
     font: fontIndex >= 4 ? fontIndex - 1 : fontIndex,
@@ -9950,8 +10293,8 @@ function parseXf(data, palette, formatCode) {
     border: { diagonalDown: (diag & 1) !== 0, diagonalUp: (diag & 2) !== 0 },
     fill: {
       pattern: PATTERN[border2 >>> 26 & 63] ?? "none",
-      fg: paletteColor(fill2 & 127, palette),
-      bg: paletteColor(fill2 >> 7 & 127, palette)
+      fg: paletteColor(fill & 127, palette),
+      bg: paletteColor(fill >> 7 & 127, palette)
     }
   };
   const edges = [
@@ -13661,7 +14004,7 @@ function readPptCharacterRuns(input, limits = {}) {
   const { directory, currentEdit } = buildPersistDirectory(view2, uv.getUint32(cu.dataOffset + 8, true));
   const associations = /* @__PURE__ */ new Map();
   let records = 0, styleBytes = 0;
-  const scan = (root) => {
+  const scan2 = (root) => {
     const stack = [{ record: root, depth: 0 }];
     while (stack.length) {
       const { record: record5, depth } = stack.pop();
@@ -13706,13 +14049,13 @@ function readPptCharacterRuns(input, limits = {}) {
     const doc = readRecordOrThrow(view2, directory.get(currentEdit.docPersistIdRef));
     for (const list of children4(view2, doc))
       if (list.recType === RT2.SlideListWithText && list.recInstance === 0)
-        scan(list);
+        scan2(list);
     const visited = /* @__PURE__ */ new Set();
     for (const slide of texts.slides) {
       const offset = directory.get(slide.persistId);
       if (!visited.has(offset)) {
         visited.add(offset);
-        scan(readRecordOrThrow(view2, offset));
+        scan2(readRecordOrThrow(view2, offset));
       }
     }
   } catch (error) {
@@ -18321,31 +18664,222 @@ async function assertGeometryPackageScope(pkg, pagePaths, commands, check, roots
   return movePins;
 }
 
+// opc/properties/patch.ts
+var XMLNS = "http://www.w3.org/2000/xmlns/";
+function tagEnd(xml, from) {
+  let quote = "";
+  for (let i = from + 1; i < xml.length; i++) {
+    const ch = xml[i];
+    if (quote) {
+      if (ch === quote) quote = "";
+    } else if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === ">") return i + 1;
+  }
+  throw new Error("Unterminated tag in property part");
+}
+function skipMarkup(xml, at2) {
+  if (xml.startsWith("<!--", at2)) return xml.indexOf("-->", at2) + 3;
+  if (xml.startsWith("<![CDATA[", at2)) return xml.indexOf("]]>", at2) + 3;
+  if (xml.startsWith("<?", at2)) return xml.indexOf("?>", at2) + 2;
+  return void 0;
+}
+function scan(xml) {
+  let i = 0;
+  let rootStart = -1;
+  while (rootStart < 0) {
+    const lt = xml.indexOf("<", i);
+    if (lt < 0) throw new Error("Property part has no root element");
+    const skipped = skipMarkup(xml, lt);
+    if (skipped !== void 0) i = skipped;
+    else rootStart = lt;
+  }
+  const openEnd = tagEnd(xml, rootStart);
+  if (xml[openEnd - 2] === "/") {
+    const root = {
+      start: rootStart,
+      openEnd,
+      closeStart: openEnd,
+      end: openEnd,
+      selfClosing: true
+    };
+    return { root, children: [] };
+  }
+  const children5 = [];
+  let depth = 0;
+  let child2;
+  i = openEnd;
+  for (; ; ) {
+    const lt = xml.indexOf("<", i);
+    if (lt < 0) throw new Error("Property part root is not closed");
+    const skipped = skipMarkup(xml, lt);
+    if (skipped !== void 0) {
+      i = skipped;
+      continue;
+    }
+    const end = tagEnd(xml, lt);
+    i = end;
+    if (xml[lt + 1] === "/") {
+      if (depth === 0) {
+        const root = { start: rootStart, openEnd, closeStart: lt, end, selfClosing: false };
+        return { root, children: children5 };
+      }
+      depth--;
+      if (depth === 0 && child2)
+        children5.push({ ...child2, closeStart: lt, end, selfClosing: false });
+    } else if (xml[end - 2] === "/") {
+      if (depth === 0)
+        children5.push({ start: lt, openEnd: end, closeStart: end, end, selfClosing: true });
+    } else {
+      if (depth === 0) child2 = { start: lt, openEnd: end };
+      depth++;
+    }
+  }
+}
+var escapeText = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\r/g, "&#xD;");
+var qualifiedName = (xml, span) => /^<([^\s/>]+)/.exec(xml.slice(span.start, span.openEnd))?.[1] ?? "";
+var PartPatch = class {
+  constructor(xml, rootElement) {
+    this.xml = xml;
+    const { root, children: children5 } = scan(xml);
+    const kids = elements(rootElement);
+    if (kids.length !== children5.length) throw new Error("Property part markup is not supported");
+    kids.forEach((kid, index) => this.spans.set(kid, children5[index]));
+    this.root = root;
+    for (const attribute3 of Array.from(rootElement.attributes)) {
+      if (attribute3.name === "xmlns") this.defaultNs = attribute3.value;
+      else if (attribute3.namespaceURI === XMLNS || attribute3.name.startsWith("xmlns:"))
+        this.prefixes.set(attribute3.value, attribute3.localName);
+    }
+  }
+  xml;
+  root;
+  spans = /* @__PURE__ */ new Map();
+  edits = [];
+  appended = [];
+  prefixes = /* @__PURE__ */ new Map();
+  defaultNs = null;
+  seq = 0;
+  add(start, end, text) {
+    this.edits.push({ start, end, text, seq: this.seq++ });
+  }
+  span(element) {
+    const span = this.spans.get(element);
+    if (!span) throw new Error("Element is not a child of the patched root");
+    return span;
+  }
+  /** The prefix bound to `ns` on the root, declaring `preferred` for it when none is. */
+  prefix(ns, preferred) {
+    const known = this.prefixes.get(ns);
+    if (known !== void 0) return known;
+    const taken = new Set(this.prefixes.values());
+    let prefix = preferred;
+    for (let n = 1; taken.has(prefix); n++) prefix = `${preferred}${n}`;
+    this.prefixes.set(ns, prefix);
+    const at2 = this.root.openEnd - (this.root.selfClosing ? 2 : 1);
+    this.add(at2, at2, ` xmlns:${prefix}="${ns}"`);
+    return prefix;
+  }
+  /** `local` qualified for an element in `ns`: unprefixed in the default namespace. */
+  qualify(ns, local, preferred) {
+    return this.defaultNs === ns && !this.prefixes.has(ns) ? local : `${this.prefix(ns, preferred)}:${local}`;
+  }
+  /** Replaces the element's content, keeping its start tag (and attributes) as written. */
+  setContent(element, content2) {
+    const span = this.span(element);
+    if (span.selfClosing)
+      this.add(span.openEnd - 2, span.openEnd, `>${content2}</${qualifiedName(this.xml, span)}>`);
+    else this.add(span.openEnd, span.closeStart, content2);
+  }
+  /** Adds ` name="value"` text to the element's start tag. */
+  addAttribute(element, attribute3) {
+    const span = this.span(element);
+    const at2 = span.openEnd - (span.selfClosing ? 2 : 1);
+    this.add(at2, at2, attribute3);
+  }
+  remove(element) {
+    const span = this.span(element);
+    this.add(span.start, span.end, "");
+  }
+  /** Inserts `markup` before `before`, or as the root's last child. */
+  insert(markup, before) {
+    if (before) {
+      const at2 = this.span(before).start;
+      this.add(at2, at2, markup);
+    } else this.appended.push(markup);
+  }
+  toString() {
+    const edits = [...this.edits];
+    if (this.appended.length) {
+      const text = this.appended.join("");
+      const root = this.root;
+      if (root.selfClosing) {
+        const name = qualifiedName(this.xml, root);
+        edits.push({
+          start: root.end - 2,
+          end: root.end,
+          text: `>${text}</${name}>`,
+          seq: this.seq
+        });
+      } else edits.push({ start: root.closeStart, end: root.closeStart, text, seq: this.seq });
+    }
+    edits.sort((a, b) => a.start - b.start || a.end - a.start - (b.end - b.start) || a.seq - b.seq);
+    let out = "";
+    let at2 = 0;
+    for (const edit of edits) {
+      out += this.xml.slice(at2, edit.start) + edit.text;
+      at2 = Math.max(at2, edit.end);
+    }
+    return out + this.xml.slice(at2);
+  }
+};
+
 // opc/properties/app.ts
 var FIELDS = [
   ["template", "Template", "text"],
   ["totalTime", "TotalTime", "int"],
+  ["pages", "Pages", "int"],
+  ["words", "Words", "int"],
+  ["characters", "Characters", "int"],
   ["application", "Application", "text"],
   ["docSecurity", "DocSecurity", "int"],
+  ["presentationFormat", "PresentationFormat", "text"],
+  ["lines", "Lines", "int"],
+  ["paragraphs", "Paragraphs", "int"],
+  ["slides", "Slides", "int"],
+  ["notes", "Notes", "int"],
+  ["hiddenSlides", "HiddenSlides", "int"],
+  ["mmClips", "MMClips", "int"],
   ["scaleCrop", "ScaleCrop", "bool"],
   ["headingPairs", "HeadingPairs", "pairs"],
   ["titlesOfParts", "TitlesOfParts", "titles"],
   ["manager", "Manager", "text"],
   ["company", "Company", "text"],
   ["linksUpToDate", "LinksUpToDate", "bool"],
+  ["charactersWithSpaces", "CharactersWithSpaces", "int"],
   ["sharedDoc", "SharedDoc", "bool"],
   ["hyperlinkBase", "HyperlinkBase", "text"],
   ["hyperlinksChanged", "HyperlinksChanged", "bool"],
   ["appVersion", "AppVersion", "text"]
 ];
+var STRICT_APP_NAMESPACES = {
+  extendedProperties: "http://purl.oclc.org/ooxml/officeDocument/extendedProperties",
+  vt: "http://purl.oclc.org/ooxml/officeDocument/docPropsVTypes"
+};
 var EMPTY_APP = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 <Properties xmlns="${NS.extendedProperties}" xmlns:vt="${NS.vt}"/>`;
-function vectorItems(element) {
-  const vector = first(element, "vector", NS.vt);
+function namespacesOf(root) {
+  if (root.localName !== "Properties") return void 0;
+  if (root.namespaceURI === NS.extendedProperties) return { app: NS.extendedProperties, vt: NS.vt };
+  if (root.namespaceURI === STRICT_APP_NAMESPACES.extendedProperties)
+    return { app: STRICT_APP_NAMESPACES.extendedProperties, vt: STRICT_APP_NAMESPACES.vt };
+  return void 0;
+}
+function vectorItems(element, vt) {
+  const vector = first(element, "vector", vt);
   return vector ? elements(vector) : [];
 }
-function readPairs(element) {
-  const variants = vectorItems(element).map((variant) => elements(variant)[0]);
+function readPairs(element, vt) {
+  const variants = vectorItems(element, vt).map((variant) => elements(variant)[0]);
   const out = [];
   for (let i = 0; i + 1 < variants.length; i += 2) {
     const name = variants[i]?.textContent ?? "";
@@ -18354,10 +18888,10 @@ function readPairs(element) {
   }
   return out;
 }
-function readField(element, kind) {
+function readField(element, kind, vt) {
   const text = element.textContent ?? "";
-  if (kind === "pairs") return readPairs(element);
-  if (kind === "titles") return vectorItems(element).map((item) => item.textContent ?? "");
+  if (kind === "pairs") return readPairs(element, vt);
+  if (kind === "titles") return vectorItems(element, vt).map((item) => item.textContent ?? "");
   if (kind === "bool") return text.trim() === "true" || text.trim() === "1";
   if (kind === "int") {
     const value = Number.parseInt(text, 10);
@@ -18365,69 +18899,61 @@ function readField(element, kind) {
   }
   return text === "" ? void 0 : text;
 }
-function parseAppProperties(xml) {
+function readKnown(root, ns) {
   const out = {};
-  if (!xml) return out;
-  const root = parseXml(xml, { label: "app properties" }).documentElement;
   for (const [field, local, kind] of FIELDS) {
-    const element = first(root, local, NS.extendedProperties);
+    const element = first(root, local, ns.app);
     if (!element) continue;
-    const value = readField(element, kind);
+    const value = readField(element, kind, ns.vt);
     if (value !== void 0) out[field] = value;
   }
   return out;
 }
+function parseAppProperties(xml) {
+  if (!xml) return {};
+  const root = parseXml(xml, { label: "app properties" }).documentElement;
+  const ns = namespacesOf(root);
+  return ns ? readKnown(root, ns) : {};
+}
 var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-function fill(doc, element, kind, value) {
-  while (element.firstChild) element.removeChild(element.firstChild);
-  const vt = (local, text) => {
-    const node = doc.createElementNS(NS.vt, `vt:${local}`);
-    if (text !== void 0) node.textContent = text;
-    return node;
-  };
-  if (kind === "pairs" || kind === "titles") {
-    const items = kind === "pairs" ? value.flatMap((pair) => [
-      vt("lpstr", pair.name),
-      vt("i4", String(Math.trunc(pair.count)))
-    ]) : value.map((title) => vt("lpstr", title));
-    const vector = vt("vector");
-    vector.setAttribute("size", String(items.length));
-    vector.setAttribute("baseType", kind === "pairs" ? "variant" : "lpstr");
-    for (const item of items) {
-      if (kind === "pairs") {
-        const variant = vt("variant");
-        variant.appendChild(item);
-        vector.appendChild(variant);
-      } else vector.appendChild(item);
-    }
-    element.appendChild(vector);
-    return;
-  }
-  element.textContent = kind === "bool" ? value ? "true" : "false" : String(value);
+function content(kind, value, vt) {
+  if (kind === "bool") return value ? "true" : "false";
+  if (kind === "int") return String(Math.trunc(value));
+  if (kind === "text") return escapeText(String(value));
+  const item = (local, text) => `<${vt}:${local}>${escapeText(text)}</${vt}:${local}>`;
+  const items = kind === "pairs" ? value.flatMap((pair) => [
+    `<${vt}:variant>${item("lpstr", pair.name)}</${vt}:variant>`,
+    `<${vt}:variant>${item("i4", String(Math.trunc(pair.count)))}</${vt}:variant>`
+  ]) : value.map((title) => item("lpstr", title));
+  const baseType = kind === "pairs" ? "variant" : "lpstr";
+  return `<${vt}:vector size="${items.length}" baseType="${baseType}">${items.join("")}</${vt}:vector>`;
 }
 function writeAppProperties(props, sourceXml) {
-  const doc = parseXml(sourceXml ?? EMPTY_APP, { label: "app properties" });
-  const root = doc.documentElement;
-  const prior = parseAppProperties(sourceXml);
+  const xml = sourceXml ?? EMPTY_APP;
+  const root = parseXml(xml, { label: "app properties" }).documentElement;
+  const ns = namespacesOf(root);
+  if (!ns) throw new Error("app properties root is not an extended-properties element");
+  const patch = new PartPatch(xml, root);
+  const prior = readKnown(root, ns);
+  const ownPrefix = root.prefix ? `${root.prefix}:` : "";
   FIELDS.forEach(([field, local, kind], index) => {
     const value = props[field];
-    const existing = first(root, local, NS.extendedProperties);
+    const existing = first(root, local, ns.app);
     if (value === void 0 || kind === "text" && value === "") {
-      if (existing && (existing.textContent ?? "") !== "") root.removeChild(existing);
+      if (existing && (existing.textContent ?? "") !== "") patch.remove(existing);
       return;
     }
     if (existing && same(prior[field], value)) return;
-    let element = existing;
-    if (!element) {
-      element = doc.createElementNS(NS.extendedProperties, local);
-      const next = FIELDS.slice(index + 1).map(([, name]) => first(root, name, NS.extendedProperties)).find((node) => node !== void 0);
-      root.insertBefore(element, next ?? null);
+    const vt = kind === "pairs" || kind === "titles" ? patch.prefix(ns.vt, "vt") : "";
+    const body = content(kind, value, vt);
+    if (existing) {
+      patch.setContent(existing, body);
+      return;
     }
-    fill(doc, element, kind, value);
+    const next = FIELDS.slice(index + 1).map(([, name]) => first(root, name, ns.app)).find((node) => node !== void 0);
+    patch.insert(`<${ownPrefix}${local}>${body}</${ownPrefix}${local}>`, next);
   });
-  const out = buildXml(doc);
-  return out.startsWith("<?xml") ? out : `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-${out}`;
+  return patch.toString();
 }
 
 // visio/edit-page-properties.ts