@json-to-office/core-docx 7.2.0 → 7.3.1

package/dist/plugin/example/index.js

@@ -2751,7 +2751,7 @@ var init_imageUtils = __esm({
 });
 
 // src/ir/types.ts
-var TWIPS_PER_INCH, TWIPS_PER_POINT2, EMU_PER_INCH, EMU_PER_TWIP, DOCX_IR_SCHEMA_VERSION, DOCX_IR_BORDER_STYLES;
+var TWIPS_PER_INCH, TWIPS_PER_POINT2, EMU_PER_INCH, EMU_PER_TWIP, DOCX_IR_SCHEMA_VERSION, NOT_XML_CHAR, DOCX_IR_BORDER_STYLES;
 var init_types = __esm({
   "src/ir/types.ts"() {
     "use strict";
@@ -2760,6 +2760,7 @@ var init_types = __esm({
     EMU_PER_INCH = 914400;
     EMU_PER_TWIP = EMU_PER_INCH / TWIPS_PER_INCH;
     DOCX_IR_SCHEMA_VERSION = 1;
+    NOT_XML_CHAR = /[^\t\n\r\u0020-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}]/u;
     DOCX_IR_BORDER_STYLES = [
       "single",
       "dashDotStroked",
@@ -2846,6 +2847,242 @@ var init_units = __esm({
   }
 });
 
+// src/ir/chartValues.ts
+function numericLabelValue(label) {
+  const value = label.trim();
+  return NUMERIC_LABEL.test(value) ? Number(value) : void 0;
+}
+function isNumericLabel(label) {
+  const value = numericLabelValue(label);
+  return value !== void 0 && Number.isFinite(value);
+}
+function isOutOfRangeNumericLabel(label) {
+  const value = numericLabelValue(label);
+  return value !== void 0 && !Number.isFinite(value);
+}
+function scatterX(labels, index) {
+  const label = labels[index];
+  const value = label === void 0 ? void 0 : numericLabelValue(label);
+  if (value === void 0) return index + 1;
+  if (!Number.isFinite(value)) {
+    throw new RangeError(
+      `Scatter x label ${JSON.stringify(label)} is not finite.`
+    );
+  }
+  return value;
+}
+var NUMERIC_LABEL;
+var init_chartValues = __esm({
+  "src/ir/chartValues.ts"() {
+    "use strict";
+    NUMERIC_LABEL = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
+  }
+});
+
+// src/renderers/chartText.ts
+function chartTextRoles(font) {
+  const { bold, ...rest } = font;
+  const text = rest;
+  return {
+    text,
+    axisTitle: { ...text, bold },
+    title: {
+      ...text,
+      fontSize: Math.round(text.fontSize * CHART_TITLE_SCALE),
+      bold: true
+    }
+  };
+}
+var CHART_TITLE_SCALE;
+var init_chartText = __esm({
+  "src/renderers/chartText.ts"() {
+    "use strict";
+    CHART_TITLE_SCALE = 1.4;
+  }
+});
+
+// src/renderers/docxjs/docxSubpath.ts
+function docxSubpath(specifier, component, importer) {
+  let module;
+  let failure;
+  let loading;
+  return {
+    specifier,
+    load() {
+      loading ??= importer().then(
+        (loadedModule) => {
+          module = loadedModule;
+        },
+        (reason) => {
+          failure = { reason };
+        }
+      );
+      return loading;
+    },
+    loaded: () => module !== void 0,
+    get() {
+      if (module !== void 0) return module;
+      if (failure !== void 0) {
+        const { reason } = failure;
+        const detail = reason instanceof Error ? reason.message : String(reason);
+        throw new Error(
+          `The docx \`${component}\` component needs docx 9.8.0 or later: the \`${specifier}\` entry could not be loaded (${detail})`
+        );
+      }
+      throw new Error(
+        `${specifier} is not loaded: await its load() before buildDocument() (render() does)`
+      );
+    }
+  };
+}
+var init_docxSubpath = __esm({
+  "src/renderers/docxjs/docxSubpath.ts"() {
+    "use strict";
+  }
+});
+
+// src/renderers/docxjs/charts.ts
+import { assertNever } from "@json-to-office/shared/rendering";
+function loadDocxCharts() {
+  return charts.load();
+}
+function chartFont(role) {
+  return {
+    name: role.fontFamily,
+    size: role.fontSize,
+    color: role.color,
+    bold: role.bold ?? false
+  };
+}
+function chartRunOptions(chart, floating) {
+  const roles = chartTextRoles(chart.textFont);
+  const text = chartFont(roles.text);
+  const axisTitle = chartFont(roles.axisTitle);
+  const palette = chart.colors;
+  const colorAt = (index) => palette.length > 0 ? palette[index % palette.length] : void 0;
+  const withColor = (index) => {
+    const color = colorAt(index);
+    return color ? { color } : {};
+  };
+  const seriesName = (index) => chart.series[index].name ?? `Series ${index + 1}`;
+  const categories = chart.series[0]?.labels ?? [];
+  const axis = (title) => ({
+    ...title ? { title: { text: title, font: axisTitle } } : {},
+    font: text
+  });
+  const common = {
+    ...chart.title && chart.showTitle !== false ? { title: { text: chart.title, font: chartFont(roles.title) } } : {},
+    legend: chart.showLegend === false ? false : {
+      position: LEGEND_POSITION[chart.legendPosition ?? "b"],
+      font: text
+    },
+    font: { name: roles.text.fontFamily, color: roles.text.color },
+    // Office-open's chart space is unfilled and unbordered; `ChartRun`'s
+    // default is Word's white fill and grey border.
+    chartArea: { fill: "none", border: "none" },
+    transformation: {
+      width: emuToPixels(chart.widthEmu),
+      height: emuToPixels(chart.heightEmu)
+    },
+    // Without an authored description `ChartRun` describes the chart from
+    // its data, which is deterministic; the name stays empty, as it is on
+    // every other drawing this renderer writes.
+    ...chart.altText ? { altText: { name: "", description: chart.altText } } : {},
+    ...floating ? { floating } : {}
+  };
+  switch (chart.chartType) {
+    case "column":
+    case "bar":
+    case "area":
+    case "line":
+      return {
+        ...common,
+        type: chart.chartType,
+        categories,
+        ...chart.chartType === "line" ? { markers: true } : {},
+        series: chart.series.map((entry, index) => ({
+          name: seriesName(index),
+          values: entry.values,
+          ...withColor(index)
+        })),
+        categoryAxis: axis(chart.categoryAxisTitle),
+        valueAxis: axis(chart.valueAxisTitle)
+      };
+    case "pie":
+    case "doughnut":
+      return {
+        ...common,
+        type: chart.chartType,
+        categories,
+        series: chart.series.map((entry, index) => ({
+          name: seriesName(index),
+          values: entry.values,
+          ...palette.length > 0 ? { colors: entry.values.map((_, point) => colorAt(point)) } : {}
+        }))
+      };
+    case "radar":
+      return {
+        ...common,
+        type: "radar",
+        categories,
+        markers: true,
+        series: chart.series.map((entry, index) => ({
+          name: seriesName(index),
+          values: entry.values,
+          ...withColor(index)
+        })),
+        categoryAxis: axis(chart.categoryAxisTitle),
+        valueAxis: axis(chart.valueAxisTitle)
+      };
+    case "scatter":
+      return {
+        ...common,
+        type: "scatter",
+        markers: true,
+        lines: "straight",
+        series: chart.series.map((entry, index) => ({
+          name: seriesName(index),
+          points: entry.values.map((y, point) => ({
+            x: scatterX(entry.labels, point),
+            y
+          })),
+          ...withColor(index)
+        })),
+        xAxis: { ...axis(chart.categoryAxisTitle), gridlines: false },
+        yAxis: axis(chart.valueAxisTitle)
+      };
+    case "bubble":
+      throw new Error(
+        "the docxjs renderer has no emitter for a bubble chart; the compiler should have refused it"
+      );
+    default:
+      return assertNever(chart.chartType, "DocxIrChartType");
+  }
+}
+function emitChart(chart, floating) {
+  return new (charts.get()).ChartRun(
+    chartRunOptions(chart, floating)
+  );
+}
+var charts, LEGEND_POSITION;
+var init_charts = __esm({
+  "src/renderers/docxjs/charts.ts"() {
+    "use strict";
+    init_chartValues();
+    init_units();
+    init_chartText();
+    init_docxSubpath();
+    charts = docxSubpath("docx/charts", "chart", () => import("docx/charts"));
+    LEGEND_POSITION = {
+      b: "bottom",
+      l: "left",
+      r: "right",
+      t: "top",
+      tr: "topRight"
+    };
+  }
+});
+
 // src/renderers/docxjs/emit.ts
 import {
   AlignmentType,
@@ -2881,7 +3118,7 @@ import {
   WidthType,
   WpsShapeRun
 } from "docx";
-import { assertNever } from "@json-to-office/shared/rendering";
+import { assertNever as assertNever2 } from "@json-to-office/shared/rendering";
 function complexField(instruction, formatting, leading, cachedText) {
   const options = runOptions(formatting);
   const fieldChar = (type, extra = {}) => new TextRun({
@@ -2918,7 +3155,12 @@ function runOptions(formatting) {
   if (formatting.bold !== void 0) options.bold = formatting.bold;
   if (formatting.italic !== void 0) options.italics = formatting.italic;
   if (formatting.underline !== void 0) {
-    options.underline = formatting.underline ? { type: formatting.underline.type } : void 0;
+    options.underline = formatting.underline ? {
+      type: formatting.underline.type,
+      // A native visual's text is the one place a run states its own
+      // underline colour.
+      ...formatting.underline.color ? { color: formatting.underline.color.hex } : {}
+    } : void 0;
   }
   if (formatting.strike !== void 0) options.strike = formatting.strike;
   if (formatting.allCaps !== void 0) options.allCaps = formatting.allCaps;
@@ -3044,21 +3286,36 @@ function inlineChildren(children, resources = /* @__PURE__ */ new Map()) {
       case "shape":
         out.push(emitShape(child, resources));
         break;
-      case "drawingGroup":
-        throw new Error(
-          "the docxjs renderer has no emitter for a drawing group; this document should have been refused by the capability check"
-        );
-      case "chart":
-        throw new Error(
-          "the docxjs renderer has no emitter for a chart; this document should have been refused by the capability check"
+      case "drawingGroup": {
+        const build = resources.drawingGroup;
+        if (!build) {
+          throw new Error(
+            "the docxjs renderer was handed a drawing group without loading docx/shapes; render() loads it whenever the IR holds one"
+          );
+        }
+        const pending = breakOption();
+        if (pending.break) out.push(new TextRun(pending));
+        out.push(build(child, resources));
+        break;
+      }
+      case "chart": {
+        const pending = breakOption();
+        if (pending.break) out.push(new TextRun(pending));
+        out.push(
+          emitChart(
+            child,
+            child.floating ? floatingOptions(child.floating) : void 0
+          )
         );
+        break;
+      }
       case "noteReference":
         out.push(
           child.noteKind === "endnote" ? new EndnoteReferenceRun(child.id) : new FootnoteReferenceRun(child.id)
         );
         break;
       default:
-        assertNever(child, "DocxIrInline");
+        assertNever2(child, "DocxIrInline");
     }
   }
   return out;
@@ -3263,7 +3520,7 @@ function emitBlock(block2, resources = /* @__PURE__ */ new Map()) {
     case "toc":
       return emitToc(block2);
     default:
-      return assertNever(block2, "DocxIrBlock");
+      return assertNever2(block2, "DocxIrBlock");
   }
 }
 function emitToc(block2) {
@@ -3407,6 +3664,7 @@ var ALIGNMENT2, PAGE_FIELDS, isSequenceField, WRAP_TYPE, ThemedTableOfContents,
 var init_emit = __esm({
   "src/renderers/docxjs/emit.ts"() {
     "use strict";
+    init_charts();
     ALIGNMENT2 = {
       left: AlignmentType.LEFT,
       center: AlignmentType.CENTER,
@@ -3705,10 +3963,13 @@ function canonicalizeRelationshipIds(zip) {
     const rename = new Map(
       ordered.map((id, index) => [id, `rId${highest + 1 + index}`])
     );
-    const rewrite = (xml) => xml.replace(/"([^"]+)"/g, (whole, value) => {
-      const replacement = rename.get(value);
-      return replacement === void 0 ? whole : `"${replacement}"`;
-    });
+    const rewrite = (xml) => xml.replace(
+      /(\s[\w:.-]+=)"([^"]*)"/g,
+      (whole, prefix, value) => {
+        const replacement = rename.get(value);
+        return replacement === void 0 ? whole : `${prefix}"${replacement}"`;
+      }
+    );
     updates.push({ name: relsName, xml: rewrite(relsXml) });
     if (partEntry) {
       updates.push({ name: partName, xml: rewrite(partXml) });
@@ -3719,17 +3980,62 @@ function canonicalizeRelationshipIds(zip) {
     if (entry) zip.updateFile(entry, Buffer.from(update.xml, "utf8"));
   }
 }
+function canonicalizeEmbeddedPackages(zip, generatedAt, depth = 1) {
+  const names = zip.getEntries().map((entry) => entry.entryName).filter((name) => EMBEDDED_OFFICE_PACKAGE.test(name));
+  let changed = false;
+  for (const name of names) {
+    const entry = zip.getEntry(name);
+    if (!entry) continue;
+    let nested;
+    try {
+      nested = new AdmZip(entry.getData());
+      nested.getEntries();
+    } catch {
+      continue;
+    }
+    if (canonicalizeNestedPackage(nested, generatedAt, depth)) {
+      zip.updateFile(entry, nested.toBuffer());
+      changed = true;
+    }
+  }
+  return changed;
+}
+function canonicalizeNestedPackage(zip, generatedAt, depth) {
+  let changed = false;
+  const coreProperties3 = zip.getEntry("docProps/core.xml");
+  if (coreProperties3) {
+    const xml = coreProperties3.getData().toString("utf8");
+    const normalized = xml.replace(
+      CORE_TIMESTAMP,
+      `$1${generatedAt.toISOString()}$2`
+    );
+    if (normalized !== xml) {
+      zip.updateFile(coreProperties3, Buffer.from(normalized, "utf8"));
+      changed = true;
+    }
+  }
+  if (depth < MAX_EMBEDDED_DEPTH && canonicalizeEmbeddedPackages(zip, generatedAt, depth + 1)) {
+    changed = true;
+  }
+  const zipTimestamp = toDosTime(generatedAt);
+  for (const entry of zip.getEntries()) {
+    const header = entry.header;
+    if (header.timeval !== zipTimestamp) {
+      header.timeval = zipTimestamp;
+      changed = true;
+    }
+  }
+  return changed;
+}
 function canonicalizeDocxBuffer(buffer, generatedAt = DEFAULT_GENERATION_DATE) {
   const zip = new AdmZip(buffer);
   normalizeTextCase(zip);
   canonicalizeRelationshipIds(zip);
+  canonicalizeEmbeddedPackages(zip, generatedAt);
   const isoTimestamp = generatedAt.toISOString();
   const coreProperties3 = zip.getEntry("docProps/core.xml");
   if (coreProperties3) {
-    const normalized = coreProperties3.getData().toString("utf8").replace(
-      /(<dcterms:(?:created|modified)\b[^>]*>)[^<]*(<\/dcterms:(?:created|modified)>)/g,
-      `$1${isoTimestamp}$2`
-    );
+    const normalized = coreProperties3.getData().toString("utf8").replace(CORE_TIMESTAMP, `$1${isoTimestamp}$2`);
     zip.updateFile(coreProperties3, Buffer.from(normalized, "utf8"));
   }
   const zipTimestamp = toDosTime(generatedAt);
@@ -3742,35 +4048,567 @@ function normalizeDocxCaseBuffer(buffer) {
   const zip = new AdmZip(buffer);
   return normalizeTextCase(zip) ? zip.toBuffer() : buffer;
 }
-var DEFAULT_GENERATION_DATE, STABLE_RELATIONSHIP_ID;
+var DEFAULT_GENERATION_DATE, STABLE_RELATIONSHIP_ID, CORE_TIMESTAMP, EMBEDDED_OFFICE_PACKAGE, MAX_EMBEDDED_DEPTH;
 var init_packageDocument = __esm({
   "src/utils/packageDocument.ts"() {
     "use strict";
     init_normalizeTextCase();
     DEFAULT_GENERATION_DATE = /* @__PURE__ */ new Date("2000-01-01T00:00:00.000Z");
     STABLE_RELATIONSHIP_ID = /^rId\d+$/;
+    CORE_TIMESTAMP = /(<dcterms:(?:created|modified)\b[^>]*>)[^<]*(<\/dcterms:(?:created|modified)>)/g;
+    EMBEDDED_OFFICE_PACKAGE = /\.(?:docx|pptx|xlsx|xlsm)$/i;
+    MAX_EMBEDDED_DEPTH = 3;
   }
 });
 
 // src/utils/fixFloatingImageIds.ts
 import AdmZip2 from "adm-zip";
+function compareDrawingParts(a, b) {
+  const ma = DRAWING_PART.exec(a);
+  const mb = DRAWING_PART.exec(b);
+  const rank = RANK.indexOf(ma[1]) - RANK.indexOf(mb[1]);
+  return rank !== 0 ? rank : Number(ma[2] || 0) - Number(mb[2] || 0);
+}
 function fixFloatingImageIdsInBuffer(buffer) {
   const zip = new AdmZip2(buffer);
-  const documentEntry = zip.getEntry("word/document.xml");
-  if (!documentEntry) {
+  if (!zip.getEntry("word/document.xml")) {
     throw new Error("document.xml not found in DOCX");
   }
+  const parts = zip.getEntries().filter((entry) => DRAWING_PART.test(entry.entryName)).sort((a, b) => compareDrawingParts(a.entryName, b.entryName));
   let idCounter = 1;
-  const documentXml = documentEntry.getData().toString("utf8").replace(/(<wp:docPr\b[^>]*?\s)id="\d+"/g, (_match, prefix) => {
-    const newId = idCounter++;
-    return `${prefix}id="${newId}"`;
-  });
-  zip.updateFile(documentEntry, Buffer.from(documentXml, "utf8"));
+  for (const entry of parts) {
+    const xml = entry.getData().toString("utf8");
+    const renumbered = xml.replace(
+      /(<wp:docPr\b[^>]*?\s)id="\d+"/g,
+      (_match, prefix) => `${prefix}id="${idCounter++}"`
+    );
+    zip.updateFile(entry, Buffer.from(renumbered, "utf8"));
+  }
   return zip.toBuffer();
 }
+var DRAWING_PART, RANK;
 var init_fixFloatingImageIds = __esm({
   "src/utils/fixFloatingImageIds.ts"() {
     "use strict";
+    DRAWING_PART = /^word\/(document|header|footer|footnotes|endnotes|comments)(\d*)\.xml$/;
+    RANK = [
+      "document",
+      "header",
+      "footer",
+      "footnotes",
+      "endnotes",
+      "comments"
+    ];
+  }
+});
+
+// src/renderers/docxjs/presetShapes.ts
+function docxPresetShape(geometry) {
+  const name = Object.hasOwn(OOXML_PRESET_TO_DOCX, geometry) ? OOXML_PRESET_TO_DOCX[geometry] : void 0;
+  if (!name) {
+    throw new Error(
+      `the docxjs renderer has no preset for the OOXML geometry "${geometry}"`
+    );
+  }
+  return name;
+}
+function docxLineDash(dash) {
+  const name = Object.hasOwn(OOXML_DASH_TO_DOCX, dash) ? OOXML_DASH_TO_DOCX[dash] : void 0;
+  if (!name) {
+    throw new Error(
+      `the docxjs renderer has no line dash for the OOXML value "${dash}"`
+    );
+  }
+  return name;
+}
+var OOXML_PRESET_TO_DOCX, OOXML_DASH_TO_DOCX;
+var init_presetShapes = __esm({
+  "src/renderers/docxjs/presetShapes.ts"() {
+    "use strict";
+    OOXML_PRESET_TO_DOCX = {
+      line: "line",
+      lineInv: "inverseLine",
+      straightConnector1: "straightConnector",
+      bentConnector2: "elbowConnectorOneBend",
+      bentConnector3: "elbowConnector",
+      bentConnector4: "elbowConnectorThreeBends",
+      bentConnector5: "elbowConnectorFourBends",
+      curvedConnector2: "curvedConnectorOneBend",
+      curvedConnector3: "curvedConnector",
+      curvedConnector4: "curvedConnectorThreeBends",
+      curvedConnector5: "curvedConnectorFourBends",
+      triangle: "triangle",
+      rtTriangle: "rightTriangle",
+      diamond: "diamond",
+      parallelogram: "parallelogram",
+      trapezoid: "trapezoid",
+      nonIsoscelesTrapezoid: "nonIsoscelesTrapezoid",
+      pentagon: "pentagon",
+      hexagon: "hexagon",
+      heptagon: "heptagon",
+      octagon: "octagon",
+      decagon: "decagon",
+      dodecagon: "dodecagon",
+      ellipse: "ellipse",
+      teardrop: "teardrop",
+      pieWedge: "pieWedge",
+      pie: "pie",
+      blockArc: "blockArc",
+      donut: "donut",
+      noSmoking: "noSymbol",
+      chord: "chord",
+      arc: "arc",
+      frame: "frame",
+      halfFrame: "halfFrame",
+      corner: "lShape",
+      diagStripe: "diagonalStripe",
+      plus: "cross",
+      plaque: "plaque",
+      can: "cylinder",
+      cube: "cube",
+      bevel: "beveledRectangle",
+      foldedCorner: "foldedCorner",
+      smileyFace: "smileyFace",
+      heart: "heart",
+      lightningBolt: "lightningBolt",
+      sun: "sun",
+      moon: "moon",
+      cloud: "cloud",
+      leftBracket: "leftBracket",
+      rightBracket: "rightBracket",
+      leftBrace: "leftBrace",
+      rightBrace: "rightBrace",
+      bracketPair: "bracketPair",
+      bracePair: "bracePair",
+      rect: "rectangle",
+      roundRect: "roundedRectangle",
+      round1Rect: "roundedCornerRectangle",
+      round2SameRect: "topRoundedCornersRectangle",
+      round2DiagRect: "diagonalRoundedCornersRectangle",
+      snip1Rect: "snippedCornerRectangle",
+      snip2SameRect: "topSnippedCornersRectangle",
+      snip2DiagRect: "diagonalSnippedCornersRectangle",
+      snipRoundRect: "roundedAndSnippedCornersRectangle",
+      rightArrow: "rightArrow",
+      leftArrow: "leftArrow",
+      upArrow: "upArrow",
+      downArrow: "downArrow",
+      leftRightArrow: "leftRightArrow",
+      upDownArrow: "upDownArrow",
+      quadArrow: "quadArrow",
+      leftRightUpArrow: "leftRightUpArrow",
+      bentArrow: "bentArrow",
+      uturnArrow: "uTurnArrow",
+      leftUpArrow: "leftUpArrow",
+      bentUpArrow: "bentUpArrow",
+      curvedRightArrow: "curvedRightArrow",
+      curvedLeftArrow: "curvedLeftArrow",
+      curvedUpArrow: "curvedUpArrow",
+      curvedDownArrow: "curvedDownArrow",
+      stripedRightArrow: "stripedRightArrow",
+      notchedRightArrow: "notchedRightArrow",
+      homePlate: "pentagonArrow",
+      chevron: "chevron",
+      rightArrowCallout: "rightArrowCallout",
+      downArrowCallout: "downArrowCallout",
+      leftArrowCallout: "leftArrowCallout",
+      upArrowCallout: "upArrowCallout",
+      leftRightArrowCallout: "leftRightArrowCallout",
+      upDownArrowCallout: "upDownArrowCallout",
+      quadArrowCallout: "quadArrowCallout",
+      circularArrow: "circularArrow",
+      leftCircularArrow: "leftCircularArrow",
+      leftRightCircularArrow: "leftRightCircularArrow",
+      swooshArrow: "swooshArrow",
+      mathPlus: "mathPlus",
+      mathMinus: "mathMinus",
+      mathMultiply: "mathMultiply",
+      mathDivide: "mathDivide",
+      mathEqual: "mathEqual",
+      mathNotEqual: "mathNotEqual",
+      flowChartProcess: "flowChartProcess",
+      flowChartAlternateProcess: "flowChartAlternateProcess",
+      flowChartDecision: "flowChartDecision",
+      flowChartInputOutput: "flowChartInputOutput",
+      flowChartPredefinedProcess: "flowChartPredefinedProcess",
+      flowChartInternalStorage: "flowChartInternalStorage",
+      flowChartDocument: "flowChartDocument",
+      flowChartMultidocument: "flowChartMultidocument",
+      flowChartTerminator: "flowChartTerminator",
+      flowChartPreparation: "flowChartPreparation",
+      flowChartManualInput: "flowChartManualInput",
+      flowChartManualOperation: "flowChartManualOperation",
+      flowChartConnector: "flowChartConnector",
+      flowChartOffpageConnector: "flowChartOffpageConnector",
+      flowChartPunchedCard: "flowChartPunchedCard",
+      flowChartPunchedTape: "flowChartPunchedTape",
+      flowChartSummingJunction: "flowChartSummingJunction",
+      flowChartOr: "flowChartOr",
+      flowChartCollate: "flowChartCollate",
+      flowChartSort: "flowChartSort",
+      flowChartExtract: "flowChartExtract",
+      flowChartMerge: "flowChartMerge",
+      flowChartOfflineStorage: "flowChartOfflineStorage",
+      flowChartOnlineStorage: "flowChartOnlineStorage",
+      flowChartDelay: "flowChartDelay",
+      flowChartMagneticTape: "flowChartMagneticTape",
+      flowChartMagneticDisk: "flowChartMagneticDisk",
+      flowChartMagneticDrum: "flowChartMagneticDrum",
+      flowChartDisplay: "flowChartDisplay",
+      irregularSeal1: "explosion12",
+      irregularSeal2: "explosion14",
+      star4: "star4",
+      star5: "star5",
+      star6: "star6",
+      star7: "star7",
+      star8: "star8",
+      star10: "star10",
+      star12: "star12",
+      star16: "star16",
+      star24: "star24",
+      star32: "star32",
+      ribbon2: "ribbonUp",
+      ribbon: "ribbonDown",
+      ellipseRibbon2: "curvedRibbonUp",
+      ellipseRibbon: "curvedRibbonDown",
+      leftRightRibbon: "leftRightRibbon",
+      verticalScroll: "verticalScroll",
+      horizontalScroll: "horizontalScroll",
+      wave: "wave",
+      doubleWave: "doubleWave",
+      wedgeRectCallout: "rectangularCallout",
+      wedgeRoundRectCallout: "roundedRectangularCallout",
+      wedgeEllipseCallout: "ellipticalCallout",
+      cloudCallout: "cloudCallout",
+      borderCallout1: "lineCallout",
+      borderCallout2: "bentLineCallout",
+      borderCallout3: "doubleBentLineCallout",
+      accentCallout1: "lineCalloutWithAccentBar",
+      accentCallout2: "bentLineCalloutWithAccentBar",
+      accentCallout3: "doubleBentLineCalloutWithAccentBar",
+      callout1: "lineCalloutWithNoBorder",
+      callout2: "bentLineCalloutWithNoBorder",
+      callout3: "doubleBentLineCalloutWithNoBorder",
+      accentBorderCallout1: "lineCalloutWithBorderAndAccentBar",
+      accentBorderCallout2: "bentLineCalloutWithBorderAndAccentBar",
+      accentBorderCallout3: "doubleBentLineCalloutWithBorderAndAccentBar",
+      actionButtonBlank: "actionButtonBlank",
+      actionButtonHome: "actionButtonHome",
+      actionButtonHelp: "actionButtonHelp",
+      actionButtonInformation: "actionButtonInformation",
+      actionButtonForwardNext: "actionButtonForwardNext",
+      actionButtonBackPrevious: "actionButtonBackPrevious",
+      actionButtonEnd: "actionButtonEnd",
+      actionButtonBeginning: "actionButtonBeginning",
+      actionButtonReturn: "actionButtonReturn",
+      actionButtonDocument: "actionButtonDocument",
+      actionButtonSound: "actionButtonSound",
+      actionButtonMovie: "actionButtonMovie",
+      gear6: "gear6",
+      gear9: "gear9",
+      funnel: "funnel",
+      cornerTabs: "cornerTabs",
+      squareTabs: "squareTabs",
+      plaqueTabs: "plaqueTabs",
+      chartX: "chartX",
+      chartStar: "chartStar",
+      chartPlus: "chartPlus"
+    };
+    OOXML_DASH_TO_DOCX = {
+      solid: "solid",
+      dot: "dot",
+      dash: "dash",
+      lgDash: "longDash",
+      dashDot: "dashDot",
+      lgDashDot: "longDashDot",
+      lgDashDotDot: "longDashDotDot",
+      sysDash: "shortDash",
+      sysDot: "shortDot",
+      sysDashDot: "shortDashDot",
+      sysDashDotDot: "shortDashDotDot"
+    };
+  }
+});
+
+// src/renderers/docxjs/drawingGroup.ts
+function chooseMarkers(ir) {
+  const strings = [];
+  collectStrings(ir, strings, /* @__PURE__ */ new WeakSet());
+  const unused = (base) => {
+    for (let n = 0; ; n += 1) {
+      const candidate = n === 0 ? base : `${base}-${n}`;
+      if (!strings.some((value) => value.includes(candidate))) return candidate;
+    }
+  };
+  return {
+    noAltText: unused(DEFAULT_MARKERS.noAltText),
+    textBox: unused(DEFAULT_MARKERS.textBox)
+  };
+}
+function collectStrings(node, out, seen) {
+  if (typeof node === "string") {
+    out.push(node);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  if (node instanceof ArrayBuffer || ArrayBuffer.isView(node)) return;
+  if (seen.has(node)) return;
+  seen.add(node);
+  if (node instanceof Map) {
+    for (const [key, value] of node) {
+      collectStrings(key, out, seen);
+      collectStrings(value, out, seen);
+    }
+    return;
+  }
+  if (node instanceof Set) {
+    for (const value of node) collectStrings(value, out, seen);
+    return;
+  }
+  for (const value of Object.values(node)) collectStrings(value, out, seen);
+}
+function createDrawingGroupFactory(shapes2, pictures, markers) {
+  return (group, resources) => new shapes2.ShapeGroupRun(
+    drawingGroupOptions(group, resources, pictures, markers)
+  );
+}
+function drawingGroupOptions(group, resources, pictures, markers = DEFAULT_MARKERS) {
+  const canvasWidth = group.canvasWidthEmu;
+  const canvasHeight = group.canvasHeightEmu;
+  const near = (value, edge) => Math.abs(value - edge) <= OVERFLOW_TOLERANCE_EMU;
+  const bounds = unrotatedBounds(group.children);
+  const fillsCanvas = bounds !== void 0 && near(bounds.left, 0) && near(bounds.top, 0) && near(bounds.right, canvasWidth) && near(bounds.bottom, canvasHeight);
+  const union = {
+    left: Math.min(0, bounds?.left ?? 0),
+    top: Math.min(0, bounds?.top ?? 0),
+    right: Math.max(canvasWidth, bounds?.right ?? 0),
+    bottom: Math.max(canvasHeight, bounds?.bottom ?? 0)
+  };
+  const overflows = union.left < -OVERFLOW_TOLERANCE_EMU || union.top < -OVERFLOW_TOLERANCE_EMU || union.right > canvasWidth + OVERFLOW_TOLERANCE_EMU || union.bottom > canvasHeight + OVERFLOW_TOLERANCE_EMU;
+  const widthEmu = overflows ? (union.right - union.left) * group.widthEmu / canvasWidth : group.widthEmu;
+  const heightEmu = overflows ? (union.bottom - union.top) * group.heightEmu / canvasHeight : group.heightEmu;
+  return {
+    children: [
+      ...fillsCanvas ? [] : [canvasPad(canvasWidth, canvasHeight)],
+      ...group.children.map(
+        (child, index) => groupChild(child, index, resources, pictures, markers)
+      )
+    ],
+    transformation: {
+      width: emuToPixels(widthEmu),
+      height: emuToPixels(heightEmu)
+    },
+    // `||`, not `??`: docx treats '' as no description too, and would then
+    // describe the diagram from the child names.
+    altText: { name: "", description: group.altText || markers.noAltText },
+    ...group.floating ? { floating: floatingOptions(group.floating) } : {}
+  };
+}
+function groupChild(child, index, resources, pictures, markers) {
+  return child.kind === "picture" ? pictureChild(child, index, pictures) : shapeChild(child, index, resources, markers);
+}
+function canvasPad(canvasWidthEmu, canvasHeightEmu) {
+  return {
+    type: "rectangle",
+    transformation: {
+      offset: { left: 0, top: 0 },
+      width: emuToPixels(canvasWidthEmu),
+      height: emuToPixels(canvasHeightEmu)
+    },
+    fill: "none",
+    line: "none",
+    decorative: true,
+    altText: { name: "Canvas" }
+  };
+}
+function childTransformation(frame) {
+  const rotation2 = frame.rotationDegrees;
+  return {
+    offset: { left: emuToPixels(frame.xEmu), top: emuToPixels(frame.yEmu) },
+    width: emuToPixels(frame.widthEmu),
+    height: emuToPixels(frame.heightEmu),
+    ...rotation2 !== void 0 && rotation2 % 360 !== 0 ? { rotation: rotation2 } : {},
+    ...frame.flipHorizontal || frame.flipVertical ? {
+      flip: {
+        ...frame.flipHorizontal ? { horizontal: true } : {},
+        ...frame.flipVertical ? { vertical: true } : {}
+      }
+    } : {}
+  };
+}
+function shapeChild(shape, index, resources, markers) {
+  const paragraphs = shape.text?.paragraphs ?? [];
+  return {
+    type: docxPresetShape(shape.geometry),
+    transformation: childTransformation(shape.frame),
+    fill: shapeFill(shape.fill),
+    line: shapeLine(shape.outline),
+    altText: {
+      name: shape.name ?? `Shape ${index + 1}`,
+      ...shape.isTextBox ? { title: markers.textBox } : {}
+    },
+    // Never `children: []`: docx would write an empty `w:txbxContent`, which
+    // the schema does not allow.
+    ...paragraphs.length > 0 ? {
+      children: paragraphs.map(
+        (paragraph2) => emitParagraph(paragraph2, resources)
+      )
+    } : {},
+    ...shape.text ? { textOptions: textOptions(shape.text) } : {}
+  };
+}
+function pictureChild(picture2, index, pictures) {
+  const crop = picture2.crop;
+  return {
+    type: "picture",
+    image: pictures(picture2.resourceId, {
+      widthEmu: picture2.frame.widthEmu,
+      heightEmu: picture2.frame.heightEmu
+    }),
+    transformation: childTransformation(picture2.frame),
+    ...crop ? {
+      crop: {
+        ...crop.left !== void 0 ? { left: crop.left * 100 } : {},
+        ...crop.top !== void 0 ? { top: crop.top * 100 } : {},
+        ...crop.right !== void 0 ? { right: crop.right * 100 } : {},
+        ...crop.bottom !== void 0 ? { bottom: crop.bottom * 100 } : {}
+      }
+    } : {},
+    altText: {
+      name: picture2.name ?? `Picture ${index + 1}`,
+      ...picture2.altText ? { description: picture2.altText } : {}
+    }
+  };
+}
+function shapeFill(fill) {
+  if (!fill || fill.kind === "none") return "none";
+  return {
+    type: "solid",
+    color: fill.color.hex,
+    ...fill.transparencyPercent !== void 0 ? { transparency: clamp(fill.transparencyPercent, 0, 100) } : {}
+  };
+}
+function shapeLine(outline) {
+  if (!outline || !outline.color) return "none";
+  return {
+    color: outline.color.hex,
+    // An omitted width is office-open's omitted `w`, a hairline, where docx's
+    // own default would be 1pt.
+    width: outline.widthEmu !== void 0 ? clamp(outline.widthEmu / EMU_PER_POINT, 0, MAX_POINTS) : 0,
+    ...outline.dash ? { dash: docxLineDash(outline.dash) } : {}
+  };
+}
+function textOptions(text) {
+  const insets = text.insetsEmu;
+  const points = (emu) => clamp(emu / EMU_PER_POINT, 0, MAX_POINTS);
+  const margins = insets ? {
+    ...insets.top !== void 0 ? { top: points(insets.top) } : {},
+    ...insets.right !== void 0 ? { right: points(insets.right) } : {},
+    ...insets.bottom !== void 0 ? { bottom: points(insets.bottom) } : {},
+    ...insets.left !== void 0 ? { left: points(insets.left) } : {}
+  } : void 0;
+  return {
+    verticalAlignment: VERTICAL_ALIGNMENT[text.anchor ?? "top"],
+    ...margins && Object.keys(margins).length > 0 ? { margins } : {}
+  };
+}
+function unrotatedBounds(children) {
+  if (children.length === 0) return void 0;
+  let left = Infinity;
+  let top = Infinity;
+  let right = -Infinity;
+  let bottom = -Infinity;
+  for (const { frame } of children) {
+    left = Math.min(left, frame.xEmu);
+    top = Math.min(top, frame.yEmu);
+    right = Math.max(right, frame.xEmu + frame.widthEmu);
+    bottom = Math.max(bottom, frame.yEmu + frame.heightEmu);
+  }
+  return { left, top, right, bottom };
+}
+function clamp(value, low, high) {
+  return Math.min(high, Math.max(low, value));
+}
+var DEFAULT_MARKERS, EMU_PER_POINT, MAX_POINTS, OVERFLOW_TOLERANCE_EMU, VERTICAL_ALIGNMENT;
+var init_drawingGroup = __esm({
+  "src/renderers/docxjs/drawingGroup.ts"() {
+    "use strict";
+    init_units();
+    init_emit();
+    init_presetShapes();
+    DEFAULT_MARKERS = {
+      noAltText: "jto:no-alt-text",
+      textBox: "jto:text-box"
+    };
+    EMU_PER_POINT = 12700;
+    MAX_POINTS = 1584;
+    OVERFLOW_TOLERANCE_EMU = 2;
+    VERTICAL_ALIGNMENT = {
+      top: "top",
+      middle: "center",
+      bottom: "bottom"
+    };
+  }
+});
+
+// src/renderers/docxjs/drawingGroupRepair.ts
+import AdmZip3 from "adm-zip";
+function repairDrawingGroupsInBuffer(buffer, markers) {
+  const textBox = new RegExp(
+    `(<wps:cNvPr\\b[^>]*?) title="${escapeRegExp2(markers.textBox)}"(\\s*/>)<wps:cNvSpPr/>`,
+    "g"
+  );
+  const noAltText = new RegExp(
+    `(<wp:docPr\\b[^>]*?) descr="${escapeRegExp2(markers.noAltText)}"`,
+    "g"
+  );
+  const zip = new AdmZip3(buffer);
+  const parts = zip.getEntries().filter((entry) => DRAWING_PART.test(entry.entryName)).sort((a, b) => compareDrawingParts(a.entryName, b.entryName));
+  const texts = new Map(
+    parts.map((entry) => [entry, entry.getData().toString("utf8")])
+  );
+  let highest = 0;
+  for (const xml of texts.values()) {
+    for (const match of xml.matchAll(DOC_PR_ID)) {
+      highest = Math.max(highest, Number(match[1]));
+    }
+    for (const match of xml.replace(GROUP, "").matchAll(CNVPR_ID)) {
+      highest = Math.max(highest, Number(match[1]));
+    }
+  }
+  let next = highest + 1;
+  for (const [entry, xml] of texts) {
+    if (!xml.includes("<wpg:wgp")) continue;
+    const repaired = xml.replace(
+      GROUP,
+      (span) => span.replace(CHILD_ID, (_match, head) => `${head}id="${next++}"`).replace(
+        ROTATION,
+        (_match, head, value) => `${head}rot="${Math.round(Number(value))}"`
+      ).replace(textBox, '$1$2<wps:cNvSpPr txBox="1"/>')
+    ).replace(noAltText, "$1");
+    texts.set(entry, repaired);
+    zip.updateFile(entry, Buffer.from(repaired, "utf8"));
+  }
+  for (const [entry, xml] of texts) {
+    if (xml.includes(markers.noAltText) || xml.includes(markers.textBox)) {
+      throw new Error(
+        `the drawing-group repair left a marker in ${entry.entryName}`
+      );
+    }
+  }
+  return zip.toBuffer();
+}
+var GROUP, DOC_PR_ID, CNVPR_ID, CHILD_ID, ROTATION, escapeRegExp2;
+var init_drawingGroupRepair = __esm({
+  "src/renderers/docxjs/drawingGroupRepair.ts"() {
+    "use strict";
+    init_fixFloatingImageIds();
+    GROUP = /<wpg:wgp\b[^>]*>[\s\S]*?<\/wpg:wgp>/g;
+    DOC_PR_ID = /<wp:docPr\b[^>]*?\sid="(\d+)"/g;
+    CNVPR_ID = /<(?:wps|pic|wpg):cNvPr\b[^>]*?\sid="(\d+)"/g;
+    CHILD_ID = /(<(?:wps|pic|wpg):cNvPr\b[^>]*?\s)id="\d+"/g;
+    ROTATION = /(<a:xfrm\b[^>]*?\s)rot="([^"]*)"/g;
+    escapeRegExp2 = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
 });
 
@@ -3799,18 +4637,32 @@ function createDocxJsRenderer() {
     format: "docx",
     capabilities: DOCXJS_CAPABILITIES,
     async render(ir, renderOptions) {
-      const resources = await prepareImages(
+      await loadDocxCharts();
+      const prepared = await prepareImages(
         ir,
         renderOptions?.svgRasterFallback
       );
+      const markers = prepared.drawingGroups > 0 ? chooseMarkers(ir) : void 0;
+      let resources = prepared.images;
+      if (markers) {
+        await shapes.load();
+        resources = Object.assign(prepared.images, {
+          drawingGroup: createDrawingGroupFactory(
+            shapes.get(),
+            prepared.pictureSource,
+            markers
+          )
+        });
+      }
       const document = buildDocument(ir, resources);
       const packed = await Packer.toBuffer(document);
       const fixed = fixFloatingImageIdsInBuffer(packed);
+      const repaired = markers ? repairDrawingGroupsInBuffer(fixed, markers) : fixed;
       if (renderOptions?.deterministic === false)
-        return new Uint8Array(normalizeDocxCaseBuffer(fixed));
+        return new Uint8Array(normalizeDocxCaseBuffer(repaired));
       return new Uint8Array(
         canonicalizeDocxBuffer(
-          fixed,
+          repaired,
           resolveGenerationDate({
             deterministic: renderOptions?.deterministic,
             generatedAt: renderOptions?.generatedAt
@@ -3823,6 +4675,7 @@ function createDocxJsRenderer() {
 function buildDocument(ir, resources = /* @__PURE__ */ new Map()) {
   return new Document({
     styles: emitStyles(ir.styles),
+    ...ir.theme ? { theme: themeOptions(ir.theme) } : {},
     sections: ir.sections.map(
       (section2, index) => sectionOptions(section2, resources, index === ir.sections.length - 1)
     ),
@@ -3854,6 +4707,21 @@ function buildDocument(ir, resources = /* @__PURE__ */ new Map()) {
     } : {}
   });
 }
+function themeOptions(theme) {
+  const colors = {};
+  for (const [slot, color] of Object.entries(theme.colors)) {
+    if (color) colors[slot] = color.hex;
+  }
+  const fonts = {
+    ...theme.headingFont ? { headings: theme.headingFont } : {},
+    ...theme.bodyFont ? { body: theme.bodyFont } : {}
+  };
+  return {
+    name: theme.name,
+    ...Object.keys(colors).length > 0 ? { colors } : {},
+    ...Object.keys(fonts).length > 0 ? { fonts } : {}
+  };
+}
 function noteBodies(notes, resources) {
   const bodies = {};
   for (const note of notes) {
@@ -3891,7 +4759,7 @@ function numberingConfig(numbering) {
   };
 }
 async function prepareImages(ir, svgRasterFallback) {
-  const placements = collectImagePlacements(ir);
+  const { placements, drawingGroups } = collectImagePlacements(ir);
   const jobs = [];
   for (const resource of ir.resources) {
     if (resource.kind !== "image" || resource.mediaType !== "svg") continue;
@@ -3939,16 +4807,55 @@ async function prepareImages(ir, svgRasterFallback) {
       });
     });
   }
-  return resources;
+  const pictureSource = (resourceId, placement) => {
+    const resource = ir.resources.find(
+      (candidate) => candidate.kind === "image" && candidate.id === resourceId
+    );
+    if (!resource) {
+      throw new Error(`no image was prepared for resource "${resourceId}"`);
+    }
+    const data = Buffer.from(resource.bytes);
+    if (resource.mediaType !== "svg") {
+      return {
+        type: resource.mediaType,
+        data
+      };
+    }
+    const size = `${emuToPixels(placement.widthEmu)}x${emuToPixels(placement.heightEmu)}`;
+    return {
+      type: "svg",
+      data,
+      fallback: {
+        type: "png",
+        data: rasters.get(`${resourceId}:${size}`) ?? data
+      }
+    };
+  };
+  return { images: resources, pictureSource, drawingGroups };
 }
 function collectImagePlacements(ir) {
   const placements = /* @__PURE__ */ new Map();
+  let drawingGroups = 0;
+  const record = (resourceId, widthEmu, heightEmu) => {
+    const key = `${emuToPixels(widthEmu)}x${emuToPixels(heightEmu)}`;
+    const sizes = placements.get(resourceId) ?? /* @__PURE__ */ new Set();
+    sizes.add(key);
+    placements.set(resourceId, sizes);
+  };
   const visitInline = (inline) => {
     if (inline.kind === "image") {
-      const key = `${emuToPixels(inline.widthEmu)}x${emuToPixels(inline.heightEmu)}`;
-      const sizes = placements.get(inline.resourceId) ?? /* @__PURE__ */ new Set();
-      sizes.add(key);
-      placements.set(inline.resourceId, sizes);
+      record(inline.resourceId, inline.widthEmu, inline.heightEmu);
+      return;
+    }
+    if (inline.kind === "drawingGroup") {
+      drawingGroups += 1;
+      for (const child of inline.children) {
+        if (child.kind === "picture") {
+          record(child.resourceId, child.frame.widthEmu, child.frame.heightEmu);
+        } else {
+          child.text?.paragraphs.forEach(visitBlock);
+        }
+      }
       return;
     }
     if (inline.kind === "hyperlink" || inline.kind === "revision") {
@@ -3979,7 +4886,7 @@ function collectImagePlacements(ir) {
   for (const note of [...ir.footnotes, ...ir.endnotes]) {
     note.children.forEach(visitBlock);
   }
-  return placements;
+  return { placements, drawingGroups };
 }
 function sectionOptions(section2, resources, closesDocument = false) {
   const { page, columns } = section2.properties;
@@ -4092,17 +4999,26 @@ function coreProperties(ir) {
     ...metadata.custom?.length ? { customProperties: metadata.custom } : {}
   };
 }
-var DOCXJS_RENDERER_ID, DOCXJS_CAPABILITIES;
+var DOCXJS_RENDERER_ID, shapes, DOCXJS_CAPABILITIES;
 var init_docxjs = __esm({
   "src/renderers/docxjs/index.ts"() {
     "use strict";
     init_styles2();
+    init_charts();
     init_imageUtils();
     init_packageDocument();
     init_fixFloatingImageIds();
     init_emit();
+    init_docxSubpath();
+    init_drawingGroup();
+    init_drawingGroupRepair();
     init_units();
     DOCXJS_RENDERER_ID = "docxjs";
+    shapes = docxSubpath(
+      "docx/shapes",
+      "visual",
+      () => import("docx/shapes")
+    );
     DOCXJS_CAPABILITIES = /* @__PURE__ */ new Set([
       "paragraphs",
       "styles",
@@ -4115,8 +5031,10 @@ var init_docxjs = __esm({
       "images",
       "floating-images",
       "svg-images",
+      "charts",
       "text-frames",
       "text-boxes",
+      "drawing-groups",
       "toc",
       "cached-toc",
       "fields",
@@ -4137,183 +5055,331 @@ var init_docxjs = __esm({
   }
 });
 
-// src/utils/chartWorkbook.ts
-import AdmZip3 from "adm-zip";
-import { chartWorkbookParts } from "@json-to-office/shared/rendering";
-import {
-  CHART_WORKBOOK_SHEET_NAME,
-  categoryReference,
-  columnLetter,
-  seriesNameReference,
-  seriesValueReference
-} from "@json-to-office/shared/rendering";
-function buildChartWorkbook(series) {
-  const zip = new AdmZip3();
-  for (const [name, content] of chartWorkbookParts(series)) {
-    zip.addFile(name, Buffer.from(content, "utf8"));
+// src/renderers/office-open/chartLook.ts
+function seriesLook(chartType) {
+  switch (chartType) {
+    case "line":
+    case "scatter":
+      return { marker: MARKER, smooth: false };
+    case "radar":
+      return { marker: MARKER };
+    case "column":
+    case "bar":
+      return { invertIfNegative: false };
+    default:
+      return {};
   }
-  for (const entry of zip.getEntries()) {
-    entry.header.timeval = WORKBOOK_TIMESTAMP;
+}
+function axesLook(chartType) {
+  switch (chartType) {
+    case "column":
+    case "bar":
+    case "line":
+    case "area": {
+      const horizontal = chartType === "bar";
+      return {
+        categoryAxis: {
+          position: horizontal ? "l" : "b",
+          ...NO_TICKS,
+          line: AXIS_LINE
+        },
+        valueAxis: {
+          position: horizontal ? "b" : "l",
+          gridLine: GRIDLINES,
+          ...NO_TICKS,
+          lineVisible: false,
+          crossBetween: chartType === "area" ? "midCat" : "between"
+        }
+      };
+    }
+    case "radar":
+      return {
+        categoryAxis: {
+          position: "b",
+          gridLine: GRIDLINES,
+          ...NO_TICKS,
+          majorTickMark: "cross",
+          line: AXIS_LINE
+        },
+        valueAxis: {
+          position: "l",
+          gridLine: GRIDLINES,
+          ...NO_TICKS,
+          majorTickMark: "cross",
+          line: AXIS_LINE,
+          crossBetween: "between"
+        }
+      };
+    case "scatter": {
+      const line = { ...AXIS_LINE, color: SCATTER_AXIS_TINT };
+      return {
+        categoryAxis: {
+          position: "b",
+          ...NO_TICKS,
+          line,
+          crossBetween: "midCat"
+        },
+        valueAxis: {
+          position: "l",
+          gridLine: GRIDLINES,
+          ...NO_TICKS,
+          line,
+          crossBetween: "midCat"
+        }
+      };
+    }
+    default:
+      return {};
+  }
+}
+function plotLook(chart) {
+  const common = {
+    ...axesLook(chart.chartType),
+    autoTitleDeleted: !(chart.title && chart.showTitle !== false),
+    plotAreaUnfilled: true
+  };
+  switch (chart.chartType) {
+    case "column":
+      return { ...common, dataBorder: "none", gapWidth: 219, overlap: -27 };
+    case "bar":
+      return { ...common, dataBorder: "none", gapWidth: 182, overlap: 0 };
+    case "area":
+      return { ...common, dataBorder: "none" };
+    case "line":
+      return { ...common, ...LINE_SERIES, lineMarkers: true };
+    case "radar":
+      return { ...common, ...LINE_SERIES, radarStyle: "marker" };
+    case "scatter": {
+      const labels = chart.series[0]?.labels ?? [];
+      return {
+        ...common,
+        ...LINE_SERIES,
+        lineWidthPoints: 1.5,
+        scatterStyle: "lineMarker",
+        scatterXValues: labels.map((_, index) => scatterX(labels, index))
+      };
+    }
+    case "pie":
+    case "doughnut":
+      return {
+        ...common,
+        dataBorder: { widthPoints: 1.5, color: { scheme: "lt1" } },
+        firstSliceAngle: 0,
+        ...chart.chartType === "doughnut" ? { holeSize: 50 } : {}
+      };
+    default:
+      return common;
   }
-  return new Uint8Array(zip.toBuffer());
 }
-var WORKBOOK_TIMESTAMP;
-var init_chartWorkbook = __esm({
-  "src/utils/chartWorkbook.ts"() {
+var TEXT_1_TINT, SCATTER_AXIS_TINT, HAIRLINE_POINTS, GRIDLINES, AXIS_LINE, NO_TICKS, LINE_SERIES, MARKER;
+var init_chartLook = __esm({
+  "src/renderers/office-open/chartLook.ts"() {
     "use strict";
-    init_packageDocument();
-    WORKBOOK_TIMESTAMP = toDosTime(DEFAULT_GENERATION_DATE);
+    init_chartValues();
+    TEXT_1_TINT = { scheme: "tx1", lumMod: 15e3, lumOff: 85e3 };
+    SCATTER_AXIS_TINT = {
+      scheme: "tx1",
+      lumMod: 25e3,
+      lumOff: 75e3
+    };
+    HAIRLINE_POINTS = 0.75;
+    GRIDLINES = {
+      size: HAIRLINE_POINTS,
+      color: TEXT_1_TINT
+    };
+    AXIS_LINE = {
+      widthPoints: HAIRLINE_POINTS,
+      color: TEXT_1_TINT
+    };
+    NO_TICKS = {
+      majorTickMark: "none",
+      minorTickMark: "none",
+      tickLabelPosition: "nextTo"
+    };
+    LINE_SERIES = {
+      lineWidthPoints: 2.25,
+      lineCap: "rnd",
+      lineJoin: "round",
+      markerLineWidthPoints: HAIRLINE_POINTS
+    };
+    MARKER = { symbol: "circle", size: 5 };
   }
 });
 
 // src/renderers/office-open/chartParts.ts
 import {
-  CHART_WORKBOOK_CONTENT_TYPE,
-  chartWorkbookRelsXml,
-  matchChartParts,
-  spliceChartXml
+  finishChartXml,
+  matchChartParts
 } from "@json-to-office/shared/rendering";
-function spliceInput(chart) {
-  const { bold, ...rest } = chart.textFont;
-  const textFont = rest;
-  const axisTitleFont = { ...rest, bold };
-  const chartTitleFont = {
-    ...rest,
-    fontSize: Math.round(rest.fontSize * CHART_TITLE_SCALE),
-    bold: true
+function chartInput(chart) {
+  const roles = chartTextRoles(chart.textFont);
+  const textFont = roles.text;
+  const axisTitleFont = roles.axisTitle;
+  const chartTitleFont = roles.title;
+  const look = plotLook(chart);
+  const categoryAxis = {
+    ...look.categoryAxis,
+    ...chart.categoryAxisTitle ? { title: chart.categoryAxisTitle, titleFont: axisTitleFont } : {}
+  };
+  const valueAxis = {
+    ...look.valueAxis,
+    ...chart.valueAxisTitle ? { title: chart.valueAxisTitle, titleFont: axisTitleFont } : {}
   };
   return {
+    ...look,
     chartType: chart.chartType,
     series: chart.series,
     colors: chart.colors,
+    ...chart.title && chart.showTitle !== false ? { title: chart.title } : {},
     textFont,
     titleFont: chartTitleFont,
     ...chart.legendPosition ? { legendPosition: chart.legendPosition } : {},
-    ...chart.categoryAxisTitle ? {
-      categoryAxis: {
-        title: chart.categoryAxisTitle,
-        titleFont: axisTitleFont
-      }
-    } : {},
-    ...chart.valueAxisTitle ? {
-      valueAxis: { title: chart.valueAxisTitle, titleFont: axisTitleFont }
-    } : {}
+    ...Object.keys(categoryAxis).length > 0 ? { categoryAxis } : {},
+    ...Object.keys(valueAxis).length > 0 ? { valueAxis } : {}
   };
 }
-function declareWorkbookContentType(zip) {
-  const entry = zip.getEntry("[Content_Types].xml");
-  if (!entry) return;
-  const xml = entry.getData().toString("utf8");
-  if (xml.includes(`Extension="xlsx"`)) return;
-  zip.updateFile(
-    entry,
-    Buffer.from(
-      xml.replace(
-        '<Default Extension="xml"',
-        `<Default Extension="xlsx" ContentType="${CHART_WORKBOOK_CONTENT_TYPE}"/><Default Extension="xml"`
-      ),
-      "utf8"
-    )
-  );
-}
-function spliceChartParts(zip, charts) {
-  if (charts.length === 0) return;
+function finishChartParts(zip, charts2) {
+  if (charts2.length === 0) return;
   const parts = zip.getEntries().map((entry) => entry.entryName).map((name) => name.match(/^word\/charts\/chart(\d+)\.xml$/)).filter((match) => match !== null).map(
     (match) => [
       Number(match[1]),
       zip.getEntry(match[0]).getData().toString("utf8")
     ]
   );
-  for (const { ordinal, xml, chart } of matchChartParts(parts, charts)) {
-    const workbookName = `chart${ordinal}.xlsx`;
+  const inputs = charts2.map(chartInput);
+  for (const { ordinal, xml, chart } of matchChartParts(parts, inputs)) {
+    const finished = finishChartXml(xml, chart);
+    if (finished === xml) continue;
     zip.updateFile(
       zip.getEntry(`word/charts/chart${ordinal}.xml`),
-      Buffer.from(spliceChartXml(xml, spliceInput(chart)), "utf8")
-    );
-    zip.addFile(
-      `word/embeddings/${workbookName}`,
-      Buffer.from(buildChartWorkbook(chart.series))
-    );
-    zip.addFile(
-      `word/charts/_rels/chart${ordinal}.xml.rels`,
-      Buffer.from(chartWorkbookRelsXml(workbookName), "utf8")
+      Buffer.from(finished, "utf8")
     );
   }
-  declareWorkbookContentType(zip);
 }
-var CHART_TITLE_SCALE;
 var init_chartParts = __esm({
   "src/renderers/office-open/chartParts.ts"() {
     "use strict";
-    init_chartWorkbook();
-    CHART_TITLE_SCALE = 1.4;
+    init_chartText();
+    init_chartLook();
   }
 });
 
-// src/renderers/office-open/cellTocs.ts
-function spliceCellTocs(zip, tocs, stringifyTableOfContents) {
-  if (tocs.length === 0) return;
-  const spliced = /* @__PURE__ */ new Set();
-  for (const entry of zip.getEntries()) {
-    if (!TABLE_PARTS.test(entry.entryName)) continue;
-    const original = entry.getData().toString("utf8");
-    let xml = original;
-    for (const toc of tocs) {
-      const start = markerParagraph(xml, toc.start);
-      if (!start) continue;
-      const end = markerParagraph(xml, toc.end);
-      if (spliced.has(toc) || !end || end.from < start.to) {
-        throw new Error(
-          `the office-open renderer lost track of a table of contents in a table cell (${entry.entryName})`
-        );
-      }
-      xml = xml.slice(0, start.from) + stringifyTableOfContents(
-        toc.alias,
-        toc.options,
-        xml.slice(start.to, end.from)
-      ) + xml.slice(end.to);
-      spliced.add(toc);
-    }
-    if (xml !== original) zip.updateFile(entry, Buffer.from(xml, "utf8"));
-  }
-  if (spliced.size !== tocs.length) {
+// src/renderers/office-open/themePart.ts
+function replaceOnce(xml, pattern, replacer, what) {
+  const count = [...xml.matchAll(pattern)].length;
+  if (count !== 1) {
     throw new Error(
-      `the office-open renderer placed ${tocs.length} table(s) of contents in table cells and found ${spliced.size}`
+      `office-open's theme part has ${count} ${what}, expected one`
     );
   }
+  return xml.replace(pattern, replacer);
+}
+function spliceTheme(zip, theme) {
+  const entry = zip.getEntry(THEME_PART);
+  if (!entry) throw new Error(`office-open wrote no ${THEME_PART}`);
+  let xml = entry.getData().toString("utf8");
+  const name = esc(theme.name);
+  xml = renamed(xml, "theme", name);
+  const colors = Object.entries(theme.colors);
+  if (colors.some(([, color]) => color)) {
+    xml = renamed(xml, "clrScheme", name);
+    for (const [slot, color] of colors) {
+      if (!color) continue;
+      const element = SCHEME_ELEMENT[slot];
+      xml = replaceOnce(
+        xml,
+        new RegExp(`<a:${element}>[\\s\\S]*?</a:${element}>`, "g"),
+        () => `<a:${element}><a:srgbClr val="${color.hex}"/></a:${element}>`,
+        `a:${element}`
+      );
+    }
+  }
+  if (theme.headingFont || theme.bodyFont) {
+    xml = renamed(xml, "fontScheme", name);
+    for (const [collection, key, officeFace] of OFFICE_FACES) {
+      const family = theme[key];
+      if (family === void 0 || family === officeFace) continue;
+      xml = replaceOnce(
+        xml,
+        new RegExp(`(<a:${collection}>)<a:latin\\b[^>]*/>`, "g"),
+        (_match, open) => `${open}<a:latin typeface="${esc(family)}"/>`,
+        `a:${collection} a:latin`
+      );
+    }
+  }
+  zip.updateFile(THEME_PART, Buffer.from(xml, "utf8"));
 }
-function markerParagraph(xml, marker) {
-  const at = xml.indexOf(marker);
-  if (at < 0) return void 0;
-  const from = Math.max(
-    xml.lastIndexOf("<w:p>", at),
-    xml.lastIndexOf("<w:p ", at)
-  );
-  const close = xml.indexOf("</w:p>", at);
-  if (xml.indexOf(marker, at + marker.length) >= 0 || from < 0 || close < 0 || xml.lastIndexOf("</w:p>", at) > from) {
-    throw new Error(
-      "the office-open renderer found a table-of-contents marker it did not write"
+var THEME_PART, SCHEME_ELEMENT, OFFICE_FACES, esc, renamed;
+var init_themePart = __esm({
+  "src/renderers/office-open/themePart.ts"() {
+    "use strict";
+    THEME_PART = "word/theme/theme1.xml";
+    SCHEME_ELEMENT = {
+      dark1: "dk1",
+      light1: "lt1",
+      dark2: "dk2",
+      light2: "lt2",
+      accent1: "accent1",
+      accent2: "accent2",
+      accent3: "accent3",
+      accent4: "accent4",
+      accent5: "accent5",
+      accent6: "accent6",
+      hyperlink: "hlink",
+      followedHyperlink: "folHlink"
+    };
+    OFFICE_FACES = [
+      ["majorFont", "headingFont", "Calibri Light"],
+      ["minorFont", "bodyFont", "Calibri"]
+    ];
+    esc = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    renamed = (xml, element, name) => replaceOnce(
+      xml,
+      new RegExp(`(<a:${element}\\b[^>]*?\\bname=")[^"]*(")`, "g"),
+      (_match, open, close) => `${open}${name}${close}`,
+      `a:${element} name`
     );
   }
-  return { from, to: close + "</w:p>".length };
+});
+
+// src/utils/chartWorkbook.ts
+import AdmZip4 from "adm-zip";
+import { chartWorkbookParts } from "@json-to-office/shared/rendering";
+import {
+  CHART_WORKBOOK_SHEET_NAME,
+  categoryReference,
+  columnLetter,
+  seriesNameReference,
+  seriesValueReference
+} from "@json-to-office/shared/rendering";
+function buildChartWorkbook(series, options = {}) {
+  const zip = new AdmZip4();
+  for (const [name, content] of chartWorkbookParts(series, options)) {
+    zip.addFile(name, Buffer.from(content, "utf8"));
+  }
+  for (const entry of zip.getEntries()) {
+    entry.header.timeval = WORKBOOK_TIMESTAMP;
+  }
+  return new Uint8Array(zip.toBuffer());
 }
-var TABLE_PARTS;
-var init_cellTocs = __esm({
-  "src/renderers/office-open/cellTocs.ts"() {
+var WORKBOOK_TIMESTAMP;
+var init_chartWorkbook = __esm({
+  "src/utils/chartWorkbook.ts"() {
     "use strict";
-    TABLE_PARTS = /^word\/(?:document|header\d+|footer\d+)\.xml$/;
+    init_packageDocument();
+    WORKBOOK_TIMESTAMP = toDosTime(DEFAULT_GENERATION_DATE);
   }
 });
 
 // src/renderers/office-open/emit.ts
-import { assertNever as assertNever2 } from "@json-to-office/shared/rendering";
+import { assertNever as assertNever3 } from "@json-to-office/shared/rendering";
+import { chartLook, withSeriesLook } from "@json-to-office/shared/rendering";
 function emptyContext() {
   let next = 1;
   return {
     pictures: /* @__PURE__ */ new Map(),
     nextDrawingId: () => next++,
-    charts: [],
-    cellTocs: []
+    charts: []
   };
 }
 function simpleField(instruction, cachedText) {
@@ -4354,18 +5420,19 @@ function runProperties2(formatting) {
   if (formatting.doubleStrike !== void 0) {
     out.doubleStrike = formatting.doubleStrike;
   }
-  if (formatting.superScript) out.superScript = true;
-  if (formatting.subScript) out.subScript = true;
+  if (formatting.superScript) out.verticalAlign = "superscript";
+  if (formatting.subScript) out.verticalAlign = "subscript";
   if (formatting.smallCaps !== void 0) out.smallCaps = formatting.smallCaps;
   if (formatting.allCaps !== void 0) out.allCaps = formatting.allCaps;
-  if (formatting.highlight !== void 0) out.highlight = formatting.highlight;
+  if (formatting.highlight !== void 0) {
+    out.highlight = formatting.highlight;
+  }
   if (formatting.shading) out.shading = shading(formatting.shading);
   if (formatting.scalePercent !== void 0)
     out.scale = formatting.scalePercent;
-  if (formatting.characterSpacingTwentieths !== void 0) {
-    const stated = formatting.characterSpacingTwentieths;
-    const twentieths = twips(stated);
-    out.characterSpacing = twentieths === 0 && stated !== 0 ? "0pt" : twentieths;
+  const stated = formatting.characterSpacingTwentieths;
+  if (stated !== void 0 && stated !== 0) {
+    out.characterSpacing = twips(stated);
   }
   if (formatting.language) out.language = { value: formatting.language };
   if (formatting.noProof !== void 0) out.noProof = formatting.noProof;
@@ -4395,7 +5462,9 @@ function inlineChildren2(children, ctx = emptyContext()) {
     switch (child.kind) {
       case "lineBreak":
         pendingBreaks += 1;
-        if (child.clear && child.clear !== "none") pendingClear = child.clear;
+        if (child.clear && child.clear !== "none") {
+          pendingClear = child.clear;
+        }
         break;
       case "text":
         out.push({
@@ -4433,7 +5502,7 @@ function inlineChildren2(children, ctx = emptyContext()) {
       case "drawingGroup": {
         const pending = breakOption();
         if (pending.break) out.push(pending);
-        out.push({ wpgGroup: drawingGroupOptions(child, ctx) });
+        out.push({ wpgGroup: drawingGroupOptions2(child, ctx) });
         break;
       }
       case "hyperlink":
@@ -4463,8 +5532,9 @@ function inlineChildren2(children, ctx = emptyContext()) {
         out.push({ wpsShape: shapeOptions(child, ctx) });
         break;
       case "chart":
-        ctx.charts?.push(child);
-        out.push({ chart: chartOptions(child, ctx) });
+        out.push({
+          chart: chartOptions(child, ctx, ctx.charts?.push(child) ?? 1)
+        });
         break;
       case "noteReference":
         out.push(
@@ -4472,7 +5542,7 @@ function inlineChildren2(children, ctx = emptyContext()) {
         );
         break;
       default:
-        assertNever2(child, "DocxIrInline");
+        assertNever3(child, "DocxIrInline");
     }
   }
   return out;
@@ -4513,8 +5583,11 @@ function floatingOptions2(floating) {
     ...floating.vertical ? { verticalPosition: position(floating.vertical) } : {},
     ...floating.wrap ? {
       wrap: {
-        type: WRAP_TYPE2[floating.wrap.type],
-        ...floating.wrap.side ? { side: floating.wrap.side } : {}
+        // Named, as OOXML names them; 0.11 took docx.js's numbers.
+        type: floating.wrap.type,
+        ...floating.wrap.side ? {
+          side: floating.wrap.side
+        } : {}
       }
     } : {},
     ...floating.margins ? {
@@ -4541,66 +5614,92 @@ function imageMedia(ctx, resourceId, placement) {
 }
 function pictureOptions(image, ctx) {
   const media = imageMedia(ctx, image.resourceId, image);
-  return {
-    type: media.type,
+  const source = media.type === "svg" ? {
+    type: "svg",
     data: media.data,
-    // No `fileName`: at run level the backend allocates one, and stating our
-    // own would only fight it.
-    ...media.fallback ? { fallback: media.fallback } : {},
+    // The SVG slot always carries a raster: `prepareImages` falls back
+    // to the vector bytes when none could be made.
+    fallback: media.fallback ?? {
+      type: "png",
+      data: media.data
+    }
+  } : { type: media.type, data: media.data };
+  return {
+    ...source,
     // Raw numbers are EMUs in @office-open/docx. Passing pixels here makes a
     // normal image only a few hundred EMUs wide, effectively a dot.
     transformation: { width: image.widthEmu, height: image.heightEmu },
     // The id is stated rather than left to the backend's process-global
-    // counter. `name` stays empty, which is what it was before and what the
-    // backend falls back to.
-    altText: { id: String(ctx.nextDrawingId()) },
+    // counter. `name` stays empty, which is what the backend falls back to.
+    altText: { id: String(ctx.nextDrawingId()), name: "" },
     ...image.floating ? { floating: floatingOptions2(image.floating) } : {}
     // No `description` or `title`: no DOCX this pipeline has produced carries
     // `wp:docPr` alt text, and the compiler warns so the gap is visible rather
     // than silent.
   };
 }
-function drawingGroupOptions(group, ctx) {
+function drawingGroupOptions2(group, ctx) {
   const id = ctx.nextDrawingId();
   return {
     altText: {
       id: String(id),
+      name: "",
       ...group.altText ? { description: group.altText } : {}
     },
     transformation: { width: group.widthEmu, height: group.heightEmu },
-    childOffset: { x: 0, y: 0 },
-    childExtent: { cx: group.canvasWidthEmu, cy: group.canvasHeightEmu },
-    children: group.children.map((child) => groupChild(child, ctx)),
+    childOffsetX: 0,
+    childOffsetY: 0,
+    childExtentWidth: group.canvasWidthEmu,
+    childExtentHeight: group.canvasHeightEmu,
+    children: group.children.map((child) => groupChild2(child, ctx)),
     ...group.floating ? { floating: floatingOptions2(group.floating) } : {}
   };
 }
-function chartOptions(chart, ctx) {
+function chartOptions(chart, ctx, ordinal) {
   const id = ctx.nextDrawingId();
+  const input = chartInput(chart);
+  const look = chartLook(input);
   return {
     type: chart.chartType,
     categories: chart.series[0]?.labels ?? [],
-    series: chart.series.map((entry, index) => ({
-      name: entry.name ?? `Series ${index + 1}`,
-      values: entry.values
-    })),
-    ...chart.title && chart.showTitle !== false ? { title: chart.title } : {},
+    series: chart.series.map(
+      (entry, index) => withSeriesLook(
+        {
+          name: entry.name ?? `Series ${index + 1}`,
+          values: entry.values,
+          ...seriesLook(chart.chartType)
+        },
+        look.series[index]
+      )
+    ),
+    ...look.chart,
     ...chart.showLegend !== void 0 ? { showLegend: chart.showLegend } : {},
+    externalData: {
+      ...look.chart.externalData,
+      fileName: `chart${ordinal}.xlsx`,
+      // A scatter chart's column A holds the x values its `c:xVal` caches.
+      data: buildChartWorkbook(
+        chart.series,
+        input.scatterXValues ? { categoryValues: input.scatterXValues } : {}
+      )
+    },
     transformation: { width: chart.widthEmu, height: chart.heightEmu },
     altText: {
       id: String(id),
+      name: "",
       ...chart.altText ? { description: chart.altText } : {}
     },
     ...chart.floating ? { floating: floatingOptions2(chart.floating) } : {}
   };
 }
-function groupChild(child, ctx) {
+function groupChild2(child, ctx) {
   return child.kind === "shape" ? groupShape(child, ctx) : groupPicture(child, ctx);
 }
 function groupShape(shape, ctx) {
   const id = ctx.nextDrawingId();
   return {
     type: "wps",
-    transformation: childTransformation(shape.frame),
+    transformation: childTransformation2(shape.frame),
     data: {
       nonVisualProperties: {
         id,
@@ -4609,7 +5708,7 @@ function groupShape(shape, ctx) {
         // to hold text, and it changes how the object behaves on selection.
         ...shape.isTextBox ? { textBox: "1" } : {}
       },
-      presetGeometry: { preset: shape.geometry },
+      geometry: shape.geometry,
       ...shape.fill ? { fill: drawingFill(shape.fill) } : {},
       ...shape.outline ? { outline: drawingOutline(shape.outline) } : {},
       children: (shape.text?.paragraphs ?? []).map(
@@ -4635,7 +5734,7 @@ function groupPicture(picture2, ctx) {
         fileName: media.fallbackFileName
       }
     } : {},
-    transformation: childTransformation(picture2.frame),
+    transformation: childTransformation2(picture2.frame),
     nonVisualProperties: {
       id,
       ...picture2.name ? { name: picture2.name } : {},
@@ -4644,11 +5743,7 @@ function groupPicture(picture2, ctx) {
     ...picture2.crop ? { sourceRectangle: sourceRectangle(picture2.crop) } : {}
   };
 }
-function childTransformation(frame) {
-  const flip = {
-    ...frame.flipHorizontal ? { horizontal: true } : {},
-    ...frame.flipVertical ? { vertical: true } : {}
-  };
+function childTransformation2(frame) {
   return {
     offset: {
       emus: { x: frame.xEmu, y: frame.yEmu },
@@ -4664,7 +5759,8 @@ function childTransformation(frame) {
     },
     // Degrees: the backend multiplies by 60000 on the way into `@rot`.
     ...frame.rotationDegrees !== void 0 ? { rotation: frame.rotationDegrees } : {},
-    ...Object.keys(flip).length > 0 ? { flip } : {}
+    ...frame.flipHorizontal ? { flipHorizontal: true } : {},
+    ...frame.flipVertical ? { flipVertical: true } : {}
   };
 }
 function drawingFill(fill) {
@@ -4672,7 +5768,6 @@ function drawingFill(fill) {
   return {
     type: "solid",
     color: {
-      type: "rgb",
       value: fill.color.hex,
       // Transparency becomes an alpha transform on the colour. DrawingML
       // states *opacity*, so the value is the complement of what the author
@@ -4714,7 +5809,7 @@ function sourceRectangle(crop) {
 function shapeOptions(shape, ctx) {
   const id = String(ctx.nextDrawingId());
   return {
-    altText: { id },
+    altText: { id, name: "" },
     children: shape.children.map((child) => paragraph(child, ctx)),
     // Raw transformation numbers are EMUs in @office-open/docx, while the IR
     // deliberately stores native shape dimensions in pixels.
@@ -4725,7 +5820,7 @@ function shapeOptions(shape, ctx) {
     ...shape.fill ? {
       fill: {
         type: "solid",
-        color: { type: "rgb", value: shape.fill.hex }
+        color: { value: shape.fill.hex }
       }
     } : {},
     ...shape.outline ? { outline: drawingOutline(shape.outline) } : {},
@@ -4830,13 +5925,19 @@ function frameOptions2(frame) {
     ...frame.anchorLock !== void 0 ? { anchorLock: frame.anchorLock } : {},
     ...frame.rule ? { rule: frame.rule } : {}
   };
-  return frame.xTwips !== void 0 || frame.yTwips !== void 0 ? {
-    type: "absolute",
-    position: { x: frame.xTwips ?? 0, y: frame.yTwips ?? 0 },
-    ...base
-  } : {
+  if (frame.xTwips !== void 0 || frame.yTwips !== void 0) {
+    return {
+      type: "absolute",
+      position: { x: frame.xTwips ?? 0, y: frame.yTwips ?? 0 },
+      ...base
+    };
+  }
+  return {
     type: "alignment",
-    alignment: { x: frame.xAlign, y: frame.yAlign },
+    alignment: {
+      x: frame.xAlign,
+      y: frame.yAlign
+    },
     ...base
   };
 }
@@ -4857,7 +5958,7 @@ function block(value, ctx = emptyContext()) {
     case "toc":
       return { toc: tableOfContents(value) };
     default:
-      return assertNever2(value, "DocxIrBlock");
+      return assertNever3(value, "DocxIrBlock");
   }
 }
 function tocEntry(entry) {
@@ -4876,6 +5977,7 @@ function tableOfContents(value) {
       headingStyleRange: `${value.headingRange.from}-${value.headingRange.to}`
     } : {},
     ...value.styleLevels?.length ? {
+      // `StyleLevel` is a class the backend only reads the two fields of.
       stylesWithLevels: value.styleLevels.map((style) => ({
         styleName: style.styleName,
         level: style.level
@@ -4897,14 +5999,16 @@ function table(value, ctx) {
       // unstated columns comes out fractional, and the XML would carry it
       // verbatim; floored here, as the docxjs backend floors it.
       size: value.width.kind === "auto" ? 0 : value.width.kind === "twips" ? twips(value.width.value) : value.width.value,
-      type: value.width.kind === "twips" ? "dxa" : value.width.kind === "percent" ? "pct" : "auto"
+      type: value.width.kind === "twips" ? "twips" : value.width.kind === "percent" ? "percent" : "auto"
     },
     layout: value.layout,
     // An empty grid is a table with nothing to say about its columns, which is
     // not the same as one whose columns are all zero wide. The compiler hands
     // over every grid in twips; floored for the same reason as the width.
     ...value.columnGrid.values.length > 0 ? { columnWidths: value.columnGrid.values.map(twips) } : {},
-    ...value.alignment ? { alignment: alignment(value.alignment) } : {},
+    ...value.alignment ? {
+      alignment: alignment(value.alignment)
+    } : {},
     ...value.borders ? { borders: borders2(value.borders) } : {},
     ...value.cellMargins ? { margins: cellMargins(value.cellMargins) } : {},
     ...value.floating ? { float: tableFloat2(value.floating) } : {}
@@ -4949,52 +6053,29 @@ function tableRow(row, ctx) {
 }
 function tableCell(cell, ctx) {
   const children = cellChildren2(cell, ctx);
-  if (cell.children[cell.children.length - 1]?.kind !== "paragraph")
+  if (cell.children[cell.children.length - 1]?.kind === "toc")
     children.push({ paragraph: { children: [] } });
   return {
     children,
-    ...cell.widthTwips !== void 0 ? { width: { size: twips(cell.widthTwips), type: "dxa" } } : {},
-    ...cell.verticalAlign ? { verticalAlign: cell.verticalAlign } : {},
+    ...cell.widthTwips !== void 0 ? { width: { size: twips(cell.widthTwips), type: "twips" } } : {},
+    ...cell.verticalAlign ? {
+      verticalAlign: cell.verticalAlign
+    } : {},
     ...cell.shading ? { shading: shading(cell.shading) } : {},
     ...cell.margins ? { margins: cellMargins(cell.margins) } : {},
     ...cell.borders ? { borders: borders2(cell.borders) } : {},
     ...cell.columnSpan !== void 0 ? { columnSpan: cell.columnSpan } : {},
     ...cell.rowSpan !== void 0 ? { verticalMerge: cell.rowSpan } : {},
-    ...cell.textDirection ? { textDirection: cell.textDirection } : {}
+    ...cell.textDirection ? {
+      textDirection: cell.textDirection
+    } : {}
   };
 }
 function cellChildren2(cell, ctx) {
-  const children = [];
-  for (const child of cell.children) {
-    if (child.kind !== "toc") {
-      children.push(block(child, ctx));
-      continue;
-    }
-    const { alias, entries, ...options } = tableOfContents(child);
-    const index = ctx.cellTocs.length;
-    const toc = {
-      start: cellTocMarker(index, "start"),
-      end: cellTocMarker(index, "end"),
-      alias: String(alias),
-      options
-    };
-    ctx.cellTocs.push(toc);
-    children.push(
-      markerParagraph2(toc.start),
-      ...entries ?? [],
-      markerParagraph2(toc.end)
-    );
-  }
-  return children;
-}
-function cellTocMarker(index, edge) {
-  return `\uE000jto-cell-toc-${index}-${edge}\uE000`;
-}
-function markerParagraph2(text) {
-  return { paragraph: { children: [{ text }] } };
+  return cell.children.map((child) => block(child, ctx));
 }
 function cellMargins(margins) {
-  const side = (value) => value === void 0 ? void 0 : { size: twips(value), type: "dxa" };
+  const side = (value) => value === void 0 ? void 0 : { size: twips(value), type: "twips" };
   const out = {};
   for (const [name, value] of [
     ["top", margins.topTwips],
@@ -5037,39 +6118,43 @@ function section(value, ctx, closesDocument = false) {
     properties: {
       ...value.properties.type ? { type: value.properties.type } : {},
       ...value.properties.titlePage !== void 0 ? { titlePage: value.properties.titlePage } : {},
-      page: {
-        // Orientation is implied by the width/height pair, which is how this
-        // pipeline has always expressed it; stating it as well changes `w:pgSz`.
-        size: {
-          width: twips(page.widthTwips),
-          height: twips(page.heightTwips),
-          ...page.code !== void 0 ? { code: page.code } : {}
-        },
-        margin: {
-          top: twips(page.margins.topTwips),
-          right: twips(page.margins.rightTwips),
-          bottom: twips(page.margins.bottomTwips),
-          left: twips(page.margins.leftTwips),
-          ...page.margins.headerTwips !== void 0 ? { header: twips(page.margins.headerTwips) } : {},
-          ...page.margins.footerTwips !== void 0 ? { footer: twips(page.margins.footerTwips) } : {},
-          ...page.margins.gutterTwips !== void 0 ? { gutter: twips(page.margins.gutterTwips) } : {}
-        },
-        ...value.properties.pageNumbers ? {
-          pageNumbers: {
-            ...value.properties.pageNumbers.start !== void 0 ? { start: value.properties.pageNumbers.start } : {},
-            ...value.properties.pageNumbers.formatType ? { formatType: value.properties.pageNumbers.formatType } : {}
-          }
-        } : {},
-        ...value.properties.borders ? {
-          borders: {
-            ...value.properties.borders.display ? { display: value.properties.borders.display } : {},
-            ...value.properties.borders.offsetFrom ? { offsetFrom: value.properties.borders.offsetFrom } : {},
-            ...value.properties.borders.borders ? borders2(value.properties.borders.borders) : {}
-          }
-        } : {}
+      // Orientation is implied by the width/height pair, which is how this
+      // pipeline has always expressed it; stating it as well changes `w:pgSz`.
+      pageSize: {
+        width: twips(page.widthTwips),
+        height: twips(page.heightTwips),
+        ...page.code !== void 0 ? { code: page.code } : {}
+      },
+      pageMargin: {
+        top: twips(page.margins.topTwips),
+        right: twips(page.margins.rightTwips),
+        bottom: twips(page.margins.bottomTwips),
+        left: twips(page.margins.leftTwips),
+        ...page.margins.headerTwips !== void 0 ? { header: twips(page.margins.headerTwips) } : {},
+        ...page.margins.footerTwips !== void 0 ? { footer: twips(page.margins.footerTwips) } : {},
+        ...page.margins.gutterTwips !== void 0 ? { gutter: twips(page.margins.gutterTwips) } : {}
       },
+      ...value.properties.pageNumbers ? {
+        pageNumberType: {
+          ...value.properties.pageNumbers.start !== void 0 ? { start: value.properties.pageNumbers.start } : {},
+          ...value.properties.pageNumbers.formatType ? {
+            format: value.properties.pageNumbers.formatType
+          } : {}
+        }
+      } : {},
+      ...value.properties.borders ? {
+        pageBorders: {
+          ...value.properties.borders.display ? {
+            display: value.properties.borders.display
+          } : {},
+          ...value.properties.borders.offsetFrom ? {
+            offsetFrom: value.properties.borders.offsetFrom
+          } : {},
+          ...value.properties.borders.borders ? borders2(value.properties.borders.borders) : {}
+        }
+      } : {},
       ...columns ? {
-        column: {
+        columns: {
           count: columns.count,
           ...columns.spaceTwips !== void 0 ? { space: twips(columns.spaceTwips) } : {},
           ...columns.separator !== void 0 ? { separate: columns.separator } : {},
@@ -5113,6 +6198,8 @@ function sectionChildren2(value, ctx, closesDocument = false) {
         spacing: { before: 0, after: 0, line: 20, lineRule: "exact" }
       }
     });
+  if (!closesDocument && !bookmark?.closes && last?.kind === "toc")
+    blocks.push({ paragraph: { children: [] } });
   if (!bookmark) return blocks;
   return [
     ...bookmark.opens ? [{ bookmarkStart: { id: bookmark.id, name: bookmark.name } }] : [],
@@ -5123,15 +6210,19 @@ function sectionChildren2(value, ctx, closesDocument = false) {
 function numberingConfig2(numbering) {
   return {
     reference: numbering.reference,
-    levels: numbering.levels.map((level) => ({
-      level: level.level,
-      format: level.format,
-      text: level.text,
-      ...level.alignment ? { alignment: alignment(level.alignment) } : {},
-      ...level.suffix ? { suffix: level.suffix } : {},
-      ...level.start !== void 0 ? { start: level.start } : {},
-      ...level.paragraphStyleId ? { paragraphStyle: level.paragraphStyleId } : {},
-      style: {
+    levels: numbering.levels.map(
+      (level) => ({
+        level: level.level,
+        format: level.format,
+        text: level.text,
+        ...level.alignment ? { alignment: alignment(level.alignment) } : {},
+        ...level.suffix ? { suffix: level.suffix } : {},
+        // Always stated. docx.js writes `w:start w:val="1"` for a level that
+        // names none, and so did this backend until 0.14, which writes no
+        // `w:start` at all when it is not given one; Word and LibreOffice then
+        // count every such list from 0.
+        start: level.start ?? 1,
+        ...level.paragraphStyleId ? { paragraphStyle: level.paragraphStyleId } : {},
         ...level.indent ? {
           paragraph: {
             indent: {
@@ -5141,25 +6232,22 @@ function numberingConfig2(numbering) {
           }
         } : {},
         ...level.run ? { run: runProperties2(level.run) } : {}
-      }
-    }))
+      })
+    )
   };
 }
-var WRAP_TYPE2, BODY_ANCHOR;
+var BODY_ANCHOR;
 var init_emit2 = __esm({
   "src/renderers/office-open/emit.ts"() {
     "use strict";
     init_units();
-    WRAP_TYPE2 = {
-      none: 0,
-      square: 1,
-      tight: 2,
-      topAndBottom: 3
-    };
+    init_chartWorkbook();
+    init_chartLook();
+    init_chartParts();
     BODY_ANCHOR = {
-      top: "t",
-      middle: "ctr",
-      bottom: "b"
+      top: "top",
+      middle: "center",
+      bottom: "bottom"
     };
   }
 });
@@ -5219,37 +6307,49 @@ var init_styles3 = __esm({
 var office_open_exports = {};
 __export(office_open_exports, {
   OFFICE_OPEN_DOCX_RENDERER_ID: () => OFFICE_OPEN_DOCX_RENDERER_ID,
+  OFFICE_OPEN_VERSION: () => OFFICE_OPEN_VERSION,
   buildDocumentOptions: () => buildDocumentOptions,
   createOfficeOpenDocxRenderer: () => createOfficeOpenDocxRenderer
 });
-import AdmZip4 from "adm-zip";
+import AdmZip5 from "adm-zip";
+import {
+  assertBackendVersion,
+  installedPackageVersion
+} from "@json-to-office/shared/rendering/node";
+function installedBackendVersion() {
+  let resolved;
+  try {
+    resolved = import.meta.resolve?.(OFFICE_OPEN_DOCX);
+  } catch {
+    resolved = void 0;
+  }
+  return installedPackageVersion(OFFICE_OPEN_DOCX, import.meta.url, resolved);
+}
 async function createOfficeOpenDocxRenderer() {
   const backend = await import(
     /* @vite-ignore */
     OFFICE_OPEN_DOCX
   );
-  for (const name of [
-    "generateDocument",
-    "stringifyTableOfContents"
-  ]) {
-    if (typeof backend[name] !== "function") {
-      throw new Error(
-        `${OFFICE_OPEN_DOCX} does not export ${name}(); the installed version is not compatible with this adapter.`
-      );
-    }
+  assertBackendVersion(
+    OFFICE_OPEN_DOCX,
+    OFFICE_OPEN_VERSION,
+    installedBackendVersion()
+  );
+  if (typeof backend.generateDocument !== "function") {
+    throw new Error(
+      `${OFFICE_OPEN_DOCX} does not export generateDocument(); the installed version is not compatible with this adapter.`
+    );
   }
   return {
     id: OFFICE_OPEN_DOCX_RENDERER_ID,
     format: "docx",
     capabilities: OFFICE_OPEN_CAPABILITIES,
     async render(ir, options) {
-      const charts = [];
-      const cellTocs = [];
+      const charts2 = [];
       const document = await buildDocumentOptions(
         ir,
-        charts,
-        options?.svgRasterFallback,
-        cellTocs
+        charts2,
+        options?.svgRasterFallback
       );
       const bytes = await backend.generateDocument(document, {
         type: "uint8array"
@@ -5257,10 +6357,10 @@ async function createOfficeOpenDocxRenderer() {
       let raw = Buffer.from(
         bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)
       );
-      if (charts.length > 0 || cellTocs.length > 0) {
-        const zip = new AdmZip4(raw);
-        spliceChartParts(zip, charts);
-        spliceCellTocs(zip, cellTocs, backend.stringifyTableOfContents);
+      if (ir.theme || charts2.length > 0) {
+        const zip = new AdmZip5(raw);
+        if (ir.theme) spliceTheme(zip, ir.theme);
+        finishChartParts(zip, charts2);
         raw = zip.toBuffer();
       }
       if (options?.deterministic === false)
@@ -5277,13 +6377,12 @@ async function createOfficeOpenDocxRenderer() {
     }
   };
 }
-async function buildDocumentOptions(ir, charts = [], svgRasterFallback, cellTocs = []) {
+async function buildDocumentOptions(ir, charts2 = [], svgRasterFallback) {
   let nextDrawingId = 1;
   const ctx = {
     pictures: await prepareImages2(ir, svgRasterFallback),
     nextDrawingId: () => nextDrawingId++,
-    charts,
-    cellTocs
+    charts: charts2
   };
   return {
     styles: emitStyles2(ir.styles),
@@ -5291,16 +6390,20 @@ async function buildDocumentOptions(ir, charts = [], svgRasterFallback, cellTocs
       (value, index) => section(value, ctx, index === ir.sections.length - 1)
     ),
     ...coreProperties2(ir),
-    features: {
+    settings: {
       updateFields: ir.settings.updateFields,
       ...ir.settings.trackRevisions ? { trackRevisions: true } : {}
     },
-    ...ir.numbering.length > 0 ? { numbering: { config: ir.numbering.map(numberingConfig2) } } : {},
+    ...ir.numbering.length > 0 ? {
+      numbering: {
+        abstractNumberings: ir.numbering.map(numberingConfig2)
+      }
+    } : {},
     ...ir.footnotes.length > 0 ? { footnotes: noteBodies2(ir.footnotes, ctx) } : {},
     ...ir.endnotes.length > 0 ? { endnotes: noteBodies2(ir.endnotes, ctx) } : {},
     ...ir.comments.length > 0 ? {
-      comments: {
-        children: ir.comments.map((comment) => ({
+      comments: ir.comments.map(
+        (comment) => ({
           id: comment.id,
           author: comment.author,
           ...comment.initials ? { initials: comment.initials } : {},
@@ -5308,29 +6411,25 @@ async function buildDocumentOptions(ir, charts = [], svgRasterFallback, cellTocs
           children: comment.children.map(
             (child) => paragraphOf(child, ctx)
           )
-        }))
-      }
+        })
+      )
     } : {}
   };
 }
 function paragraphOf(value, ctx) {
   const emitted = block(value, ctx);
-  const asParagraph = emitted.paragraph;
-  if (!asParagraph) {
+  if (!("paragraph" in emitted) || typeof emitted.paragraph === "string") {
     throw new Error(
       `the office-open renderer expected a paragraph, not a "${value.kind}"`
     );
   }
-  return asParagraph;
+  return emitted.paragraph;
 }
 function noteBodies2(notes, ctx) {
-  const bodies = {};
-  for (const note of notes) {
-    bodies[String(note.id)] = {
-      children: note.children.map((child) => paragraphOf(child, ctx))
-    };
-  }
-  return bodies;
+  return notes.map((note) => ({
+    id: note.id,
+    children: note.children.map((child) => paragraphOf(child, ctx))
+  }));
 }
 async function prepareImages2(ir, svgRasterFallback) {
   const placements = collectImagePlacements2(ir);
@@ -5353,23 +6452,16 @@ async function prepareImages2(ir, svgRasterFallback) {
     if (resource.kind !== "image") continue;
     const type = resource.mediaType;
     const data = Buffer.from(resource.bytes);
-    const placementData = /* @__PURE__ */ new Map();
-    [...placements.get(resource.id) ?? []].forEach((size, index) => {
-      placementData.set(
-        size,
-        index === 0 ? data : distinguishImageBytes(data, type, size)
-      );
-    });
     resources.set(resource.id, (placement) => {
       const sizeKey = placementKey(placement);
       const stem = `${resource.id}-${sizeKey}`;
       return {
         type,
-        // @office-open/docx stores a drawing transformation on its deduplicated
-        // media entry. Equivalent bytes drawn at a second size would otherwise
-        // reuse the first size, so each distinct placement size gets equivalent
-        // image bytes carrying a harmless format-native marker.
-        data: placementData.get(sizeKey) ?? data,
+        // The same bytes at every size: the backend keeps each drawing's
+        // extent on the drawing. 0.11 kept it on its deduplicated media
+        // entry, and an image drawn at a second size took the first one's,
+        // unless its bytes were told apart.
+        data,
         // Named after the resource and the size it is drawn at, so two
         // placements of one image at one size share a single part and a third
         // at another size gets its own.
@@ -5392,104 +6484,6 @@ async function prepareImages2(ir, svgRasterFallback) {
 function placementKey(placement) {
   return `${emuToPixels(placement.widthEmu)}x${emuToPixels(placement.heightEmu)}`;
 }
-function distinguishImageBytes(data, mediaType, placement) {
-  const marker = Buffer.from(`json-to-office:${placement}`, "utf8");
-  switch (mediaType) {
-    case "png":
-      return addPngTextChunk(data, marker);
-    case "jpg":
-      return addJpegComment(data, marker);
-    case "gif":
-      return addGifComment(data, marker);
-    case "svg":
-      return Buffer.concat([
-        data,
-        Buffer.from(`
-<!-- ${marker.toString("utf8")} -->`, "utf8")
-      ]);
-    case "bmp": {
-      const marked = Buffer.concat([data, marker]);
-      if (marked.length >= 14 && marked.subarray(0, 2).toString("ascii") === "BM") {
-        marked.writeUInt32LE(marked.length, 2);
-      }
-      return marked;
-    }
-    default:
-      return Buffer.concat([data, marker]);
-  }
-}
-function addPngTextChunk(data, marker) {
-  const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
-  if (data.length < 8 || !data.subarray(0, 8).equals(signature)) {
-    return Buffer.concat([data, marker]);
-  }
-  let offset = 8;
-  while (offset + 12 <= data.length) {
-    const payloadLength = data.readUInt32BE(offset);
-    const chunkEnd = offset + 12 + payloadLength;
-    if (chunkEnd > data.length) break;
-    if (data.subarray(offset + 4, offset + 8).toString("ascii") === "IEND") {
-      const payload = Buffer.concat([
-        Buffer.from("json-to-office\0", "latin1"),
-        marker
-      ]);
-      const chunk = Buffer.alloc(12 + payload.length);
-      chunk.writeUInt32BE(payload.length, 0);
-      chunk.write("tEXt", 4, 4, "ascii");
-      payload.copy(chunk, 8);
-      chunk.writeUInt32BE(
-        crc32(chunk.subarray(4, 8 + payload.length)),
-        8 + payload.length
-      );
-      return Buffer.concat([
-        data.subarray(0, offset),
-        chunk,
-        data.subarray(offset)
-      ]);
-    }
-    offset = chunkEnd;
-  }
-  throw new Error(
-    "Cannot mark a PNG that has no intact IEND chunk; its bytes were not checked to decode before rendering"
-  );
-}
-function addJpegComment(data, marker) {
-  if (data.length < 2 || data[0] !== 255 || data[1] !== 216) {
-    return Buffer.concat([data, marker]);
-  }
-  const comment = Buffer.alloc(4 + marker.length);
-  comment[0] = 255;
-  comment[1] = 254;
-  comment.writeUInt16BE(marker.length + 2, 2);
-  marker.copy(comment, 4);
-  return Buffer.concat([data.subarray(0, 2), comment, data.subarray(2)]);
-}
-function addGifComment(data, marker) {
-  const trailer = data.lastIndexOf(59);
-  if (trailer < 0 || marker.length > 255) {
-    return Buffer.concat([data, marker]);
-  }
-  const comment = Buffer.concat([
-    Buffer.from([33, 254, marker.length]),
-    marker,
-    Buffer.from([0])
-  ]);
-  return Buffer.concat([
-    data.subarray(0, trailer),
-    comment,
-    data.subarray(trailer)
-  ]);
-}
-function crc32(data) {
-  let crc = 4294967295;
-  for (const byte of data) {
-    crc ^= byte;
-    for (let bit = 0; bit < 8; bit += 1) {
-      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
-    }
-  }
-  return (crc ^ 4294967295) >>> 0;
-}
 function collectImagePlacements2(ir) {
   const placements = /* @__PURE__ */ new Map();
   const record = (resourceId, placement) => {
@@ -5557,18 +6551,19 @@ function coreProperties2(ir) {
     ...metadata.custom?.length ? { customProperties: metadata.custom } : {}
   };
 }
-var OFFICE_OPEN_DOCX_RENDERER_ID, OFFICE_OPEN_DOCX, OFFICE_OPEN_CAPABILITIES;
+var OFFICE_OPEN_DOCX_RENDERER_ID, OFFICE_OPEN_DOCX, OFFICE_OPEN_VERSION, OFFICE_OPEN_CAPABILITIES;
 var init_office_open = __esm({
   "src/renderers/office-open/index.ts"() {
     "use strict";
     init_chartParts();
-    init_cellTocs();
+    init_themePart();
     init_imageUtils();
     init_packageDocument();
     init_emit2();
     init_styles3();
     OFFICE_OPEN_DOCX_RENDERER_ID = "office-open";
     OFFICE_OPEN_DOCX = "@office-open/docx";
+    OFFICE_OPEN_VERSION = "0.14.6";
     OFFICE_OPEN_CAPABILITIES = /* @__PURE__ */ new Set([
       "paragraphs",
       "styles",
@@ -9484,6 +10479,7 @@ function emptyToUndefined(formatting) {
 }
 
 // src/ir/compiler.ts
+init_chartValues();
 init_types();
 
 // src/ir/measure.ts
@@ -9516,6 +10512,49 @@ function tableWidthTwips(width, measureTwips) {
 
 // src/ir/compiler.ts
 init_units();
+
+// src/ir/theme.ts
+init_colorUtils();
+init_styleHelpers();
+init_types();
+var THEME_COLOR_TOKENS = [
+  ["dark1", "text"],
+  ["light1", "background"],
+  ["dark2", "textSecondary"],
+  ["light2", "backgroundSecondary"],
+  ["accent1", "primary"],
+  ["accent2", "secondary"],
+  ["accent3", "accent"],
+  ["accent4", "accent4"],
+  ["accent5", "accent5"],
+  ["accent6", "accent6"]
+];
+var NOT_XML_CHARS = new RegExp(NOT_XML_CHAR.source, "gu");
+var xmlText = (value) => (value ?? "").replace(NOT_XML_CHARS, "").trim();
+function compileTheme(theme, themeName) {
+  const colors = {};
+  for (const [slot, token] of THEME_COLOR_TOKENS) {
+    const hex = schemeHex(token, theme);
+    if (hex) colors[slot] = { hex };
+  }
+  const headingFont = xmlText(resolveFontFamily(theme, "heading"));
+  const bodyFont = xmlText(resolveFontFamily(theme, "body"));
+  return {
+    name: xmlText(theme.name) || xmlText(themeName) || "Office Theme",
+    colors,
+    ...headingFont ? { headingFont } : {},
+    ...bodyFont ? { bodyFont } : {}
+  };
+}
+function schemeHex(token, theme) {
+  try {
+    return resolveColor(token, theme);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/ir/compiler.ts
 var CONTENT_BOOKMARK_ID_BASE = 2e6;
 var SINGLE_LINE_TWIPS = 240;
 function compileDocument(structure, layout, warnings = [], images = /* @__PURE__ */ new Map(), options = {}) {
@@ -9581,6 +10620,7 @@ function compileDocument(structure, layout, warnings = [], images = /* @__PURE__
       trackRevisions: structure.trackRevisions === true,
       ...noProofWords(structure.theme) ? { noProofWords: noProofWords(structure.theme) } : {}
     },
+    theme: compileTheme(structure.theme, structure.themeName),
     // The statistic styles are appended rather than built with the rest: a
     // document that uses no statistic must keep the exact style set it had
     // before the component had styles, or every recorded golden moves for a
@@ -10349,14 +11389,6 @@ function compileShape2(props, children, scope) {
     );
   }
   const fill = style?.shading?.fill;
-  const dropOutline = Boolean(fill) && Boolean(outline.outline);
-  if (dropOutline) {
-    warnOnce(
-      ctx,
-      "text-box",
-      '[core-docx] text-box renderAs "shape" cannot carry a fill and a border at once (docx emits invalid shape properties); keeping the fill and dropping the border.'
-    );
-  }
   ctx.features.require("text-boxes", path3);
   if (props.floating) ctx.features.require("floating-images", path3);
   const insets = shapeInsets(
@@ -10375,7 +11407,7 @@ function compileShape2(props, children, scope) {
           heightPx: height.pixels,
           children,
           ...fill ? { fill: irColor(resolveColor(fill, ctx.theme)) } : {},
-          ...outline.outline && !dropOutline ? { outline: outline.outline } : {},
+          ...outline.outline ? { outline: outline.outline } : {},
           ...insets ? { insetsEmu: insets } : {},
           ...props.floating ? { floating: compileFloating(props.floating, ctx, path3) } : {}
         }
@@ -11598,6 +12630,7 @@ function compileImage2(component, scope) {
 }
 var DEFAULT_CHART_HEIGHT_INCHES = 3;
 var MAX_CHART_TEXT_POINTS = 10;
+var MIN_CHART_TEXT_POINTS = 1;
 function chartTextFont(theme) {
   const bodySize = getThemeFonts(theme).body?.size;
   let color = "000000";
@@ -11607,9 +12640,12 @@ function chartTextFont(theme) {
   }
   return {
     fontFamily: resolveFontFamily(theme, "body"),
-    fontSize: Math.min(
-      typeof bodySize === "number" && bodySize > 0 ? bodySize : 11,
-      MAX_CHART_TEXT_POINTS
+    fontSize: Math.max(
+      MIN_CHART_TEXT_POINTS,
+      Math.min(
+        typeof bodySize === "number" && bodySize > 0 ? bodySize : 11,
+        MAX_CHART_TEXT_POINTS
+      )
     ),
     bold: false,
     color
@@ -11620,7 +12656,7 @@ function compileChart(component, scope) {
   const props = component.props ?? {};
   if (props.type === "bubble") {
     throw new Error(
-      `Chart at ${path3} is a bubble chart, which no docx renderer draws; use the pptx \`chart\` component on the pptxgenjs renderer for one.`
+      `Chart at ${path3} is a bubble chart, but the docx \`chart\` component has no bubble sizes; use the pptx \`chart\` component on the pptxgenjs renderer.`
     );
   }
   const rawSeries = Array.isArray(props.data) ? props.data : [];
@@ -11642,10 +12678,22 @@ function compileChart(component, scope) {
         `Chart series "${label}" at ${path3} has ${labels.length} labels and ${values.length} values; they must be the same length.`
       );
     }
+    if (labels.length === 0) {
+      throw new Error(
+        `Chart series "${label}" at ${path3} has no data points; give it at least one label and value.`
+      );
+    }
+    const numbers = values.map((value) => Number(value));
+    const bad = numbers.findIndex((value) => !Number.isFinite(value));
+    if (bad !== -1) {
+      throw new Error(
+        `Chart series "${label}" at ${path3} has a value that is not a finite number (${JSON.stringify(values[bad])} at "${String(labels[bad])}").`
+      );
+    }
     return {
       ...typeof raw.name === "string" ? { name: raw.name } : {},
       labels: labels.map((value) => String(value)),
-      values: values.map((value) => Number(value))
+      values: numbers
     };
   });
   const categories = series[0].labels;
@@ -11657,6 +12705,44 @@ function compileChart(component, scope) {
       );
     }
   }
+  if (props.type === "pie" && series.length > 1) {
+    throw new Error(
+      `Chart at ${path3} is a pie with ${series.length} series; a pie draws one series. Use a doughnut for one ring per series, or a column chart to compare them.`
+    );
+  }
+  if (props.type === "pie" || props.type === "doughnut") {
+    for (const [index, entry] of series.entries()) {
+      const at = entry.values.findIndex((value) => value < 0);
+      if (at === -1) continue;
+      throw new Error(
+        `Chart series "${entry.name ?? `series ${index}`}" at ${path3} has a negative value (${entry.values[at]} at "${entry.labels[at]}"); a ${props.type} chart draws each value as a share of the whole.`
+      );
+    }
+  }
+  if (props.type === "scatter") {
+    for (const [index, entry] of series.entries()) {
+      const at = entry.labels.findIndex(isOutOfRangeNumericLabel);
+      if (at !== -1) {
+        throw new Error(
+          `Chart series "${entry.name ?? `series ${index}`}" at ${path3} has an x label ${JSON.stringify(entry.labels[at])} outside the finite number range.`
+        );
+      }
+    }
+  }
+  if (props.type === "scatter" && series.some((entry) => entry.labels.some((label) => !isNumericLabel(label)))) {
+    warnOnce(
+      ctx,
+      "chart",
+      `Chart at ${path3} is a scatter chart whose labels are not all finite numbers; labels that do not read as finite numbers use their 1-based positions for x.`
+    );
+  }
+  if ((props.type === "pie" || props.type === "doughnut") && (typeof props.catAxisTitle === "string" || typeof props.valAxisTitle === "string")) {
+    warnOnce(
+      ctx,
+      "chart",
+      `Chart at ${path3} is a ${props.type} chart, which has no axes; its axis titles are not drawn.`
+    );
+  }
   const colors = Array.isArray(props.chartColors) ? props.chartColors.map(
     (color) => resolveColor(String(color), ctx.theme)
   ) : chartPaletteValues(ctx.theme).flatMap((value) => {
@@ -11669,13 +12755,21 @@ function compileChart(component, scope) {
   const contentWidthInches = scope.measureTwips / 1440;
   const widthInches = typeof props.width === "number" ? props.width : contentWidthInches;
   const heightInches = typeof props.height === "number" ? props.height : DEFAULT_CHART_HEIGHT_INCHES;
+  const widthEmu = inchesToEmu(widthInches);
+  const heightEmu = inchesToEmu(heightInches);
+  if (!(widthEmu > 0 && heightEmu > 0)) {
+    const inches = (value) => String(Number.isFinite(value) ? Math.round(value * 100) / 100 : value);
+    throw new Error(
+      `Chart at ${path3} has no room: it would be ${inches(widthInches)}\xD7${inches(heightInches)} in. Set \`width\`/\`height\`, or give it a container with space.`
+    );
+  }
   const chart = {
     kind: "chart",
     chartType: props.type,
     series,
     colors,
-    widthEmu: inchesToEmu(widthInches),
-    heightEmu: inchesToEmu(heightInches),
+    widthEmu,
+    heightEmu,
     ...typeof props.title === "string" ? { title: props.title } : {},
     ...props.showTitle !== void 0 ? { showTitle: props.showTitle } : {},
     ...props.showLegend !== void 0 ? { showLegend: props.showLegend } : {},
@@ -11878,7 +12972,7 @@ function compileFrame(floating, ctx, path3) {
 function compileFloating(floating, ctx, path3) {
   if (floating.wrap?.type === "tight") {
     throw new Error(
-      "Image floating wrap.type 'tight' is not supported due to invalid OOXML emitted by docx. Use 'square', 'topAndBottom', or 'none'."
+      "Image floating wrap.type 'tight' is not supported. Use 'square', 'topAndBottom', or 'none'."
     );
   }
   const hRelative = floating.horizontalPosition?.relative;