@superdoc-dev/cli 0.2.0-next.106 → 0.2.0-next.107

package/dist/index.js

@@ -37760,7 +37760,7 @@ var init_remark_gfm_z_sDF4ss_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-Cx2VynBq.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-BDyjQdwB.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -48346,6 +48346,182 @@ function parseRelativeHeight(value) {
     return null;
   return isValidRelativeHeight(parsed) ? parsed : null;
 }
+function normalizeChartTarget(target) {
+  let cleaned = target;
+  if (cleaned.startsWith("/"))
+    cleaned = cleaned.slice(1);
+  if (cleaned.startsWith("./"))
+    cleaned = cleaned.slice(2);
+  while (cleaned.startsWith("../"))
+    cleaned = cleaned.slice(3);
+  if (!cleaned.startsWith("word/"))
+    cleaned = `word/${cleaned}`;
+  return cleaned;
+}
+function resolveChartPart(docx, chartRelId, filename) {
+  if (!chartRelId || !docx)
+    return null;
+  const chartRel = findChild(docx[`word/_rels/${filename || "document.xml"}.rels`] || docx["word/_rels/document.xml.rels"], "Relationships")?.elements?.find((el) => getAttr(el, "Id") === chartRelId);
+  if (!chartRel)
+    return null;
+  const target = getAttr(chartRel, "Target");
+  if (!target)
+    return null;
+  return {
+    chartPartPath: normalizeChartTarget(target),
+    chartRel
+  };
+}
+function parseChartXml(chartXml) {
+  const chartSpace = chartXml?.name === "c:chartSpace" ? chartXml : findChild(chartXml, "c:chartSpace");
+  const chart = findChild(chartSpace, "c:chart");
+  if (!chart)
+    return null;
+  const plotArea = findChild(chart, "c:plotArea");
+  if (!plotArea)
+    return null;
+  const chartTypeEntry = findChartTypeElement(plotArea);
+  if (!chartTypeEntry)
+    return null;
+  const { element: chartTypeEl, chartType } = chartTypeEntry;
+  const subType = extractGrouping(chartTypeEl);
+  const barDirection = extractBarDirection(chartTypeEl);
+  const series = parseSeries(chartTypeEl, chartType);
+  const categoryAxis = parseAxis(plotArea, "c:catAx");
+  const valueAxis = parseAxis(plotArea, "c:valAx");
+  const legendPosition = parseLegendPosition(chart);
+  const styleId = parseStyleId(chartSpace);
+  return {
+    chartType,
+    ...subType && { subType },
+    ...barDirection && { barDirection },
+    series,
+    ...categoryAxis && { categoryAxis },
+    ...valueAxis && { valueAxis },
+    ...legendPosition && { legendPosition },
+    ...styleId != null && { styleId }
+  };
+}
+function findChartTypeElement(plotArea) {
+  for (const el of plotArea.elements || [])
+    if (CHART_TYPE_NAMES.has(el.name))
+      return {
+        element: el,
+        chartType: CHART_TYPE_MAP[el.name]
+      };
+  for (const el of plotArea.elements || [])
+    if (el.name?.startsWith("c:") && el.name.endsWith("Chart"))
+      return {
+        element: el,
+        chartType: el.name.replace("c:", "")
+      };
+  return null;
+}
+function extractGrouping(chartTypeEl) {
+  return getAttr(findChild(chartTypeEl, "c:grouping"), "val") || undefined;
+}
+function extractBarDirection(chartTypeEl) {
+  const val = getAttr(findChild(chartTypeEl, "c:barDir"), "val");
+  return val === "col" || val === "bar" ? val : undefined;
+}
+function parseSeries(chartTypeEl, chartType) {
+  return findChildren$1(chartTypeEl, "c:ser").map((seriesEl) => parseOneSeries(seriesEl, chartType));
+}
+function parseOneSeries(serEl, chartType) {
+  const name = extractSeriesName(serEl);
+  const categories = extractCachedStrings(findChild(serEl, "c:cat"));
+  const values = extractCachedNumbers(findChild(serEl, "c:val"));
+  const xValues = extractCachedNumbers(findChild(serEl, "c:xVal"));
+  const yValues = extractCachedNumbers(findChild(serEl, "c:yVal"));
+  const bubbleSizes = extractCachedNumbers(findChild(serEl, "c:bubbleSize"));
+  if (chartType === "scatterChart" || chartType === "bubbleChart") {
+    const parsedCategoryValues = categories.map((value) => Number(value));
+    const numericCategoryValues = parsedCategoryValues.every((value) => Number.isFinite(value)) ? parsedCategoryValues : [];
+    const seriesXValues = xValues.length ? xValues : numericCategoryValues;
+    const seriesYValues = yValues.length ? yValues : values;
+    return {
+      name,
+      categories: categories.length ? categories : seriesXValues.map((value, index2) => formatChartLabel(value, index2 + 1)),
+      values: seriesYValues,
+      ...seriesXValues.length ? { xValues: seriesXValues } : {},
+      ...chartType === "bubbleChart" && bubbleSizes.length ? { bubbleSizes } : {}
+    };
+  }
+  return {
+    name,
+    categories,
+    values
+  };
+}
+function formatChartLabel(value, fallbackIndex) {
+  if (!Number.isFinite(value))
+    return `Category ${fallbackIndex}`;
+  if (Number.isInteger(value))
+    return String(value);
+  return String(Number(value.toFixed(3)));
+}
+function extractSeriesName(serEl) {
+  return findChild(findChild(findChild(findChild(findChild(serEl, "c:tx"), "c:strRef"), "c:strCache"), "c:pt"), "c:v")?.elements?.[0]?.text ?? `Series ${getAttr(findChild(serEl, "c:idx"), "val") ?? ""}`.trim();
+}
+function extractCachedStrings(parentEl) {
+  if (!parentEl)
+    return [];
+  const strCache = findChild(findChild(parentEl, "c:strRef"), "c:strCache");
+  const numCache = findChild(findChild(parentEl, "c:numRef"), "c:numCache");
+  const cache = strCache || numCache;
+  if (!cache)
+    return [];
+  return findChildren$1(cache, "c:pt").sort((a, b) => (Number(getAttr(a, "idx")) || 0) - (Number(getAttr(b, "idx")) || 0)).map((pt) => findChild(pt, "c:v")?.elements?.[0]?.text ?? "");
+}
+function extractCachedNumbers(parentEl) {
+  if (!parentEl)
+    return [];
+  const numCache = findChild(findChild(parentEl, "c:numRef"), "c:numCache");
+  if (!numCache)
+    return [];
+  return findChildren$1(numCache, "c:pt").sort((a, b) => (Number(getAttr(a, "idx")) || 0) - (Number(getAttr(b, "idx")) || 0)).map((pt) => {
+    const text$2 = findChild(pt, "c:v")?.elements?.[0]?.text;
+    const num = Number(text$2);
+    return Number.isFinite(num) ? num : 0;
+  });
+}
+function parseAxis(plotArea, axisName) {
+  const axis = findChild(plotArea, axisName);
+  if (!axis)
+    return;
+  const title = extractAxisTitle(findChild(axis, "c:title"));
+  const orientation = getAttr(findChild(findChild(axis, "c:scaling"), "c:orientation"), "val");
+  const config$39 = {};
+  if (title)
+    config$39.title = title;
+  if (orientation === "minMax" || orientation === "maxMin")
+    config$39.orientation = orientation;
+  return Object.keys(config$39).length > 0 ? config$39 : undefined;
+}
+function extractAxisTitle(titleEl) {
+  if (!titleEl)
+    return;
+  return findChild(findChild(findChild(findChild(findChild(titleEl, "c:tx"), "c:rich"), "a:p"), "a:r"), "a:t")?.elements?.[0]?.text || undefined;
+}
+function parseLegendPosition(chart) {
+  const legend = findChild(chart, "c:legend");
+  if (!legend)
+    return;
+  return getAttr(findChild(legend, "c:legendPos"), "val") || undefined;
+}
+function parseStyleId(chartSpace) {
+  const altContent = findChild(chartSpace, "mc:AlternateContent");
+  if (altContent) {
+    const val$1 = getAttr(findChild(findChild(altContent, "mc:Choice"), "c14:style"), "val");
+    if (val$1 != null)
+      return Number(val$1);
+    const fallbackVal = getAttr(findChild(findChild(altContent, "mc:Fallback"), "c:style"), "val");
+    if (fallbackVal != null)
+      return Number(fallbackVal);
+  }
+  const val = getAttr(findChild(chartSpace, "c:style"), "val");
+  return val != null ? Number(val) : undefined;
+}
 function handleImageNode(node3, params, isAnchor) {
   if (!node3)
     return null;
@@ -48479,6 +48655,8 @@ function handleImageNode(node3, params, isAnchor) {
       horizontal: positionHValue,
       top: positionVValue
     }, anchorData, wrap$1, isHidden);
+  if (uri === "http://schemas.openxmlformats.org/drawingml/2006/chart")
+    return handleChartDrawing(params, node3, graphicData, size, padding, marginOffset, anchorData, wrap$1, isAnchor);
   const picture = graphicData?.elements.find((el) => el.name === "pic:pic");
   if (!picture || !picture.elements)
     return null;
@@ -55607,6 +55785,8 @@ function decode$46(params) {
     return null;
   if (node3.attrs.isPict)
     return null;
+  if (node3.type === "chart" && node3.attrs.originalXml)
+    return wrapTextInRun(carbonCopy(node3.attrs.originalXml), []);
   return wrapTextInRun({
     name: "w:drawing",
     elements: [(node3.attrs.isAnchor ? translator$197 : translator$198).decode(params)]
@@ -58320,6 +58500,7 @@ function exportSchemaToJson(params) {
     contentBlock: translator$27,
     vectorShape: translateVectorShape,
     shapeGroup: translateShapeGroup,
+    chart: translator$10,
     structuredContent: translator$7,
     structuredContentBlock: translator$7,
     documentPartObject: translator$7,
@@ -66728,7 +66909,7 @@ var isRegExp = (value) => {
     i2++;
   }
   return { processedNodes };
-}, HEADER_FOOTER_FILENAME_PATTERN, DRAWING_XML_TAG = "w:drawing", SHAPE_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape", GROUP_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup", SD_IMAGE_ID_NAMESPACE = "7c9e6679-7425-40de-944b-e07fc1f90ae7", normalizeTargetPath$1 = (targetPath = "") => {
+}, HEADER_FOOTER_FILENAME_PATTERN, CHART_TYPE_MAP, CHART_TYPE_NAMES, findChild = (node3, name) => node3?.elements?.find((el) => el.name === name), findChildren$1 = (node3, name) => node3?.elements?.filter((el) => el.name === name) ?? [], getAttr = (node3, attr) => node3?.attributes?.[attr], DRAWING_XML_TAG = "w:drawing", SHAPE_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape", GROUP_URI = "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup", SD_IMAGE_ID_NAMESPACE = "7c9e6679-7425-40de-944b-e07fc1f90ae7", normalizeTargetPath$1 = (targetPath = "") => {
   if (!targetPath)
     return targetPath;
   const trimmed = targetPath.replace(/^\/+/, "");
@@ -67005,6 +67186,39 @@ var isRegExp = (value) => {
       originalAttributes: node3?.attributes
     }
   };
+}, handleChartDrawing = (params, node3, graphicData, size, padding, marginOffset, anchorData, wrap$1, isAnchor) => {
+  const chartRelId = graphicData?.elements?.find((el) => el.name === "c:chart")?.attributes?.["r:id"];
+  if (!chartRelId)
+    return null;
+  const { docx, filename } = params;
+  const resolved = resolveChartPart(docx, chartRelId, filename);
+  if (!resolved)
+    return null;
+  const { chartPartPath } = resolved;
+  const chartXml = docx[chartPartPath];
+  const chartData = chartXml ? parseChartXml(chartXml) : null;
+  const drawingNode = params.nodes?.[0];
+  const { order: order2, originalChildren } = collectPreservedDrawingChildren(node3);
+  return {
+    type: "chart",
+    attrs: {
+      width: size.width || 400,
+      height: size.height || 300,
+      chartData,
+      chartRelId,
+      chartPartPath,
+      isAnchor,
+      anchorData,
+      wrap: wrap$1,
+      padding,
+      marginOffset,
+      originalAttributes: node3?.attributes,
+      originalChildren,
+      originalChildOrder: order2,
+      originalXml: drawingNode ? carbonCopy(drawingNode) : null,
+      drawingContent: drawingNode || null
+    }
+  };
 }, buildShapePlaceholder = (node3, size, padding, marginOffset, shapeType) => {
   const attrs = {
     drawingContent: {
@@ -72817,7 +73031,7 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_Cx2VynBq_es = __esm(() => {
+var init_SuperConverter_BDyjQdwB_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_DLE8mr0n_es();
@@ -97932,6 +98146,26 @@ var init_SuperConverter_Cx2VynBq_es = __esm(() => {
   SKIP_FIELD_PROCESSING_NODE_NAMES$1 = new Set(["w:drawing", "w:pict"]);
   SKIP_FIELD_PROCESSING_NODE_NAMES = new Set(["w:drawing", "w:pict"]);
   HEADER_FOOTER_FILENAME_PATTERN = /^(header|footer)\d*\.xml$/i;
+  CHART_TYPE_MAP = {
+    "c:barChart": "barChart",
+    "c:bar3DChart": "barChart",
+    "c:lineChart": "lineChart",
+    "c:line3DChart": "lineChart",
+    "c:pieChart": "pieChart",
+    "c:pie3DChart": "pieChart",
+    "c:ofPieChart": "ofPieChart",
+    "c:areaChart": "areaChart",
+    "c:area3DChart": "areaChart",
+    "c:scatterChart": "scatterChart",
+    "c:bubbleChart": "bubbleChart",
+    "c:bubble3DChart": "bubbleChart",
+    "c:doughnutChart": "doughnutChart",
+    "c:radarChart": "radarChart",
+    "c:stockChart": "stockChart",
+    "c:surfaceChart": "surfaceChart",
+    "c:surface3DChart": "surfaceChart"
+  };
+  CHART_TYPE_NAMES = new Set(Object.keys(CHART_TYPE_MAP));
   init_dist();
   DEFAULT_ALLOWED_PROTOCOLS = [
     "http",
@@ -132185,9 +132419,9 @@ var init_remark_gfm_CjV8kaUy_es = __esm(() => {
   init_remark_gfm_z_sDF4ss_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-CJCOedws.es.js
-var exports_src_CJCOedws_es = {};
-__export(exports_src_CJCOedws_es, {
+// ../../packages/superdoc/dist/chunks/src-asiscfsz.es.js
+var exports_src_asiscfsz_es = {};
+__export(exports_src_asiscfsz_es, {
   zt: () => defineMark,
   z: () => cM,
   yt: () => removeAwarenessStates,
@@ -140530,11 +140764,11 @@ function ensureSectPrElement(current) {
     return cloneXmlElement(current);
   return createSectPrElement();
 }
-function findChild(element3, childName) {
+function findChild2(element3, childName) {
   return element3.elements?.find((entry) => entry?.name === childName);
 }
 function ensureChild(element3, childName) {
-  const existing = findChild(element3, childName);
+  const existing = findChild2(element3, childName);
   if (existing)
     return existing;
   const created = {
@@ -140587,7 +140821,7 @@ function writeSectPrBreakType(sectPr, breakType) {
   setStringAttr(ensureChild(sectPr, "w:type"), "w:val", breakType);
 }
 function readSectPrMargins(sectPr) {
-  const pgMar = findChild(sectPr, "w:pgMar");
+  const pgMar = findChild2(sectPr, "w:pgMar");
   if (!pgMar)
     return {};
   return {
@@ -140621,7 +140855,7 @@ function writeSectPrHeaderFooterMargins(sectPr, margins) {
     setStringAttr(pgMar, "w:footer", toTwipsString(margins.footer));
 }
 function readSectPrPageSetup(sectPr) {
-  const pgSz = findChild(sectPr, "w:pgSz");
+  const pgSz = findChild2(sectPr, "w:pgSz");
   if (!pgSz)
     return;
   const width = toInchesFromTwips(pgSz.attributes?.["w:w"]);
@@ -140660,7 +140894,7 @@ function writeSectPrPageSetup(sectPr, setup) {
   }
 }
 function readSectPrColumns(sectPr) {
-  const cols = findChild(sectPr, "w:cols");
+  const cols = findChild2(sectPr, "w:cols");
   if (!cols)
     return;
   const count = toPositiveInteger(cols.attributes?.["w:num"]);
@@ -140684,7 +140918,7 @@ function writeSectPrColumns(sectPr, columns) {
     setBooleanAttr(cols, "w:equalWidth", columns.equalWidth);
 }
 function readSectPrLineNumbering(sectPr) {
-  const lnNumType = findChild(sectPr, "w:lnNumType");
+  const lnNumType = findChild2(sectPr, "w:lnNumType");
   if (!lnNumType)
     return;
   const restartRaw = asString$1(lnNumType.attributes?.["w:restart"]);
@@ -140713,7 +140947,7 @@ function writeSectPrLineNumbering(sectPr, numbering) {
     setStringAttr(lnNumType, "w:restart", numbering.restart);
 }
 function readSectPrPageNumbering(sectPr) {
-  const pgNumType = findChild(sectPr, "w:pgNumType");
+  const pgNumType = findChild2(sectPr, "w:pgNumType");
   if (!pgNumType)
     return;
   const formatRaw = asString$1(pgNumType.attributes?.["w:fmt"]);
@@ -140743,14 +140977,14 @@ function writeSectPrTitlePage(sectPr, enabled) {
   removeChildren(sectPr, (entry) => entry.name === "w:titlePg");
 }
 function readSectPrVerticalAlign(sectPr) {
-  const raw = asString$1(findChild(sectPr, "w:vAlign")?.attributes?.["w:val"]);
+  const raw = asString$1(findChild2(sectPr, "w:vAlign")?.attributes?.["w:val"]);
   return isKnownValue(raw, SECTION_VERTICAL_ALIGN_VALUES) ? raw : undefined;
 }
 function writeSectPrVerticalAlign(sectPr, value) {
   setStringAttr(ensureChild(sectPr, "w:vAlign"), "w:val", value);
 }
 function readSectPrDirection(sectPr) {
-  const bidi = findChild(sectPr, "w:bidi");
+  const bidi = findChild2(sectPr, "w:bidi");
   if (!bidi)
     return;
   return toBooleanAttr(bidi.attributes?.["w:val"]) === false ? "ltr" : "rtl";
@@ -140837,13 +141071,13 @@ function writeBorderSpec(parent, edge, border) {
     setBooleanAttr(edgeElement, "w:frame", border.frame);
 }
 function readSectPrPageBorders(sectPr) {
-  const pgBorders = findChild(sectPr, "w:pgBorders");
+  const pgBorders = findChild2(sectPr, "w:pgBorders");
   if (!pgBorders)
     return;
-  const top$1 = readBorderSpec(findChild(pgBorders, "w:top"));
-  const right$1 = readBorderSpec(findChild(pgBorders, "w:right"));
-  const bottom$1 = readBorderSpec(findChild(pgBorders, "w:bottom"));
-  const left$1 = readBorderSpec(findChild(pgBorders, "w:left"));
+  const top$1 = readBorderSpec(findChild2(pgBorders, "w:top"));
+  const right$1 = readBorderSpec(findChild2(pgBorders, "w:right"));
+  const bottom$1 = readBorderSpec(findChild2(pgBorders, "w:bottom"));
+  const left$1 = readBorderSpec(findChild2(pgBorders, "w:left"));
   const display = toPageBorderDisplay(pgBorders.attributes?.["w:display"]);
   const offsetFrom = toPageBorderOffsetFrom(pgBorders.attributes?.["w:offsetFrom"]);
   const zOrder = toPageBorderZOrder(pgBorders.attributes?.["w:zOrder"]);
@@ -164591,6 +164825,994 @@ function k0(t) {
 ${o}
 </svg>`;
 }
+function createChartElement(doc$2, chartData, geometry) {
+  const container = doc$2.createElement("div");
+  container.classList.add("superdoc-chart");
+  container.style.width = "100%";
+  container.style.height = "100%";
+  container.style.position = "relative";
+  if (!chartData || !chartData.series?.length)
+    return createChartPlaceholder(doc$2, container, "No chart data");
+  if (chartData.chartType === "barChart")
+    return renderBarChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "lineChart")
+    return renderLineChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "stockChart")
+    return renderLineChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "areaChart")
+    return renderAreaChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "scatterChart")
+    return renderScatterChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "bubbleChart")
+    return renderBubbleChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "radarChart")
+    return renderRadarChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "pieChart")
+    return renderPieChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "doughnutChart")
+    return renderDoughnutChart(doc$2, container, chartData, geometry);
+  if (chartData.chartType === "ofPieChart")
+    return renderPieChart(doc$2, container, chartData, geometry);
+  return createChartPlaceholder(doc$2, container, `Chart: ${chartData.chartType}`);
+}
+function createChartPlaceholder(doc$2, container, label) {
+  container.style.display = "flex";
+  container.style.alignItems = "center";
+  container.style.justifyContent = "center";
+  container.style.background = PLACEHOLDER_BG;
+  container.style.border = `1px solid ${PLACEHOLDER_BORDER}`;
+  container.style.borderRadius = "4px";
+  container.style.color = PLACEHOLDER_TEXT_COLOR;
+  container.style.fontSize = "13px";
+  container.style.fontFamily = FONT_FAMILY;
+  const icon = doc$2.createElement("span");
+  icon.textContent = "\uD83D\uDCCA ";
+  container.appendChild(icon);
+  const text5 = doc$2.createElement("span");
+  text5.textContent = label;
+  container.appendChild(text5);
+  return container;
+}
+function formatTickValue(value) {
+  if (Math.abs(value) >= 1e6)
+    return `${(value / 1e6).toFixed(1)}M`;
+  if (Math.abs(value) >= 1000)
+    return `${(value / 1000).toFixed(1)}K`;
+  return Number.isInteger(value) ? String(value) : value.toFixed(1);
+}
+function applyGuardrails(chart) {
+  let truncated = false;
+  let series = chart.series;
+  if (series.length > MAX_RENDERED_SERIES) {
+    series = series.slice(0, MAX_RENDERED_SERIES);
+    truncated = true;
+  }
+  series = series.map((s2) => {
+    if (s2.values.length <= MAX_POINTS_PER_SERIES && s2.categories.length <= MAX_POINTS_PER_SERIES)
+      return s2;
+    truncated = true;
+    return {
+      name: s2.name,
+      categories: s2.categories.slice(0, MAX_POINTS_PER_SERIES),
+      values: s2.values.slice(0, MAX_POINTS_PER_SERIES),
+      ...s2.xValues && { xValues: s2.xValues.slice(0, MAX_POINTS_PER_SERIES) },
+      ...s2.bubbleSizes && { bubbleSizes: s2.bubbleSizes.slice(0, MAX_POINTS_PER_SERIES) }
+    };
+  });
+  return {
+    series,
+    truncated
+  };
+}
+function computeBarLayout(width, height, series) {
+  const plotWidth = Math.max(1, width - CHART_PADDING.left - CHART_PADDING.right);
+  const plotHeight = Math.max(1, height - CHART_PADDING.top - CHART_PADDING.bottom);
+  const allValues = series.flatMap((s2) => s2.values);
+  const maxValue = Math.max(0, ...allValues);
+  const minValue = Math.min(0, ...allValues);
+  const valueRange = Math.max(1, maxValue - minValue);
+  const categories = series[0]?.categories ?? [];
+  const categoryCount = Math.max(1, categories.length);
+  const seriesCount = series.length;
+  const groupWidth = plotWidth / categoryCount;
+  const barGap = Math.max(1, groupWidth * 0.1);
+  const totalBarWidth = groupWidth - barGap * 2;
+  return {
+    plotWidth,
+    plotHeight,
+    groupWidth,
+    barWidth: Math.max(1, totalBarWidth / seriesCount),
+    barGap,
+    baselineY: CHART_PADDING.top + plotHeight * (maxValue / valueRange),
+    valueRange,
+    minValue,
+    maxValue
+  };
+}
+function renderBars(doc$2, svg2, series, layout) {
+  const { groupWidth, barGap, barWidth, baselineY, valueRange, plotHeight } = layout;
+  for (let si = 0;si < series.length; si++) {
+    const s2 = series[si];
+    const color2 = SERIES_COLORS[si % SERIES_COLORS.length];
+    for (let ci = 0;ci < s2.values.length; ci++) {
+      const value = s2.values[ci];
+      const barHeight = Math.abs(value / valueRange) * plotHeight;
+      const x = CHART_PADDING.left + ci * groupWidth + barGap + si * barWidth;
+      const y$1 = value >= 0 ? baselineY - barHeight : baselineY;
+      const rect = doc$2.createElementNS(SVG_NS, "rect");
+      rect.setAttribute("x", String(x));
+      rect.setAttribute("y", String(y$1));
+      rect.setAttribute("width", String(barWidth));
+      rect.setAttribute("height", String(Math.max(0.5, barHeight)));
+      rect.setAttribute("fill", color2);
+      svg2.appendChild(rect);
+    }
+  }
+}
+function renderAxes(doc$2, svg2, layout) {
+  const { plotWidth, plotHeight, baselineY } = layout;
+  const vAxis = doc$2.createElementNS(SVG_NS, "line");
+  vAxis.setAttribute("x1", String(CHART_PADDING.left));
+  vAxis.setAttribute("y1", String(CHART_PADDING.top));
+  vAxis.setAttribute("x2", String(CHART_PADDING.left));
+  vAxis.setAttribute("y2", String(CHART_PADDING.top + plotHeight));
+  vAxis.setAttribute("stroke", AXIS_COLOR);
+  vAxis.setAttribute("stroke-width", "1");
+  svg2.appendChild(vAxis);
+  const hAxis = doc$2.createElementNS(SVG_NS, "line");
+  hAxis.setAttribute("x1", String(CHART_PADDING.left));
+  hAxis.setAttribute("y1", String(baselineY));
+  hAxis.setAttribute("x2", String(CHART_PADDING.left + plotWidth));
+  hAxis.setAttribute("y2", String(baselineY));
+  hAxis.setAttribute("stroke", AXIS_COLOR);
+  hAxis.setAttribute("stroke-width", "1");
+  svg2.appendChild(hAxis);
+}
+function renderCategoryLabels(doc$2, svg2, categories, layout, width) {
+  const { groupWidth, plotHeight } = layout;
+  const categoryCount = Math.max(1, categories.length);
+  const fontSize$1 = Math.max(8, Math.min(12, width / categoryCount / 5));
+  for (let ci = 0;ci < categories.length; ci++) {
+    const labelX = CHART_PADDING.left + ci * groupWidth + groupWidth / 2;
+    const label = doc$2.createElementNS(SVG_NS, "text");
+    label.setAttribute("x", String(labelX));
+    label.setAttribute("y", String(CHART_PADDING.top + plotHeight + 16));
+    label.setAttribute("text-anchor", "middle");
+    label.setAttribute("font-size", String(fontSize$1));
+    label.setAttribute("fill", LABEL_COLOR);
+    label.setAttribute("font-family", FONT_FAMILY);
+    label.textContent = categories[ci] ?? "";
+    svg2.appendChild(label);
+  }
+}
+function renderValueTicks(doc$2, svg2, layout, height) {
+  const { plotWidth, plotHeight, valueRange, minValue } = layout;
+  const tickStep = valueRange / VALUE_TICK_COUNT;
+  const fontSize$1 = Math.max(8, Math.min(11, height / 30));
+  for (let i$1 = 0;i$1 <= VALUE_TICK_COUNT; i$1++) {
+    const tickValue = minValue + tickStep * i$1;
+    const tickY = CHART_PADDING.top + plotHeight - plotHeight * (tickValue - minValue) / valueRange;
+    const label = doc$2.createElementNS(SVG_NS, "text");
+    label.setAttribute("x", String(CHART_PADDING.left - 6));
+    label.setAttribute("y", String(tickY + 3));
+    label.setAttribute("text-anchor", "end");
+    label.setAttribute("font-size", String(fontSize$1));
+    label.setAttribute("fill", TICK_LABEL_COLOR);
+    label.setAttribute("font-family", FONT_FAMILY);
+    label.textContent = formatTickValue(tickValue);
+    svg2.appendChild(label);
+    if (i$1 > 0 && i$1 < VALUE_TICK_COUNT) {
+      const gridLine = doc$2.createElementNS(SVG_NS, "line");
+      gridLine.setAttribute("x1", String(CHART_PADDING.left));
+      gridLine.setAttribute("y1", String(tickY));
+      gridLine.setAttribute("x2", String(CHART_PADDING.left + plotWidth));
+      gridLine.setAttribute("y2", String(tickY));
+      gridLine.setAttribute("stroke", GRID_COLOR);
+      gridLine.setAttribute("stroke-width", "0.5");
+      svg2.appendChild(gridLine);
+    }
+  }
+}
+function renderLegend(doc$2, svg2, series, height) {
+  const legendY = height - 12;
+  let legendX = CHART_PADDING.left;
+  for (let si = 0;si < series.length; si++) {
+    const s2 = series[si];
+    const color2 = SERIES_COLORS[si % SERIES_COLORS.length];
+    const swatch = doc$2.createElementNS(SVG_NS, "rect");
+    swatch.setAttribute("x", String(legendX));
+    swatch.setAttribute("y", String(legendY - 8));
+    swatch.setAttribute("width", "10");
+    swatch.setAttribute("height", "10");
+    swatch.setAttribute("fill", color2);
+    svg2.appendChild(swatch);
+    const label = doc$2.createElementNS(SVG_NS, "text");
+    label.setAttribute("x", String(legendX + 14));
+    label.setAttribute("y", String(legendY));
+    label.setAttribute("font-size", "10");
+    label.setAttribute("fill", LABEL_COLOR);
+    label.setAttribute("font-family", FONT_FAMILY);
+    label.textContent = s2.name;
+    svg2.appendChild(label);
+    legendX += 14 + s2.name.length * 6 + 16;
+  }
+}
+function renderTruncationIndicator(doc$2, svg2, width) {
+  const indicator = doc$2.createElementNS(SVG_NS, "text");
+  indicator.setAttribute("x", String(width - 8));
+  indicator.setAttribute("y", "14");
+  indicator.setAttribute("text-anchor", "end");
+  indicator.setAttribute("font-size", "10");
+  indicator.setAttribute("fill", PLACEHOLDER_TEXT_COLOR);
+  indicator.setAttribute("font-family", FONT_FAMILY);
+  indicator.textContent = "Data truncated for display";
+  svg2.appendChild(indicator);
+}
+function toCartesianLayout(width, height, series, forceZeroMin = false) {
+  const plotWidth = Math.max(1, width - CHART_PADDING.left - CHART_PADDING.right);
+  const plotHeight = Math.max(1, height - CHART_PADDING.top - CHART_PADDING.bottom);
+  const values = series.flatMap((s2) => s2.values).filter((v) => Number.isFinite(v));
+  let minValue = values.length ? Math.min(...values) : 0;
+  let maxValue = values.length ? Math.max(...values) : 1;
+  if (forceZeroMin) {
+    minValue = Math.min(0, minValue);
+    maxValue = Math.max(0, maxValue);
+  }
+  if (maxValue === minValue) {
+    minValue -= 1;
+    maxValue += 1;
+  }
+  const valueRange = Math.max(1, maxValue - minValue);
+  const zeroRatio = (0 - minValue) / valueRange;
+  const baselineRatio = Math.max(0, Math.min(1, zeroRatio));
+  const baselineY = CHART_PADDING.top + plotHeight - plotHeight * baselineRatio;
+  const categoryCount = Math.max(1, series[0]?.categories?.length ?? series[0]?.values?.length ?? 1);
+  return {
+    plotWidth,
+    plotHeight,
+    minValue,
+    maxValue,
+    valueRange,
+    baselineY,
+    categoryCount
+  };
+}
+function pointX(layout, index2) {
+  if (layout.categoryCount <= 1)
+    return CHART_PADDING.left + layout.plotWidth / 2;
+  return CHART_PADDING.left + layout.plotWidth * index2 / (layout.categoryCount - 1);
+}
+function pointY(layout, value) {
+  return CHART_PADDING.top + layout.plotHeight - (value - layout.minValue) / layout.valueRange * layout.plotHeight;
+}
+function renderCartesianAxes(doc$2, svg2, layout) {
+  const vAxis = doc$2.createElementNS(SVG_NS, "line");
+  vAxis.setAttribute("x1", String(CHART_PADDING.left));
+  vAxis.setAttribute("y1", String(CHART_PADDING.top));
+  vAxis.setAttribute("x2", String(CHART_PADDING.left));
+  vAxis.setAttribute("y2", String(CHART_PADDING.top + layout.plotHeight));
+  vAxis.setAttribute("stroke", AXIS_COLOR);
+  vAxis.setAttribute("stroke-width", "1");
+  svg2.appendChild(vAxis);
+  const hAxis = doc$2.createElementNS(SVG_NS, "line");
+  hAxis.setAttribute("x1", String(CHART_PADDING.left));
+  hAxis.setAttribute("y1", String(layout.baselineY));
+  hAxis.setAttribute("x2", String(CHART_PADDING.left + layout.plotWidth));
+  hAxis.setAttribute("y2", String(layout.baselineY));
+  hAxis.setAttribute("stroke", AXIS_COLOR);
+  hAxis.setAttribute("stroke-width", "1");
+  svg2.appendChild(hAxis);
+}
+function renderPointCategoryLabels(doc$2, svg2, categories, layout, width) {
+  const labels = categories.length ? categories : Array.from({ length: layout.categoryCount }, (_$1, i$1) => String(i$1 + 1));
+  const categoryCount = Math.max(1, labels.length);
+  const fontSize$1 = Math.max(8, Math.min(12, width / categoryCount / 4));
+  for (let i$1 = 0;i$1 < labels.length; i$1++) {
+    const label = doc$2.createElementNS(SVG_NS, "text");
+    label.setAttribute("x", String(pointX(layout, i$1)));
+    label.setAttribute("y", String(CHART_PADDING.top + layout.plotHeight + 16));
+    label.setAttribute("text-anchor", "middle");
+    label.setAttribute("font-size", String(fontSize$1));
+    label.setAttribute("fill", LABEL_COLOR);
+    label.setAttribute("font-family", FONT_FAMILY);
+    label.textContent = labels[i$1] ?? "";
+    svg2.appendChild(label);
+  }
+}
+function renderCartesianValueTicks(doc$2, svg2, layout, height) {
+  const tickStep = layout.valueRange / VALUE_TICK_COUNT;
+  const fontSize$1 = Math.max(8, Math.min(11, height / 30));
+  for (let i$1 = 0;i$1 <= VALUE_TICK_COUNT; i$1++) {
+    const tickValue = layout.minValue + tickStep * i$1;
+    const tickY = CHART_PADDING.top + layout.plotHeight - layout.plotHeight * (tickValue - layout.minValue) / layout.valueRange;
+    const label = doc$2.createElementNS(SVG_NS, "text");
+    label.setAttribute("x", String(CHART_PADDING.left - 6));
+    label.setAttribute("y", String(tickY + 3));
+    label.setAttribute("text-anchor", "end");
+    label.setAttribute("font-size", String(fontSize$1));
+    label.setAttribute("fill", TICK_LABEL_COLOR);
+    label.setAttribute("font-family", FONT_FAMILY);
+    label.textContent = formatTickValue(tickValue);
+    svg2.appendChild(label);
+    if (i$1 > 0 && i$1 < VALUE_TICK_COUNT) {
+      const grid = doc$2.createElementNS(SVG_NS, "line");
+      grid.setAttribute("x1", String(CHART_PADDING.left));
+      grid.setAttribute("y1", String(tickY));
+      grid.setAttribute("x2", String(CHART_PADDING.left + layout.plotWidth));
+      grid.setAttribute("y2", String(tickY));
+      grid.setAttribute("stroke", GRID_COLOR);
+      grid.setAttribute("stroke-width", "0.5");
+      svg2.appendChild(grid);
+    }
+  }
+}
+function toXYPoints(series) {
+  const yValues = series.values;
+  const xValues = series.xValues?.length ? series.xValues : yValues.map((_$1, index2) => index2 + 1);
+  const sizes = series.bubbleSizes ?? [];
+  const count = Math.min(xValues.length, yValues.length);
+  const points = [];
+  for (let i$1 = 0;i$1 < count; i$1++) {
+    const x = xValues[i$1];
+    const y$1 = yValues[i$1];
+    if (!Number.isFinite(x) || !Number.isFinite(y$1))
+      continue;
+    const size$2 = sizes[i$1];
+    points.push({
+      x,
+      y: y$1,
+      ...Number.isFinite(size$2) ? { size: size$2 } : {}
+    });
+  }
+  return points;
+}
+function toXYLayout(width, height, points, forceZeroMin = false) {
+  const plotWidth = Math.max(1, width - CHART_PADDING.left - CHART_PADDING.right);
+  const plotHeight = Math.max(1, height - CHART_PADDING.top - CHART_PADDING.bottom);
+  let minX = points.length ? Math.min(...points.map((point5) => point5.x)) : 0;
+  let maxX = points.length ? Math.max(...points.map((point5) => point5.x)) : 1;
+  let minY = points.length ? Math.min(...points.map((point5) => point5.y)) : 0;
+  let maxY = points.length ? Math.max(...points.map((point5) => point5.y)) : 1;
+  if (forceZeroMin) {
+    minX = Math.min(0, minX);
+    maxX = Math.max(0, maxX);
+    minY = Math.min(0, minY);
+    maxY = Math.max(0, maxY);
+  }
+  if (maxX === minX) {
+    minX -= 1;
+    maxX += 1;
+  }
+  if (maxY === minY) {
+    minY -= 1;
+    maxY += 1;
+  }
+  const xRange = Math.max(1, maxX - minX);
+  const yRange = Math.max(1, maxY - minY);
+  const axisXRatio = Math.max(0, Math.min(1, (0 - minX) / xRange));
+  const axisYRatio = Math.max(0, Math.min(1, (0 - minY) / yRange));
+  const axisX = CHART_PADDING.left + plotWidth * axisXRatio;
+  const axisY = CHART_PADDING.top + plotHeight - plotHeight * axisYRatio;
+  return {
+    plotWidth,
+    plotHeight,
+    minX,
+    maxX,
+    xRange,
+    minY,
+    maxY,
+    yRange,
+    axisX,
+    axisY
+  };
+}
+function xyToSvgX(layout, xValue) {
+  return CHART_PADDING.left + (xValue - layout.minX) / layout.xRange * layout.plotWidth;
+}
+function xyToSvgY(layout, yValue) {
+  return CHART_PADDING.top + layout.plotHeight - (yValue - layout.minY) / layout.yRange * layout.plotHeight;
+}
+function renderXYAxes(doc$2, svg2, layout) {
+  const yAxis = doc$2.createElementNS(SVG_NS, "line");
+  yAxis.setAttribute("x1", String(layout.axisX));
+  yAxis.setAttribute("y1", String(CHART_PADDING.top));
+  yAxis.setAttribute("x2", String(layout.axisX));
+  yAxis.setAttribute("y2", String(CHART_PADDING.top + layout.plotHeight));
+  yAxis.setAttribute("stroke", AXIS_COLOR);
+  yAxis.setAttribute("stroke-width", "1");
+  svg2.appendChild(yAxis);
+  const xAxis = doc$2.createElementNS(SVG_NS, "line");
+  xAxis.setAttribute("x1", String(CHART_PADDING.left));
+  xAxis.setAttribute("y1", String(layout.axisY));
+  xAxis.setAttribute("x2", String(CHART_PADDING.left + layout.plotWidth));
+  xAxis.setAttribute("y2", String(layout.axisY));
+  xAxis.setAttribute("stroke", AXIS_COLOR);
+  xAxis.setAttribute("stroke-width", "1");
+  svg2.appendChild(xAxis);
+}
+function renderXYTicks(doc$2, svg2, layout, height) {
+  const fontSize$1 = Math.max(8, Math.min(11, height / 30));
+  for (let i$1 = 0;i$1 <= VALUE_TICK_COUNT; i$1++) {
+    const tickRatio = i$1 / VALUE_TICK_COUNT;
+    const yValue = layout.minY + layout.yRange * tickRatio;
+    const y$1 = CHART_PADDING.top + layout.plotHeight - layout.plotHeight * tickRatio;
+    const yLabel = doc$2.createElementNS(SVG_NS, "text");
+    yLabel.setAttribute("x", String(CHART_PADDING.left - 6));
+    yLabel.setAttribute("y", String(y$1 + 3));
+    yLabel.setAttribute("text-anchor", "end");
+    yLabel.setAttribute("font-size", String(fontSize$1));
+    yLabel.setAttribute("fill", TICK_LABEL_COLOR);
+    yLabel.setAttribute("font-family", FONT_FAMILY);
+    yLabel.textContent = formatTickValue(yValue);
+    svg2.appendChild(yLabel);
+    if (i$1 > 0 && i$1 < VALUE_TICK_COUNT) {
+      const grid = doc$2.createElementNS(SVG_NS, "line");
+      grid.setAttribute("x1", String(CHART_PADDING.left));
+      grid.setAttribute("y1", String(y$1));
+      grid.setAttribute("x2", String(CHART_PADDING.left + layout.plotWidth));
+      grid.setAttribute("y2", String(y$1));
+      grid.setAttribute("stroke", GRID_COLOR);
+      grid.setAttribute("stroke-width", "0.5");
+      svg2.appendChild(grid);
+    }
+    const xValue = layout.minX + layout.xRange * tickRatio;
+    const x = CHART_PADDING.left + layout.plotWidth * tickRatio;
+    const xLabel = doc$2.createElementNS(SVG_NS, "text");
+    xLabel.setAttribute("x", String(x));
+    xLabel.setAttribute("y", String(CHART_PADDING.top + layout.plotHeight + 16));
+    xLabel.setAttribute("text-anchor", "middle");
+    xLabel.setAttribute("font-size", String(fontSize$1));
+    xLabel.setAttribute("fill", TICK_LABEL_COLOR);
+    xLabel.setAttribute("font-family", FONT_FAMILY);
+    xLabel.textContent = formatTickValue(xValue);
+    svg2.appendChild(xLabel);
+  }
+}
+function estimateScatterBubbleElements(pointsBySeries, hasLegend) {
+  const points = pointsBySeries.reduce((sum, seriesPoints) => sum + seriesPoints.length, 0);
+  const axes = 2;
+  const ticks = (VALUE_TICK_COUNT + 1) * 2;
+  const gridLines = Math.max(0, VALUE_TICK_COUNT - 1);
+  const legend = hasLegend ? pointsBySeries.length * 2 : 0;
+  return points + axes + ticks + gridLines + legend;
+}
+function renderScatterChart(doc$2, container, chart, geometry) {
+  const { width, height } = geometry;
+  const { series, truncated } = applyGuardrails(chart);
+  const pointsBySeries = series.map(toXYPoints);
+  const allPoints = pointsBySeries.flat();
+  if (allPoints.length === 0)
+    return createChartPlaceholder(doc$2, container, "No chart data");
+  const hasLegend = chart.legendPosition !== undefined;
+  const estimated = estimateScatterBubbleElements(pointsBySeries, hasLegend);
+  if (estimated > SVG_ELEMENT_BUDGET)
+    return createChartPlaceholder(doc$2, container, `Chart too complex for inline rendering (${estimated} elements)`);
+  const layout = toXYLayout(width, height, allPoints, false);
+  const svg2 = doc$2.createElementNS(SVG_NS, "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg2.setAttribute("width", "100%");
+  svg2.setAttribute("height", "100%");
+  svg2.style.display = "block";
+  renderXYAxes(doc$2, svg2, layout);
+  renderXYTicks(doc$2, svg2, layout, height);
+  for (let si = 0;si < pointsBySeries.length; si++) {
+    const points = pointsBySeries[si];
+    const color2 = SERIES_COLORS[si % SERIES_COLORS.length];
+    for (const point5 of points) {
+      const marker = doc$2.createElementNS(SVG_NS, "circle");
+      marker.setAttribute("cx", String(xyToSvgX(layout, point5.x)));
+      marker.setAttribute("cy", String(xyToSvgY(layout, point5.y)));
+      marker.setAttribute("r", "3");
+      marker.setAttribute("fill", color2);
+      marker.setAttribute("fill-opacity", "0.85");
+      svg2.appendChild(marker);
+    }
+  }
+  if (hasLegend)
+    renderLegend(doc$2, svg2, series, height);
+  if (truncated)
+    renderTruncationIndicator(doc$2, svg2, width);
+  container.appendChild(svg2);
+  return container;
+}
+function renderBubbleChart(doc$2, container, chart, geometry) {
+  const { width, height } = geometry;
+  const { series, truncated } = applyGuardrails(chart);
+  const pointsBySeries = series.map(toXYPoints);
+  const allPoints = pointsBySeries.flat();
+  if (allPoints.length === 0)
+    return createChartPlaceholder(doc$2, container, "No chart data");
+  const hasLegend = chart.legendPosition !== undefined;
+  const estimated = estimateScatterBubbleElements(pointsBySeries, hasLegend);
+  if (estimated > SVG_ELEMENT_BUDGET)
+    return createChartPlaceholder(doc$2, container, `Chart too complex for inline rendering (${estimated} elements)`);
+  const layout = toXYLayout(width, height, allPoints, false);
+  const allSizes = allPoints.map((point5) => point5.size).filter((size$2) => size$2 != null && size$2 > 0);
+  const maxBubbleSize = allSizes.length ? Math.max(...allSizes) : 1;
+  const svg2 = doc$2.createElementNS(SVG_NS, "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg2.setAttribute("width", "100%");
+  svg2.setAttribute("height", "100%");
+  svg2.style.display = "block";
+  renderXYAxes(doc$2, svg2, layout);
+  renderXYTicks(doc$2, svg2, layout, height);
+  for (let si = 0;si < pointsBySeries.length; si++) {
+    const points = pointsBySeries[si];
+    const color2 = SERIES_COLORS[si % SERIES_COLORS.length];
+    for (const point5 of points) {
+      const size$2 = point5.size && point5.size > 0 ? point5.size : maxBubbleSize * 0.5;
+      const radius = maxBubbleSize > 0 ? 4 + size$2 / maxBubbleSize * 10 : 6;
+      const bubble = doc$2.createElementNS(SVG_NS, "circle");
+      bubble.setAttribute("cx", String(xyToSvgX(layout, point5.x)));
+      bubble.setAttribute("cy", String(xyToSvgY(layout, point5.y)));
+      bubble.setAttribute("r", String(Math.max(2, radius)));
+      bubble.setAttribute("fill", color2);
+      bubble.setAttribute("fill-opacity", "0.45");
+      bubble.setAttribute("stroke", color2);
+      bubble.setAttribute("stroke-width", "1");
+      svg2.appendChild(bubble);
+    }
+  }
+  if (hasLegend)
+    renderLegend(doc$2, svg2, series, height);
+  if (truncated)
+    renderTruncationIndicator(doc$2, svg2, width);
+  container.appendChild(svg2);
+  return container;
+}
+function estimateRadarElements(series, categoryCount, hasLegend) {
+  const grid = 4 + categoryCount;
+  const labels = categoryCount;
+  const seriesElements = series.reduce((sum, s2) => sum + 1 + Math.min(categoryCount, s2.values.length), 0);
+  const legend = hasLegend ? series.length * 2 : 0;
+  return grid + labels + seriesElements + legend;
+}
+function renderRadarChart(doc$2, container, chart, geometry) {
+  const { width, height } = geometry;
+  const { series, truncated } = applyGuardrails(chart);
+  const categories = series[0]?.categories ?? [];
+  const categoryCount = Math.max(3, categories.length, ...series.map((oneSeries) => oneSeries.values.length));
+  const hasLegend = chart.legendPosition !== undefined;
+  const estimated = estimateRadarElements(series, categoryCount, hasLegend);
+  if (estimated > SVG_ELEMENT_BUDGET)
+    return createChartPlaceholder(doc$2, container, `Chart too complex for inline rendering (${estimated} elements)`);
+  const allValues = series.flatMap((oneSeries) => oneSeries.values).filter((value) => Number.isFinite(value));
+  const maxValue = allValues.length ? Math.max(...allValues) : 1;
+  const minValue = allValues.length ? Math.min(...allValues) : 0;
+  const valueRange = Math.max(1, maxValue - Math.min(0, minValue));
+  const svg2 = doc$2.createElementNS(SVG_NS, "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg2.setAttribute("width", "100%");
+  svg2.setAttribute("height", "100%");
+  svg2.style.display = "block";
+  const legendSpace = hasLegend ? 34 : 10;
+  const radius = Math.max(10, Math.min(width - 60, height - legendSpace - 60) / 2);
+  const centerX = width / 2;
+  const centerY = CHART_PADDING.top + (height - CHART_PADDING.top - legendSpace) / 2;
+  const ringCount = 4;
+  for (let ring = 1;ring <= ringCount; ring++) {
+    const ringRadius = radius * ring / ringCount;
+    const ringPoints = [];
+    for (let i$1 = 0;i$1 < categoryCount; i$1++) {
+      const angle = -Math.PI / 2 + i$1 * Math.PI * 2 / categoryCount;
+      ringPoints.push(`${centerX + ringRadius * Math.cos(angle)},${centerY + ringRadius * Math.sin(angle)}`);
+    }
+    const polygon = doc$2.createElementNS(SVG_NS, "polygon");
+    polygon.setAttribute("points", ringPoints.join(" "));
+    polygon.setAttribute("fill", "none");
+    polygon.setAttribute("stroke", GRID_COLOR);
+    polygon.setAttribute("stroke-width", "0.8");
+    svg2.appendChild(polygon);
+  }
+  for (let i$1 = 0;i$1 < categoryCount; i$1++) {
+    const angle = -Math.PI / 2 + i$1 * Math.PI * 2 / categoryCount;
+    const x = centerX + radius * Math.cos(angle);
+    const y$1 = centerY + radius * Math.sin(angle);
+    const spoke = doc$2.createElementNS(SVG_NS, "line");
+    spoke.setAttribute("x1", String(centerX));
+    spoke.setAttribute("y1", String(centerY));
+    spoke.setAttribute("x2", String(x));
+    spoke.setAttribute("y2", String(y$1));
+    spoke.setAttribute("stroke", GRID_COLOR);
+    spoke.setAttribute("stroke-width", "0.8");
+    svg2.appendChild(spoke);
+    const labelRadius = radius + 14;
+    const labelX = centerX + labelRadius * Math.cos(angle);
+    const labelY = centerY + labelRadius * Math.sin(angle);
+    const label = doc$2.createElementNS(SVG_NS, "text");
+    label.setAttribute("x", String(labelX));
+    label.setAttribute("y", String(labelY));
+    label.setAttribute("font-size", "10");
+    label.setAttribute("fill", LABEL_COLOR);
+    label.setAttribute("font-family", FONT_FAMILY);
+    label.setAttribute("text-anchor", Math.abs(Math.cos(angle)) < 0.2 ? "middle" : Math.cos(angle) > 0 ? "start" : "end");
+    label.textContent = categories[i$1] ?? `Category ${i$1 + 1}`;
+    svg2.appendChild(label);
+  }
+  for (let si = 0;si < series.length; si++) {
+    const oneSeries = series[si];
+    const color2 = SERIES_COLORS[si % SERIES_COLORS.length];
+    const points = [];
+    const pointPositions = [];
+    const pointCount = Math.min(categoryCount, oneSeries.values.length);
+    for (let i$1 = 0;i$1 < pointCount; i$1++) {
+      const value = oneSeries.values[i$1] ?? 0;
+      const pointRadius = Math.max(0, (value - Math.min(0, minValue)) / valueRange) * radius;
+      const angle = -Math.PI / 2 + i$1 * Math.PI * 2 / categoryCount;
+      const x = centerX + pointRadius * Math.cos(angle);
+      const y$1 = centerY + pointRadius * Math.sin(angle);
+      points.push(`${x},${y$1}`);
+      pointPositions.push({
+        x,
+        y: y$1
+      });
+    }
+    if (points.length > 0) {
+      const polygon = doc$2.createElementNS(SVG_NS, "polygon");
+      polygon.setAttribute("points", points.join(" "));
+      polygon.setAttribute("fill", color2);
+      polygon.setAttribute("fill-opacity", "0.18");
+      polygon.setAttribute("stroke", color2);
+      polygon.setAttribute("stroke-width", "1.8");
+      svg2.appendChild(polygon);
+    }
+    for (const point5 of pointPositions) {
+      const marker = doc$2.createElementNS(SVG_NS, "circle");
+      marker.setAttribute("cx", String(point5.x));
+      marker.setAttribute("cy", String(point5.y));
+      marker.setAttribute("r", "2.5");
+      marker.setAttribute("fill", color2);
+      svg2.appendChild(marker);
+    }
+  }
+  if (hasLegend)
+    renderLegend(doc$2, svg2, series, height);
+  if (truncated)
+    renderTruncationIndicator(doc$2, svg2, width);
+  container.appendChild(svg2);
+  return container;
+}
+function estimateLineAreaElements(series, categories, hasLegend, withMarkers) {
+  const points = series.reduce((sum, s2) => sum + s2.values.length, 0);
+  const pathPerSeries = series.length;
+  const markerCount = withMarkers ? points : 0;
+  const axes = 2;
+  const valueTicks = (VALUE_TICK_COUNT + 1) * 2;
+  const categoryLabels = categories.length;
+  const legend = hasLegend ? series.length * 2 : 0;
+  return pathPerSeries + markerCount + axes + valueTicks + categoryLabels + legend;
+}
+function normalizePieSlices(series) {
+  let truncated = false;
+  const maxCount = Math.min(series.values.length, MAX_POINTS_PER_SERIES);
+  if (series.values.length > maxCount)
+    truncated = true;
+  const slices = [];
+  for (let i$1 = 0;i$1 < maxCount; i$1++) {
+    const raw = Number(series.values[i$1]);
+    const value = Number.isFinite(raw) && raw > 0 ? raw : 0;
+    slices.push({
+      label: series.categories[i$1] ?? `Category ${i$1 + 1}`,
+      value,
+      color: SERIES_COLORS[i$1 % SERIES_COLORS.length]
+    });
+  }
+  return {
+    slices,
+    truncated
+  };
+}
+function renderPieSlices(doc$2, svg2, slices, centerX, centerY, radius) {
+  const total = slices.reduce((sum, slice2) => sum + slice2.value, 0);
+  if (total <= 0)
+    return;
+  let start$1 = -Math.PI / 2;
+  for (const slice2 of slices) {
+    if (slice2.value <= 0)
+      continue;
+    const sweep = slice2.value / total * Math.PI * 2;
+    if (sweep >= Math.PI * 2 - 0.0001) {
+      const full = doc$2.createElementNS(SVG_NS, "circle");
+      full.setAttribute("cx", String(centerX));
+      full.setAttribute("cy", String(centerY));
+      full.setAttribute("r", String(radius));
+      full.setAttribute("fill", slice2.color);
+      full.setAttribute("stroke", "#fff");
+      full.setAttribute("stroke-width", String(Math.max(1, radius * 0.01)));
+      svg2.appendChild(full);
+      break;
+    }
+    const end$1 = start$1 + sweep;
+    const x1 = centerX + radius * Math.cos(start$1);
+    const y1 = centerY + radius * Math.sin(start$1);
+    const x2 = centerX + radius * Math.cos(end$1);
+    const y2 = centerY + radius * Math.sin(end$1);
+    const largeArc = sweep > Math.PI ? 1 : 0;
+    const path2 = doc$2.createElementNS(SVG_NS, "path");
+    path2.setAttribute("d", `M ${centerX} ${centerY} L ${x1} ${y1} A ${radius} ${radius} 0 ${largeArc} 1 ${x2} ${y2} Z`);
+    path2.setAttribute("fill", slice2.color);
+    path2.setAttribute("stroke", "#fff");
+    path2.setAttribute("stroke-width", String(Math.max(1, radius * 0.01)));
+    svg2.appendChild(path2);
+    start$1 = end$1;
+  }
+}
+function renderPieLegend(doc$2, svg2, slices, width, height) {
+  const totalWidth = slices.reduce((acc, slice2) => acc + 14 + slice2.label.length * 6 + 16, 0);
+  let legendX = Math.max(10, (width - totalWidth) / 2);
+  const legendY = height - 14;
+  for (const slice2 of slices) {
+    const swatch = doc$2.createElementNS(SVG_NS, "rect");
+    swatch.setAttribute("x", String(legendX));
+    swatch.setAttribute("y", String(legendY - 8));
+    swatch.setAttribute("width", "10");
+    swatch.setAttribute("height", "10");
+    swatch.setAttribute("fill", slice2.color);
+    svg2.appendChild(swatch);
+    const label = doc$2.createElementNS(SVG_NS, "text");
+    label.setAttribute("x", String(legendX + 14));
+    label.setAttribute("y", String(legendY));
+    label.setAttribute("font-size", "10");
+    label.setAttribute("fill", LABEL_COLOR);
+    label.setAttribute("font-family", FONT_FAMILY);
+    label.textContent = slice2.label;
+    svg2.appendChild(label);
+    legendX += 14 + slice2.label.length * 6 + 16;
+  }
+}
+function renderPieChart(doc$2, container, chart, geometry) {
+  const series = chart.series[0];
+  if (!series)
+    return createChartPlaceholder(doc$2, container, "No chart data");
+  const { slices, truncated } = normalizePieSlices(series);
+  if (slices.reduce((sum, slice2) => sum + slice2.value, 0) <= 0)
+    return createChartPlaceholder(doc$2, container, "No chart data");
+  if (slices.length * 3 > SVG_ELEMENT_BUDGET)
+    return createChartPlaceholder(doc$2, container, "Chart too large");
+  const { width, height } = geometry;
+  const hasLegend = chart.legendPosition !== undefined;
+  const title = series.name?.trim() || "";
+  const hasTitle = title.length > 0;
+  const titleSpace = hasTitle ? 34 : 10;
+  const legendSpace = hasLegend ? 40 : 10;
+  const plotWidth = Math.max(1, width - 20);
+  const plotHeight = Math.max(1, height - titleSpace - legendSpace);
+  const centerX = width / 2;
+  const centerY = titleSpace + plotHeight / 2;
+  const radius = Math.max(8, Math.min(plotWidth, plotHeight) * 0.45);
+  const svg2 = doc$2.createElementNS(SVG_NS, "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg2.setAttribute("width", "100%");
+  svg2.setAttribute("height", "100%");
+  svg2.style.display = "block";
+  if (hasTitle) {
+    const titleEl = doc$2.createElementNS(SVG_NS, "text");
+    titleEl.setAttribute("x", String(centerX));
+    titleEl.setAttribute("y", "24");
+    titleEl.setAttribute("text-anchor", "middle");
+    titleEl.setAttribute("font-size", String(Math.max(12, Math.min(22, width / 18))));
+    titleEl.setAttribute("fill", AXIS_COLOR);
+    titleEl.setAttribute("font-family", FONT_FAMILY);
+    titleEl.textContent = title;
+    svg2.appendChild(titleEl);
+  }
+  renderPieSlices(doc$2, svg2, slices, centerX, centerY, radius);
+  if (hasLegend)
+    renderPieLegend(doc$2, svg2, slices, width, height);
+  if (truncated)
+    renderTruncationIndicator(doc$2, svg2, width);
+  container.appendChild(svg2);
+  return container;
+}
+function renderLineChart(doc$2, container, chart, geometry) {
+  const { width, height } = geometry;
+  const { series, truncated } = applyGuardrails(chart);
+  const categories = series[0]?.categories ?? [];
+  const hasLegend = chart.legendPosition !== undefined;
+  const estimated = estimateLineAreaElements(series, categories, hasLegend, true);
+  if (estimated > SVG_ELEMENT_BUDGET)
+    return createChartPlaceholder(doc$2, container, `Chart too complex for inline rendering (${estimated} elements)`);
+  const layout = toCartesianLayout(width, height, series, false);
+  const svg2 = doc$2.createElementNS(SVG_NS, "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg2.setAttribute("width", "100%");
+  svg2.setAttribute("height", "100%");
+  svg2.style.display = "block";
+  renderCartesianAxes(doc$2, svg2, layout);
+  renderCartesianValueTicks(doc$2, svg2, layout, height);
+  renderPointCategoryLabels(doc$2, svg2, categories, layout, width);
+  for (let si = 0;si < series.length; si++) {
+    const s2 = series[si];
+    const color2 = SERIES_COLORS[si % SERIES_COLORS.length];
+    const points = [];
+    for (let i$1 = 0;i$1 < s2.values.length; i$1++) {
+      const x = pointX(layout, i$1);
+      const y$1 = pointY(layout, s2.values[i$1] ?? 0);
+      points.push(`${x},${y$1}`);
+    }
+    if (points.length === 0)
+      continue;
+    const line = doc$2.createElementNS(SVG_NS, "polyline");
+    line.setAttribute("points", points.join(" "));
+    line.setAttribute("fill", "none");
+    line.setAttribute("stroke", color2);
+    line.setAttribute("stroke-width", "2");
+    svg2.appendChild(line);
+    for (let i$1 = 0;i$1 < s2.values.length; i$1++) {
+      const marker = doc$2.createElementNS(SVG_NS, "circle");
+      marker.setAttribute("cx", String(pointX(layout, i$1)));
+      marker.setAttribute("cy", String(pointY(layout, s2.values[i$1] ?? 0)));
+      marker.setAttribute("r", "2.5");
+      marker.setAttribute("fill", color2);
+      svg2.appendChild(marker);
+    }
+  }
+  if (hasLegend)
+    renderLegend(doc$2, svg2, series, height);
+  if (truncated)
+    renderTruncationIndicator(doc$2, svg2, width);
+  container.appendChild(svg2);
+  return container;
+}
+function renderAreaChart(doc$2, container, chart, geometry) {
+  const { width, height } = geometry;
+  const { series, truncated } = applyGuardrails(chart);
+  const categories = series[0]?.categories ?? [];
+  const hasLegend = chart.legendPosition !== undefined;
+  const estimated = estimateLineAreaElements(series, categories, hasLegend, false) + series.length;
+  if (estimated > SVG_ELEMENT_BUDGET)
+    return createChartPlaceholder(doc$2, container, `Chart too complex for inline rendering (${estimated} elements)`);
+  const layout = toCartesianLayout(width, height, series, true);
+  const svg2 = doc$2.createElementNS(SVG_NS, "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg2.setAttribute("width", "100%");
+  svg2.setAttribute("height", "100%");
+  svg2.style.display = "block";
+  renderCartesianAxes(doc$2, svg2, layout);
+  renderCartesianValueTicks(doc$2, svg2, layout, height);
+  renderPointCategoryLabels(doc$2, svg2, categories, layout, width);
+  for (let si = 0;si < series.length; si++) {
+    const s2 = series[si];
+    if (s2.values.length === 0)
+      continue;
+    const color2 = SERIES_COLORS[si % SERIES_COLORS.length];
+    const pathParts = [`M ${pointX(layout, 0)} ${layout.baselineY}`];
+    for (let i$1 = 0;i$1 < s2.values.length; i$1++)
+      pathParts.push(`L ${pointX(layout, i$1)} ${pointY(layout, s2.values[i$1] ?? 0)}`);
+    const lastX = pointX(layout, Math.max(0, s2.values.length - 1));
+    pathParts.push(`L ${lastX} ${layout.baselineY} Z`);
+    const area = doc$2.createElementNS(SVG_NS, "path");
+    area.setAttribute("d", pathParts.join(" "));
+    area.setAttribute("fill", color2);
+    area.setAttribute("fill-opacity", "0.35");
+    area.setAttribute("stroke", color2);
+    area.setAttribute("stroke-width", "1.5");
+    svg2.appendChild(area);
+  }
+  if (hasLegend)
+    renderLegend(doc$2, svg2, series, height);
+  if (truncated)
+    renderTruncationIndicator(doc$2, svg2, width);
+  container.appendChild(svg2);
+  return container;
+}
+function renderDoughnutSlices(doc$2, svg2, slices, centerX, centerY, outerRadius, innerRadius) {
+  const total = slices.reduce((sum, slice2) => sum + slice2.value, 0);
+  if (total <= 0)
+    return;
+  let start$1 = -Math.PI / 2;
+  for (const slice2 of slices) {
+    if (slice2.value <= 0)
+      continue;
+    const sweep = slice2.value / total * Math.PI * 2;
+    if (sweep >= Math.PI * 2 - 0.0001) {
+      const ring = doc$2.createElementNS(SVG_NS, "circle");
+      ring.setAttribute("cx", String(centerX));
+      ring.setAttribute("cy", String(centerY));
+      ring.setAttribute("r", String((outerRadius + innerRadius) / 2));
+      ring.setAttribute("fill", "none");
+      ring.setAttribute("stroke", slice2.color);
+      ring.setAttribute("stroke-width", String(Math.max(1, outerRadius - innerRadius)));
+      svg2.appendChild(ring);
+      break;
+    }
+    const end$1 = start$1 + sweep;
+    const x1 = centerX + outerRadius * Math.cos(start$1);
+    const y1 = centerY + outerRadius * Math.sin(start$1);
+    const x2 = centerX + outerRadius * Math.cos(end$1);
+    const y2 = centerY + outerRadius * Math.sin(end$1);
+    const ix1 = centerX + innerRadius * Math.cos(start$1);
+    const iy1 = centerY + innerRadius * Math.sin(start$1);
+    const ix2 = centerX + innerRadius * Math.cos(end$1);
+    const iy2 = centerY + innerRadius * Math.sin(end$1);
+    const largeArc = sweep > Math.PI ? 1 : 0;
+    const path2 = doc$2.createElementNS(SVG_NS, "path");
+    path2.setAttribute("d", `M ${x1} ${y1} A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${x2} ${y2} L ${ix2} ${iy2} A ${innerRadius} ${innerRadius} 0 ${largeArc} 0 ${ix1} ${iy1} Z`);
+    path2.setAttribute("fill", slice2.color);
+    path2.setAttribute("stroke", "#fff");
+    path2.setAttribute("stroke-width", "1");
+    svg2.appendChild(path2);
+    start$1 = end$1;
+  }
+}
+function renderDoughnutChart(doc$2, container, chart, geometry) {
+  const series = chart.series[0];
+  if (!series)
+    return createChartPlaceholder(doc$2, container, "No chart data");
+  const { slices, truncated } = normalizePieSlices(series);
+  if (slices.reduce((sum, slice2) => sum + slice2.value, 0) <= 0)
+    return createChartPlaceholder(doc$2, container, "No chart data");
+  if (slices.length * 3 > SVG_ELEMENT_BUDGET)
+    return createChartPlaceholder(doc$2, container, "Chart too large");
+  const { width, height } = geometry;
+  const hasLegend = chart.legendPosition !== undefined;
+  const title = series.name?.trim() || "";
+  const hasTitle = title.length > 0;
+  const titleSpace = hasTitle ? 34 : 10;
+  const legendSpace = hasLegend ? 40 : 10;
+  const plotWidth = Math.max(1, width - 20);
+  const plotHeight = Math.max(1, height - titleSpace - legendSpace);
+  const centerX = width / 2;
+  const centerY = titleSpace + plotHeight / 2;
+  const outerRadius = Math.max(8, Math.min(plotWidth, plotHeight) * 0.45);
+  const innerRadius = Math.max(2, outerRadius * 0.58);
+  const svg2 = doc$2.createElementNS(SVG_NS, "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg2.setAttribute("width", "100%");
+  svg2.setAttribute("height", "100%");
+  svg2.style.display = "block";
+  if (hasTitle) {
+    const titleEl = doc$2.createElementNS(SVG_NS, "text");
+    titleEl.setAttribute("x", String(centerX));
+    titleEl.setAttribute("y", "24");
+    titleEl.setAttribute("text-anchor", "middle");
+    titleEl.setAttribute("font-size", String(Math.max(12, Math.min(22, width / 18))));
+    titleEl.setAttribute("fill", AXIS_COLOR);
+    titleEl.setAttribute("font-family", FONT_FAMILY);
+    titleEl.textContent = title;
+    svg2.appendChild(titleEl);
+  }
+  renderDoughnutSlices(doc$2, svg2, slices, centerX, centerY, outerRadius, innerRadius);
+  if (hasLegend)
+    renderPieLegend(doc$2, svg2, slices, width, height);
+  if (truncated)
+    renderTruncationIndicator(doc$2, svg2, width);
+  container.appendChild(svg2);
+  return container;
+}
+function estimateSvgElements(series, categories, hasLegend) {
+  const bars = series.reduce((sum, s2) => sum + s2.values.length, 0);
+  const axes = 2;
+  const categoryLabels = categories.length;
+  const valueTicks = (VALUE_TICK_COUNT + 1) * 2;
+  const legend = hasLegend ? series.length * 2 : 0;
+  return bars + axes + categoryLabels + valueTicks + legend;
+}
+function renderBarChart(doc$2, container, chart, geometry) {
+  const { width, height } = geometry;
+  const { series, truncated } = applyGuardrails(chart);
+  const categories = series[0]?.categories ?? [];
+  const hasLegend = chart.legendPosition !== undefined;
+  const estimated = estimateSvgElements(series, categories, hasLegend);
+  if (estimated > SVG_ELEMENT_BUDGET)
+    return createChartPlaceholder(doc$2, container, `Chart too complex for inline rendering (${estimated} elements)`);
+  const svg2 = doc$2.createElementNS(SVG_NS, "svg");
+  svg2.setAttribute("viewBox", `0 0 ${width} ${height}`);
+  svg2.setAttribute("width", "100%");
+  svg2.setAttribute("height", "100%");
+  svg2.style.display = "block";
+  const layout = computeBarLayout(width, height, series);
+  renderBars(doc$2, svg2, series, layout);
+  renderAxes(doc$2, svg2, layout);
+  renderCategoryLabels(doc$2, svg2, categories, layout, width);
+  renderValueTicks(doc$2, svg2, layout, height);
+  if (hasLegend)
+    renderLegend(doc$2, svg2, series, height);
+  if (truncated)
+    renderTruncationIndicator(doc$2, svg2, width);
+  container.appendChild(svg2);
+  return container;
+}
 function assertPmPositions(run2, context) {
   const hasPmStart = run2.pmStart != null;
   const hasPmEnd = run2.pmEnd != null;
@@ -167424,7 +168646,7 @@ function coerceBoolean(value) {
       return false;
   }
 }
-function toBoxSpacing$1(spacing) {
+function toBoxSpacing(spacing) {
   if (!spacing)
     return;
   const result = {};
@@ -167714,7 +168936,7 @@ function hydrateImageBlocks(blocks2, mediaFiles) {
   });
 }
 function isGradientFill(value) {
-  if (!isPlainObject$2(value))
+  if (!isPlainObject$1(value))
     return false;
   if (value.type !== "gradient")
     return false;
@@ -167728,13 +168950,13 @@ function isGradientFill(value) {
   if (!Array.isArray(value.stops) || value.stops.length === 0)
     return false;
   return value.stops.every((stop) => {
-    if (!isPlainObject$2(stop))
+    if (!isPlainObject$1(stop))
       return false;
     return typeof stop.position === "number" && Number.isFinite(stop.position) && typeof stop.color === "string" && (stop.alpha === undefined || typeof stop.alpha === "number" && Number.isFinite(stop.alpha));
   });
 }
 function isSolidFillWithAlpha(value) {
-  return isPlainObject$2(value) && value.type === "solidWithAlpha" && typeof value.color === "string" && typeof value.alpha === "number";
+  return isPlainObject$1(value) && value.type === "solidWithAlpha" && typeof value.color === "string" && typeof value.alpha === "number";
 }
 function normalizeFillColor(value) {
   if (value === null)
@@ -167753,13 +168975,13 @@ function normalizeStrokeColor(value) {
     return value;
 }
 function normalizeTextContent(value) {
-  if (!isPlainObject$2(value))
+  if (!isPlainObject$1(value))
     return;
   if (!Array.isArray(value.parts))
     return;
   if (value.parts.length === 0)
     return;
-  const validParts = value.parts.filter((p$12) => isPlainObject$2(p$12) && typeof p$12.text === "string");
+  const validParts = value.parts.filter((p$12) => isPlainObject$1(p$12) && typeof p$12.text === "string");
   if (validParts.length === 0)
     return;
   const result = { parts: validParts };
@@ -167778,7 +169000,7 @@ function normalizeTextVerticalAlign(value) {
     return value;
 }
 function normalizeTextInsets(value) {
-  if (!isPlainObject$2(value))
+  if (!isPlainObject$1(value))
     return;
   const top$1 = pickNumber(value.top);
   const right$1 = pickNumber(value.right);
@@ -167803,7 +169025,7 @@ function coerceRelativeHeight(raw) {
   }
 }
 function normalizeZIndex(originalAttributes) {
-  if (!isPlainObject$2(originalAttributes))
+  if (!isPlainObject$1(originalAttributes))
     return;
   const relativeHeight = coerceRelativeHeight(originalAttributes.relativeHeight);
   if (relativeHeight === undefined)
@@ -173308,8 +174530,8 @@ function imageNodeToRun({ node: node3, positions, sdtMetadata }) {
   const size$2 = attrs.size ?? {};
   const width = typeof size$2.width === "number" && Number.isFinite(size$2.width) && size$2.width > 0 ? size$2.width : DEFAULT_IMAGE_DIMENSION_PX;
   const height = typeof size$2.height === "number" && Number.isFinite(size$2.height) && size$2.height > 0 ? size$2.height : DEFAULT_IMAGE_DIMENSION_PX;
-  const wrap4 = isPlainObject$2(attrs.wrap) ? attrs.wrap : {};
-  const wrapAttrs = isPlainObject$2(wrap4.attrs) ? wrap4.attrs : {};
+  const wrap4 = isPlainObject$1(attrs.wrap) ? attrs.wrap : {};
+  const wrapAttrs = isPlainObject$1(wrap4.attrs) ? wrap4.attrs : {};
   const run2 = {
     kind: "image",
     src,
@@ -173342,7 +174564,7 @@ function imageNodeToRun({ node: node3, positions, sdtMetadata }) {
   }
   if (sdtMetadata)
     run2.sdt = sdtMetadata;
-  const transformData = isPlainObject$2(attrs.transformData) ? attrs.transformData : undefined;
+  const transformData = isPlainObject$1(attrs.transformData) ? attrs.transformData : undefined;
   if (transformData) {
     const rotation = typeof transformData.rotation === "number" ? transformData.rotation : undefined;
     if (rotation !== undefined)
@@ -173469,7 +174691,7 @@ function lineBreakNodeToRun({ node: node3, positions, sdtMetadata }) {
   return lineBreakRun;
 }
 function vectorShapeNodeToDrawingBlock(node3, nextBlockId, positions) {
-  const rawAttrs = getAttrs$1(node3);
+  const rawAttrs = getAttrs$2(node3);
   if (isHiddenDrawing$1(rawAttrs))
     return null;
   const effectExtent = normalizeEffectExtent(rawAttrs.effectExtent);
@@ -173489,7 +174711,7 @@ function vectorShapeNodeToDrawingBlock(node3, nextBlockId, positions) {
   });
 }
 function shapeGroupNodeToDrawingBlock(node3, nextBlockId, positions) {
-  const rawAttrs = getAttrs$1(node3);
+  const rawAttrs = getAttrs$2(node3);
   if (isHiddenDrawing$1(rawAttrs))
     return null;
   const groupTransform = isShapeGroupTransform(rawAttrs.groupTransform) ? { ...rawAttrs.groupTransform } : undefined;
@@ -173509,7 +174731,7 @@ function shapeGroupNodeToDrawingBlock(node3, nextBlockId, positions) {
   });
 }
 function shapeContainerNodeToDrawingBlock(node3, nextBlockId, positions) {
-  const rawAttrs = getAttrs$1(node3);
+  const rawAttrs = getAttrs$2(node3);
   if (isHiddenDrawing$1(rawAttrs))
     return null;
   return buildDrawingBlock(rawAttrs, nextBlockId, positions, node3, {
@@ -173521,7 +174743,7 @@ function shapeContainerNodeToDrawingBlock(node3, nextBlockId, positions) {
   }, "vectorShape");
 }
 function shapeTextboxNodeToDrawingBlock(node3, nextBlockId, positions) {
-  const rawAttrs = getAttrs$1(node3);
+  const rawAttrs = getAttrs$2(node3);
   if (isHiddenDrawing$1(rawAttrs))
     return null;
   return buildDrawingBlock(rawAttrs, nextBlockId, positions, node3, {
@@ -173565,12 +174787,12 @@ function handleShapeTextboxNode(node3, context) {
   }
 }
 function contentBlockNodeToDrawingBlock(node3, nextBlockId, positions) {
-  const rawAttrs = getAttrs(node3);
+  const rawAttrs = getAttrs$1(node3);
   const indentLeft = pickNumber(rawAttrs.hrIndentLeft);
   const indentRight = pickNumber(rawAttrs.hrIndentRight);
   if (rawAttrs.horizontalRule !== true)
     return null;
-  const size$2 = isPlainObject$2(rawAttrs.size) ? rawAttrs.size : undefined;
+  const size$2 = isPlainObject$1(rawAttrs.size) ? rawAttrs.size : undefined;
   const { width, isFullWidth } = parseFullWidth(size$2?.width);
   const height = pickNumber(size$2?.height);
   if (!height || height <= 0)
@@ -173609,7 +174831,7 @@ function inlineContentBlockConverter(node3, { positions, nextBlockId, paragraphA
     }
   } : node3, nextBlockId, positions);
 }
-function toBoxSpacing(spacing) {
+function toBoxSpacing$1(spacing) {
   if (!spacing)
     return;
   const result = {};
@@ -173641,7 +174863,7 @@ function imageNodeToBlock(node3, nextBlockId, positions, _trackedMeta, _trackedC
   const width = typeof size$2.width === "number" && Number.isFinite(size$2.width) ? size$2.width : undefined;
   const height = typeof size$2.height === "number" && Number.isFinite(size$2.height) ? size$2.height : undefined;
   const explicitDisplay = typeof attrs.display === "string" ? attrs.display : undefined;
-  const normalizedWrap = normalizeWrap$1(attrs.wrap);
+  const normalizedWrap = normalizeWrap$2(attrs.wrap);
   let anchor = normalizeAnchorData(attrs.anchorData, attrs, normalizedWrap?.behindDoc);
   if (!anchor && normalizedWrap) {
     anchor = { isAnchored: true };
@@ -173656,7 +174878,7 @@ function imageNodeToBlock(node3, nextBlockId, positions, _trackedMeta, _trackedC
   const objectFit = isAllowedObjectFit(explicitObjectFit) ? explicitObjectFit : shouldCover ? "cover" : display === "inline" ? "scale-down" : isAnchor ? "contain" : "contain";
   const zIndexFromRelativeHeight = normalizeZIndex(attrs.originalAttributes);
   const zIndex = resolveFloatingZIndex(anchor?.behindDoc === true, zIndexFromRelativeHeight);
-  const transformData = isPlainObject$1(attrs.transformData) ? attrs.transformData : undefined;
+  const transformData = isPlainObject$2(attrs.transformData) ? attrs.transformData : undefined;
   const rotation = typeof transformData?.rotation === "number" ? transformData.rotation : undefined;
   const flipH = typeof transformData?.horizontalFlip === "boolean" ? transformData.horizontalFlip : undefined;
   const flipV = typeof transformData?.verticalFlip === "boolean" ? transformData.verticalFlip : undefined;
@@ -173670,8 +174892,8 @@ function imageNodeToBlock(node3, nextBlockId, positions, _trackedMeta, _trackedC
     title: typeof attrs.title === "string" ? attrs.title : undefined,
     objectFit,
     display,
-    padding: toBoxSpacing(attrs.padding),
-    margin: toBoxSpacing(attrs.marginOffset),
+    padding: toBoxSpacing$1(attrs.padding),
+    margin: toBoxSpacing$1(attrs.marginOffset),
     anchor,
     wrap: normalizedWrap,
     ...zIndex !== undefined && { zIndex },
@@ -173697,6 +174919,49 @@ function handleImageNode2(node3, context) {
     return imageBlock;
   }
 }
+function chartNodeToDrawingBlock(node3, nextBlockId, positions) {
+  const rawAttrs = getAttrs(node3);
+  const chartData = rawAttrs.chartData && typeof rawAttrs.chartData === "object" ? rawAttrs.chartData : EMPTY_CHART_DATA;
+  const geometry = {
+    width: coercePositiveNumber(rawAttrs.width, 400),
+    height: coercePositiveNumber(rawAttrs.height, 300),
+    rotation: 0,
+    flipH: false,
+    flipV: false
+  };
+  const normalizedWrap = normalizeWrap$1(rawAttrs.wrap);
+  const anchor = normalizeAnchor(rawAttrs.anchorData, rawAttrs, normalizedWrap?.behindDoc);
+  const pos = positions.get(node3);
+  const attrsWithPm = { ...rawAttrs };
+  if (pos) {
+    attrsWithPm.pmStart = pos.start;
+    attrsWithPm.pmEnd = pos.end;
+  }
+  const resolvedZIndex = resolveFloatingZIndex(anchor?.behindDoc === true || normalizedWrap?.behindDoc === true, normalizeZIndex(rawAttrs.originalAttributes), 1);
+  return {
+    kind: "drawing",
+    id: nextBlockId("drawing"),
+    drawingKind: "chart",
+    geometry,
+    chartData,
+    chartRelId: typeof rawAttrs.chartRelId === "string" ? rawAttrs.chartRelId : undefined,
+    chartPartPath: typeof rawAttrs.chartPartPath === "string" ? rawAttrs.chartPartPath : undefined,
+    padding: toBoxSpacing(rawAttrs.padding),
+    margin: toBoxSpacing(rawAttrs.marginOffset),
+    anchor,
+    wrap: normalizedWrap,
+    zIndex: resolvedZIndex,
+    drawingContentId: typeof rawAttrs.drawingContentId === "string" ? rawAttrs.drawingContentId : undefined,
+    drawingContent: toDrawingContentSnapshot(rawAttrs.drawingContent),
+    attrs: attrsWithPm
+  };
+}
+function handleChartNode(node3, context) {
+  const { blocks: blocks2, recordBlockKind, nextBlockId, positions } = context;
+  const drawingBlock = chartNodeToDrawingBlock(node3, nextBlockId, positions);
+  blocks2.push(drawingBlock);
+  recordBlockKind?.(drawingBlock.kind);
+}
 function normalizeCellSpacing(raw) {
   if (raw == null)
     return {
@@ -182017,6 +183282,86 @@ function generateTransforms(attrs) {
     transforms.push(`scaleY(-1)`);
   return transforms;
 }
+function countChartNodes(doc$2) {
+  let count = 0;
+  doc$2.descendants((node3) => {
+    if (node3.type.name === "chart")
+      count++;
+    return node3.type.name !== "chart";
+  });
+  return count;
+}
+function collectChartNodes(doc$2) {
+  let charts = chartPositionCache.get(doc$2);
+  if (charts)
+    return charts;
+  charts = [];
+  doc$2.descendants((node3, pos) => {
+    if (node3.type.name === "chart")
+      charts.push({
+        pos,
+        node: node3
+      });
+    return node3.type.name !== "chart";
+  });
+  chartPositionCache.set(doc$2, charts);
+  return charts;
+}
+function transactionInsertsChart(tr) {
+  for (const step3 of tr.steps) {
+    const slice2 = step3.slice;
+    if (!slice2 || !slice2.content.size)
+      continue;
+    let found2 = false;
+    slice2.content.descendants((node3) => {
+      if (node3.type.name === "chart")
+        found2 = true;
+      return !found2;
+    });
+    if (found2)
+      return true;
+  }
+  return false;
+}
+function isChartMutation(tr, oldDoc) {
+  if (transactionInsertsChart(tr))
+    return true;
+  const oldCharts = collectChartNodes(oldDoc);
+  if (oldCharts.length === 0)
+    return false;
+  const newDoc = tr.doc;
+  for (const { pos, node: oldNode } of oldCharts) {
+    const mappedPos = tr.mapping.map(pos);
+    const nodeAfter = newDoc.resolve(mappedPos).nodeAfter;
+    if (!nodeAfter || nodeAfter.type.name !== "chart")
+      return true;
+    if (oldNode.attrs !== nodeAfter.attrs) {
+      if (JSON.stringify(oldNode.attrs) !== JSON.stringify(nodeAfter.attrs))
+        return true;
+    }
+  }
+  return false;
+}
+function createChartImmutabilityPlugin() {
+  return new Plugin({
+    key: CHART_IMMUTABILITY_KEY,
+    state: {
+      init(_$1, state) {
+        return countChartNodes(state.doc);
+      },
+      apply(_tr, oldCount) {
+        return oldCount;
+      }
+    },
+    filterTransaction(tr, state) {
+      if (!tr.docChanged)
+        return true;
+      if ((CHART_IMMUTABILITY_KEY.getState(state) ?? 0) === 0)
+        return !transactionInsertsChart(tr);
+      return !isChartMutation(tr, state.doc);
+    }
+  });
+}
 function createCascadeToggleCommands({ markName, setCommand, unsetCommand, toggleCommand, negationAttrs, isNegation, extendEmptyMarkRange } = {}) {
   if (!markName)
     throw new Error("createCascadeToggleCommands requires a markName");
@@ -200249,7 +201594,7 @@ var Node$13 = class Node$14 {
   if (current.trim())
     parts.push(current.trim());
   return parts;
-}, _, F, X, p3 = "http://schemas.openxmlformats.org/drawingml/2006/main", G, c0, n0 = 100, o0, u0 = (t) => h$1(t, p3, "path").length > 0, M0, r0, DOM_CLASS_NAMES, hashParagraphBorder$1 = (border) => {
+}, _, F, X, p3 = "http://schemas.openxmlformats.org/drawingml/2006/main", G, c0, n0 = 100, o0, u0 = (t) => h$1(t, p3, "path").length > 0, M0, r0, DOM_CLASS_NAMES, MAX_RENDERED_SERIES = 20, MAX_POINTS_PER_SERIES = 500, SVG_ELEMENT_BUDGET = 5000, SERIES_COLORS, AXIS_COLOR = "#595959", GRID_COLOR = "#E0E0E0", LABEL_COLOR = "#333", TICK_LABEL_COLOR = "#666", FONT_FAMILY = "Calibri, Arial, sans-serif", PLACEHOLDER_BG = "#f8f9fa", PLACEHOLDER_BORDER = "#dee2e6", PLACEHOLDER_TEXT_COLOR = "#6c757d", SVG_NS = "http://www.w3.org/2000/svg", CHART_PADDING, VALUE_TICK_COUNT = 5, hashParagraphBorder$1 = (border) => {
   const parts = [];
   if (border.style !== undefined)
     parts.push(`s:${border.style}`);
@@ -201194,7 +202539,7 @@ var Node$13 = class Node$14 {
   if (pt == null || !Number.isFinite(pt))
     return;
   return pt * PX_PER_PT2;
-}, isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value), isPlainObject$2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), normalizePrefix = (value) => {
+}, isFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value), isPlainObject$1 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), normalizePrefix = (value) => {
   if (!value)
     return "";
   return String(value);
@@ -201212,7 +202557,7 @@ var Node$13 = class Node$14 {
   if (!trimmed || trimmed === "auto" || trimmed === "none")
     return;
   return trimmed.startsWith("#") ? trimmed : `#${trimmed}`;
-}, toBoolean$1 = (value) => {
+}, toBoolean = (value) => {
   if (typeof value === "boolean")
     return value;
   if (typeof value === "string") {
@@ -202435,7 +203780,7 @@ var Node$13 = class Node$14 {
     this.onMouseLeave = null;
     this.hoveredSdtId = null;
   }
-}, LIST_MARKER_GAP = 8, DEFAULT_PAGE_HEIGHT_PX = 1056, DEFAULT_VIRTUALIZED_PAGE_GAP = 72, COMMENT_EXTERNAL_COLOR = "#B1124B", COMMENT_INTERNAL_COLOR = "#078383", COMMENT_INACTIVE_ALPHA = "40", COMMENT_ACTIVE_ALPHA = "66", COMMENT_FADED_ALPHA = "20", LINK_DATASET_KEYS, MAX_HREF_LENGTH = 2048, SAFE_ANCHOR_PATTERN, MAX_DATA_URL_LENGTH, VALID_IMAGE_DATA_URL, MAX_RESIZE_MULTIPLIER = 3, FALLBACK_MAX_DIMENSION = 1000, MIN_IMAGE_DIMENSION = 20, AMBIGUOUS_LINK_PATTERNS, linkMetrics, TRACK_CHANGE_BASE_CLASS, TRACK_CHANGE_FOCUSED_CLASS = "track-change-focused", TRACK_CHANGE_MODIFIER_CLASS, LINK_TARGET_SET, normalizeAnchor = (value) => {
+}, LIST_MARKER_GAP = 8, DEFAULT_PAGE_HEIGHT_PX = 1056, DEFAULT_VIRTUALIZED_PAGE_GAP = 72, COMMENT_EXTERNAL_COLOR = "#B1124B", COMMENT_INTERNAL_COLOR = "#078383", COMMENT_INACTIVE_ALPHA = "40", COMMENT_ACTIVE_ALPHA = "66", COMMENT_FADED_ALPHA = "20", LINK_DATASET_KEYS, MAX_HREF_LENGTH = 2048, SAFE_ANCHOR_PATTERN, MAX_DATA_URL_LENGTH, VALID_IMAGE_DATA_URL, MAX_RESIZE_MULTIPLIER = 3, FALLBACK_MAX_DIMENSION = 1000, MIN_IMAGE_DIMENSION = 20, AMBIGUOUS_LINK_PATTERNS, linkMetrics, TRACK_CHANGE_BASE_CLASS, TRACK_CHANGE_FOCUSED_CLASS = "track-change-focused", TRACK_CHANGE_MODIFIER_CLASS, LINK_TARGET_SET, normalizeAnchor$1 = (value) => {
   if (typeof value !== "string")
     return null;
   const trimmed = value.trim();
@@ -202858,6 +204203,15 @@ var Node$13 = class Node$14 {
         childSignature
       ].join("|");
     }
+    if (block.drawingKind === "chart")
+      return [
+        "drawing:chart",
+        block.chartData?.chartType ?? "",
+        block.chartData?.series?.length ?? 0,
+        block.geometry.width,
+        block.geometry.height,
+        block.chartRelId ?? ""
+      ].join("|");
     return `drawing:unknown:${block.id}`;
   }
   if (block.kind === "table") {
@@ -204829,20 +206183,20 @@ var Node$13 = class Node$14 {
     id: nextBlockId(kind),
     attrs: node3.attrs || {}
   };
-}, WRAP_TYPES$1, WRAP_TEXT_VALUES$1, H_RELATIVE_VALUES$1, V_RELATIVE_VALUES$1, H_ALIGN_VALUES$1, V_ALIGN_VALUES$1, getAttrs$1 = (node3) => {
-  return isPlainObject$2(node3.attrs) ? node3.attrs : {};
+}, WRAP_TYPES$2, WRAP_TEXT_VALUES$2, H_RELATIVE_VALUES$2, V_RELATIVE_VALUES$2, H_ALIGN_VALUES$1, V_ALIGN_VALUES$1, getAttrs$2 = (node3) => {
+  return isPlainObject$1(node3.attrs) ? node3.attrs : {};
 }, isHiddenDrawing$1 = (attrs) => {
-  if (toBoolean$1(attrs.hidden) === true)
+  if (toBoolean(attrs.hidden) === true)
     return true;
   return typeof attrs.visibility === "string" && attrs.visibility.toLowerCase() === "hidden";
 }, normalizeWrapType$1 = (value) => {
   if (typeof value !== "string")
     return;
-  return WRAP_TYPES$1.has(value) ? value : undefined;
+  return WRAP_TYPES$2.has(value) ? value : undefined;
 }, normalizeWrapText$1 = (value) => {
   if (typeof value !== "string")
     return;
-  return WRAP_TEXT_VALUES$1.has(value) ? value : undefined;
+  return WRAP_TEXT_VALUES$2.has(value) ? value : undefined;
 }, normalizePolygon$1 = (value) => {
   if (!Array.isArray(value))
     return;
@@ -204857,14 +206211,14 @@ var Node$13 = class Node$14 {
     polygon.push([x, y$1]);
   });
   return polygon.length > 0 ? polygon : undefined;
-}, normalizeWrap$2 = (value) => {
-  if (!isPlainObject$2(value))
+}, normalizeWrap$3 = (value) => {
+  if (!isPlainObject$1(value))
     return;
   const type = normalizeWrapType$1(value.type);
   if (!type || type === "Inline")
     return;
   const wrap4 = { type };
-  const attrs = isPlainObject$2(value.attrs) ? value.attrs : {};
+  const attrs = isPlainObject$1(value.attrs) ? value.attrs : {};
   const wrapText = normalizeWrapText$1(attrs.wrapText);
   if (wrapText)
     wrap4.wrapText = wrapText;
@@ -204883,7 +206237,7 @@ var Node$13 = class Node$14 {
   const polygon = normalizePolygon$1(attrs.polygon);
   if (polygon)
     wrap4.polygon = polygon;
-  const behindDoc = toBoolean$1(attrs.behindDoc);
+  const behindDoc = toBoolean(attrs.behindDoc);
   if (behindDoc != null)
     wrap4.behindDoc = behindDoc;
   return wrap4;
@@ -204896,18 +206250,18 @@ var Node$13 = class Node$14 {
     return;
   return allowed.has(value) ? value : undefined;
 }, normalizeAnchorData$1 = (value, attrs, wrapBehindDoc) => {
-  const raw = isPlainObject$2(value) ? value : undefined;
-  const marginOffset = isPlainObject$2(attrs.marginOffset) ? attrs.marginOffset : undefined;
-  const simplePos = isPlainObject$2(attrs.simplePos) ? attrs.simplePos : undefined;
-  const originalAttrs = isPlainObject$2(attrs.originalAttributes) ? attrs.originalAttributes : undefined;
+  const raw = isPlainObject$1(value) ? value : undefined;
+  const marginOffset = isPlainObject$1(attrs.marginOffset) ? attrs.marginOffset : undefined;
+  const simplePos = isPlainObject$1(attrs.simplePos) ? attrs.simplePos : undefined;
+  const originalAttrs = isPlainObject$1(attrs.originalAttributes) ? attrs.originalAttributes : undefined;
   const isAnchored = attrs.isAnchor === true || Boolean(raw);
   const anchor = {};
   if (isAnchored)
     anchor.isAnchored = true;
-  const hRelative = normalizeAnchorRelative$1(raw?.hRelativeFrom, H_RELATIVE_VALUES$1);
+  const hRelative = normalizeAnchorRelative$1(raw?.hRelativeFrom, H_RELATIVE_VALUES$2);
   if (hRelative)
     anchor.hRelativeFrom = hRelative;
-  const vRelative = normalizeAnchorRelative$1(raw?.vRelativeFrom, V_RELATIVE_VALUES$1);
+  const vRelative = normalizeAnchorRelative$1(raw?.vRelativeFrom, V_RELATIVE_VALUES$2);
   if (vRelative)
     anchor.vRelativeFrom = vRelative;
   const alignH = normalizeAnchorAlign$1(raw?.alignH, H_ALIGN_VALUES$1);
@@ -204922,12 +206276,12 @@ var Node$13 = class Node$14 {
   const offsetV = pickNumber(marginOffset?.top ?? marginOffset?.vertical ?? raw?.offsetV ?? simplePos?.y);
   if (offsetV != null)
     anchor.offsetV = offsetV;
-  const behindDoc = toBoolean$1(raw?.behindDoc ?? wrapBehindDoc ?? originalAttrs?.behindDoc);
+  const behindDoc = toBoolean(raw?.behindDoc ?? wrapBehindDoc ?? originalAttrs?.behindDoc);
   if (behindDoc != null)
     anchor.behindDoc = behindDoc;
   return anchor.isAnchored || anchor.hRelativeFrom != null || anchor.vRelativeFrom != null || anchor.alignH != null || anchor.alignV != null || anchor.offsetH != null || anchor.offsetV != null || anchor.behindDoc != null ? anchor : undefined;
 }, buildDrawingBlock = (rawAttrs, nextBlockId, positions, node3, geometry, drawingKind, extraProps) => {
-  const normalizedWrap = normalizeWrap$2(rawAttrs.wrap);
+  const normalizedWrap = normalizeWrap$3(rawAttrs.wrap);
   const baseAnchor = normalizeAnchorData$1(rawAttrs.anchorData, rawAttrs, normalizedWrap?.behindDoc);
   const pos = positions.get(node3);
   const attrsWithPm = { ...rawAttrs };
@@ -204940,8 +206294,8 @@ var Node$13 = class Node$14 {
     kind: "drawing",
     id: nextBlockId("drawing"),
     drawingKind,
-    padding: toBoxSpacing$1(rawAttrs.padding),
-    margin: toBoxSpacing$1(rawAttrs.marginOffset) ?? toBoxSpacing$1(rawAttrs.margin),
+    padding: toBoxSpacing(rawAttrs.padding),
+    margin: toBoxSpacing(rawAttrs.marginOffset) ?? toBoxSpacing(rawAttrs.margin),
     anchor: baseAnchor,
     wrap: normalizedWrap,
     zIndex: resolvedZIndex,
@@ -204960,8 +206314,8 @@ var Node$13 = class Node$14 {
     textInsets: normalizeTextInsets(rawAttrs.textInsets),
     ...extraProps
   };
-}, getAttrs = (node3) => {
-  return isPlainObject$2(node3.attrs) ? { ...node3.attrs } : {};
+}, getAttrs$1 = (node3) => {
+  return isPlainObject$1(node3.attrs) ? { ...node3.attrs } : {};
 }, parseFullWidth = (value) => {
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -204979,20 +206333,20 @@ var Node$13 = class Node$14 {
     width: pickNumber(value) ?? null,
     isFullWidth: false
   };
-}, WRAP_TYPES, WRAP_TEXT_VALUES, H_RELATIVE_VALUES, V_RELATIVE_VALUES, H_ALIGN_VALUES, V_ALIGN_VALUES, isPlainObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), isAllowedObjectFit = (value) => {
+}, WRAP_TYPES$1, WRAP_TEXT_VALUES$1, H_RELATIVE_VALUES$1, V_RELATIVE_VALUES$1, H_ALIGN_VALUES, V_ALIGN_VALUES, isPlainObject$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), isAllowedObjectFit = (value) => {
   return value === "contain" || value === "cover" || value === "fill" || value === "scale-down";
 }, isHiddenDrawing = (attrs) => {
-  if (toBoolean(attrs.hidden) === true)
+  if (toBoolean$1(attrs.hidden) === true)
     return true;
   return typeof attrs.visibility === "string" && attrs.visibility.toLowerCase() === "hidden";
 }, normalizeWrapType = (value) => {
   if (typeof value !== "string")
     return;
-  return WRAP_TYPES.has(value) ? value : undefined;
+  return WRAP_TYPES$1.has(value) ? value : undefined;
 }, normalizeWrapText = (value) => {
   if (typeof value !== "string")
     return;
-  return WRAP_TEXT_VALUES.has(value) ? value : undefined;
+  return WRAP_TEXT_VALUES$1.has(value) ? value : undefined;
 }, normalizePolygon = (value) => {
   if (!Array.isArray(value))
     return;
@@ -205007,7 +206361,7 @@ var Node$13 = class Node$14 {
     polygon.push([x, y$1]);
   });
   return polygon.length > 0 ? polygon : undefined;
-}, toBoolean = (value) => {
+}, toBoolean$1 = (value) => {
   if (value === undefined || value === null)
     return;
   if (typeof value === "boolean")
@@ -205025,14 +206379,14 @@ var Node$13 = class Node$14 {
     if (normalized === "0" || normalized === "false")
       return false;
   }
-}, normalizeWrap$1 = (value) => {
-  if (!isPlainObject$1(value))
+}, normalizeWrap$2 = (value) => {
+  if (!isPlainObject$2(value))
     return;
   const type = normalizeWrapType(value.type);
   if (!type)
     return;
   const wrap4 = { type };
-  const attrs = isPlainObject$1(value.attrs) ? value.attrs : {};
+  const attrs = isPlainObject$2(value.attrs) ? value.attrs : {};
   const wrapText = normalizeWrapText(attrs.wrapText);
   if (wrapText)
     wrap4.wrapText = wrapText;
@@ -205051,7 +206405,7 @@ var Node$13 = class Node$14 {
   const polygon = normalizePolygon(attrs.polygon);
   if (polygon)
     wrap4.polygon = polygon;
-  const behindDoc = toBoolean(attrs.behindDoc);
+  const behindDoc = toBoolean$1(attrs.behindDoc);
   if (behindDoc != null)
     wrap4.behindDoc = behindDoc;
   return wrap4;
@@ -205064,18 +206418,18 @@ var Node$13 = class Node$14 {
     return;
   return allowed.has(value) ? value : undefined;
 }, normalizeAnchorData = (value, attrs, wrapBehindDoc) => {
-  const raw = isPlainObject$1(value) ? value : undefined;
-  const marginOffset = isPlainObject$1(attrs.marginOffset) ? attrs.marginOffset : undefined;
-  const simplePos = isPlainObject$1(attrs.simplePos) ? attrs.simplePos : undefined;
-  const originalAttrs = isPlainObject$1(attrs.originalAttributes) ? attrs.originalAttributes : undefined;
+  const raw = isPlainObject$2(value) ? value : undefined;
+  const marginOffset = isPlainObject$2(attrs.marginOffset) ? attrs.marginOffset : undefined;
+  const simplePos = isPlainObject$2(attrs.simplePos) ? attrs.simplePos : undefined;
+  const originalAttrs = isPlainObject$2(attrs.originalAttributes) ? attrs.originalAttributes : undefined;
   const isAnchored = attrs.isAnchor === true || Boolean(raw);
   const anchor = {};
   if (isAnchored)
     anchor.isAnchored = true;
-  const hRelative = normalizeAnchorRelative(raw?.hRelativeFrom, H_RELATIVE_VALUES);
+  const hRelative = normalizeAnchorRelative(raw?.hRelativeFrom, H_RELATIVE_VALUES$1);
   if (hRelative)
     anchor.hRelativeFrom = hRelative;
-  const vRelative = normalizeAnchorRelative(raw?.vRelativeFrom, V_RELATIVE_VALUES);
+  const vRelative = normalizeAnchorRelative(raw?.vRelativeFrom, V_RELATIVE_VALUES$1);
   if (vRelative)
     anchor.vRelativeFrom = vRelative;
   const alignH = normalizeAnchorAlign(raw?.alignH, H_ALIGN_VALUES);
@@ -205090,11 +206444,64 @@ var Node$13 = class Node$14 {
   const offsetV = pickNumber(marginOffset?.top ?? marginOffset?.vertical ?? raw?.offsetV ?? simplePos?.y);
   if (offsetV != null)
     anchor.offsetV = offsetV;
-  const behindDoc = toBoolean(raw?.behindDoc ?? wrapBehindDoc ?? originalAttrs?.behindDoc);
+  const behindDoc = toBoolean$1(raw?.behindDoc ?? wrapBehindDoc ?? originalAttrs?.behindDoc);
   if (behindDoc != null)
     anchor.behindDoc = behindDoc;
   return anchor.isAnchored || anchor.hRelativeFrom != null || anchor.vRelativeFrom != null || anchor.alignH != null || anchor.alignV != null || anchor.offsetH != null || anchor.offsetV != null || anchor.behindDoc != null ? anchor : undefined;
-}, hydrateTableStyleAttrs = (tableNode, context, effectiveStyleId) => {
+}, WRAP_TYPES, WRAP_TEXT_VALUES, H_RELATIVE_VALUES, V_RELATIVE_VALUES, getAttrs = (node3) => {
+  return isPlainObject$1(node3.attrs) ? node3.attrs : {};
+}, normalizeWrap$1 = (value) => {
+  if (!isPlainObject$1(value))
+    return;
+  const type = typeof value.type === "string" && WRAP_TYPES.has(value.type) ? value.type : undefined;
+  if (!type || type === "Inline")
+    return;
+  const wrap4 = { type };
+  const attrs = isPlainObject$1(value.attrs) ? value.attrs : {};
+  const wrapText = typeof attrs.wrapText === "string" && WRAP_TEXT_VALUES.has(attrs.wrapText) ? attrs.wrapText : undefined;
+  if (wrapText)
+    wrap4.wrapText = wrapText;
+  const distTop = pickNumber(attrs.distTop ?? attrs.distT);
+  if (distTop != null)
+    wrap4.distTop = distTop;
+  const distBottom = pickNumber(attrs.distBottom ?? attrs.distB);
+  if (distBottom != null)
+    wrap4.distBottom = distBottom;
+  const distLeft = pickNumber(attrs.distLeft ?? attrs.distL);
+  if (distLeft != null)
+    wrap4.distLeft = distLeft;
+  const distRight = pickNumber(attrs.distRight ?? attrs.distR);
+  if (distRight != null)
+    wrap4.distRight = distRight;
+  const behindDoc = toBoolean(attrs.behindDoc);
+  if (behindDoc != null)
+    wrap4.behindDoc = behindDoc;
+  return wrap4;
+}, normalizeAnchor = (value, attrs, wrapBehindDoc) => {
+  const raw = isPlainObject$1(value) ? value : undefined;
+  const marginOffset = isPlainObject$1(attrs.marginOffset) ? attrs.marginOffset : undefined;
+  const simplePos = isPlainObject$1(attrs.simplePos) ? attrs.simplePos : undefined;
+  const isAnchored = attrs.isAnchor === true || Boolean(raw);
+  const anchor = {};
+  if (isAnchored)
+    anchor.isAnchored = true;
+  const hRelative = typeof raw?.hRelativeFrom === "string" && H_RELATIVE_VALUES.has(raw.hRelativeFrom) ? raw.hRelativeFrom : undefined;
+  if (hRelative)
+    anchor.hRelativeFrom = hRelative;
+  const vRelative = typeof raw?.vRelativeFrom === "string" && V_RELATIVE_VALUES.has(raw.vRelativeFrom) ? raw.vRelativeFrom : undefined;
+  if (vRelative)
+    anchor.vRelativeFrom = vRelative;
+  const offsetH = pickNumber(marginOffset?.horizontal ?? marginOffset?.left ?? raw?.offsetH ?? simplePos?.x);
+  if (offsetH != null)
+    anchor.offsetH = offsetH;
+  const offsetV = pickNumber(marginOffset?.top ?? marginOffset?.vertical ?? raw?.offsetV ?? simplePos?.y);
+  if (offsetV != null)
+    anchor.offsetV = offsetV;
+  const behindDoc = toBoolean(raw?.behindDoc ?? wrapBehindDoc);
+  if (behindDoc != null)
+    anchor.behindDoc = behindDoc;
+  return anchor.isAnchored || anchor.hRelativeFrom != null || anchor.vRelativeFrom != null || anchor.offsetH != null || anchor.offsetV != null || anchor.behindDoc != null ? anchor : undefined;
+}, EMPTY_CHART_DATA, hydrateTableStyleAttrs = (tableNode, context, effectiveStyleId) => {
   const hydration = {};
   const tableProps = tableNode.attrs?.tableProperties ?? null;
   let inlineBorders;
@@ -206711,6 +208118,8 @@ var Node$13 = class Node$14 {
     return drawingGeometryEqual(a2.geometry, b$1.geometry) && a2.shapeKind === b$1.shapeKind && a2.fillColor === b$1.fillColor && a2.strokeColor === b$1.strokeColor && a2.strokeWidth === b$1.strokeWidth;
   if (a2.drawingKind === "shapeGroup" && b$1.drawingKind === "shapeGroup")
     return drawingGeometryEqual(a2.geometry, b$1.geometry) && shapeGroupTransformEqual(a2.groupTransform, b$1.groupTransform) && shapeGroupSizeEqual(a2.size, b$1.size) && shapeGroupChildrenEqual(a2.shapes, b$1.shapes);
+  if (a2.drawingKind === "chart" && b$1.drawingKind === "chart")
+    return drawingGeometryEqual(a2.geometry, b$1.geometry) && a2.chartRelId === b$1.chartRelId && jsonEqual(a2.chartData, b$1.chartData);
   return true;
 }, boxSpacingEqual = (a2, b$1) => {
   if (a2 === b$1)
@@ -214464,7 +215873,7 @@ var Node$13 = class Node$14 {
   update() {
     return false;
   }
-}, ShapeGroup, sharedAttributes$2 = () => ({
+}, ShapeGroup, CHART_IMMUTABILITY_KEY, chartPositionCache, Chart, sharedAttributes$2 = () => ({
   originalName: { default: null },
   originalXml: { default: null }
 }), hiddenRender = (type) => ["sd-passthrough", {
@@ -215148,6 +216557,7 @@ var Node$13 = class Node$14 {
     TextTransform,
     VectorShape,
     ShapeGroup,
+    Chart,
     PermStart,
     PermEnd,
     PermStartBlock,
@@ -216864,9 +218274,9 @@ var Node$13 = class Node$14 {
     trackedChanges: context.trackedChanges ?? []
   });
 }, _hoisted_1$6, _hoisted_2$2, _hoisted_3, _hoisted_4, ContextMenu_default, _hoisted_1$5, BasicUpload_default, _hoisted_1$4, MIN_WIDTH = 200, PPI = 96, alignment = "flex-end", Ruler_default, GenericPopover_default, _hoisted_1$3, _hoisted_2$1, RESIZE_HANDLE_WIDTH_PX = 9, RESIZE_HANDLE_HEIGHT_PX = 9, RESIZE_HANDLE_OFFSET_PX = 4, DRAG_OVERLAY_EXTENSION_PX = 1000, MIN_DRAG_OVERLAY_WIDTH_PX = 2000, THROTTLE_INTERVAL_MS = 16, MIN_RESIZE_DELTA_PX = 1, TableResizeOverlay_default, _hoisted_1$2, OVERLAY_EXPANSION_PX = 2000, RESIZE_HANDLE_SIZE_PX = 12, MOUSE_MOVE_THROTTLE_MS = 16, DIMENSION_CHANGE_THRESHOLD_PX = 1, Z_INDEX_OVERLAY = 10, Z_INDEX_HANDLE = 15, Z_INDEX_GUIDELINE = 20, ImageResizeOverlay_default, LINK_CLICK_DEBOUNCE_MS = 300, CURSOR_UPDATE_TIMEOUT_MS = 10, POPOVER_VERTICAL_OFFSET_PX = 15, LinkClickHandler_default, _hoisted_1$1, _hoisted_2, DOCX2 = "application/vnd.openxmlformats-officedocument.wordprocessingml.document", TABLE_RESIZE_HOVER_THRESHOLD = 8, TABLE_RESIZE_THROTTLE_MS = 16, SuperEditor_default, _hoisted_1, SuperInput_default, SlashMenu, Extensions;
-var init_src_CJCOedws_es = __esm(() => {
+var init_src_asiscfsz_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
-  init_SuperConverter_Cx2VynBq_es();
+  init_SuperConverter_BDyjQdwB_es();
   init_jszip_ChlR43oI_es();
   init_uuid_qzgm05fK_es();
   init_constants_CMPtQbp7_es();
@@ -231111,6 +232521,20 @@ function print() { __p += __j.call(arguments, '') }
     INLINE_IMAGE: "superdoc-inline-image",
     INLINE_IMAGE_CLIP_WRAPPER: "superdoc-inline-image-clip-wrapper"
   };
+  SERIES_COLORS = [
+    "#4472C4",
+    "#ED7D31",
+    "#A5A5A5",
+    "#FFC000",
+    "#5B9BD5",
+    "#70AD47"
+  ];
+  CHART_PADDING = {
+    top: 30,
+    right: 20,
+    bottom: 50,
+    left: 60
+  };
   init_dist();
   globalValidationStats = new ValidationStatsCollector;
   TICK_SPACING_PX = DEFAULT_PPI / 8;
@@ -232933,6 +234357,8 @@ function print() { __p += __j.call(arguments, '') }
         return this.createVectorShapeElement(block, fragment2.geometry, true, 1, 1, context);
       if (block.drawingKind === "shapeGroup")
         return this.createShapeGroupElement(block, context);
+      if (block.drawingKind === "chart")
+        return this.createChartElement(block);
       return this.createDrawingPlaceholder();
     }
     createDrawingImageElement(block) {
@@ -233430,6 +234856,9 @@ function print() { __p += __j.call(arguments, '') }
       placeholder.style.border = "1px dashed rgba(15, 23, 42, 0.3)";
       return placeholder;
     }
+    createChartElement(block) {
+      return createChartElement(this.doc, block.chartData, block.geometry);
+    }
     renderTableFragment(fragment2, context, sdtBoundary) {
       if (!this.doc)
         throw new Error("DomPainter: document is not available");
@@ -233448,6 +234877,8 @@ function print() { __p += __j.call(arguments, '') }
           return this.createShapeGroupElement(block, context);
         if (block.drawingKind === "vectorShape")
           return this.createVectorShapeElement(block, block.geometry, false, 1, 1, context);
+        if (block.drawingKind === "chart")
+          return this.createChartElement(block);
         return this.createDrawingPlaceholder();
       };
       return renderTableFragment({
@@ -233482,7 +234913,7 @@ function print() { __p += __j.call(arguments, '') }
     buildLinkRenderData(link2) {
       const dataset = buildLinkDataset(link2);
       const sanitized = typeof link2.href === "string" ? sanitizeHref(link2.href) : null;
-      const anchorHref = normalizeAnchor(link2.anchor ?? link2.name ?? "");
+      const anchorHref = normalizeAnchor$1(link2.anchor ?? link2.name ?? "");
       let href = sanitized?.href ?? anchorHref;
       if (link2.version === 2)
         href = appendDocLocation(href, link2.docLocation ?? null);
@@ -234774,7 +236205,7 @@ function print() { __p += __j.call(arguments, '') }
     }
   };
   sdtMetadataCache = /* @__PURE__ */ new Map;
-  WRAP_TYPES$1 = new Set([
+  WRAP_TYPES$2 = new Set([
     "None",
     "Square",
     "Tight",
@@ -234782,18 +236213,18 @@ function print() { __p += __j.call(arguments, '') }
     "TopAndBottom",
     "Inline"
   ]);
-  WRAP_TEXT_VALUES$1 = new Set([
+  WRAP_TEXT_VALUES$2 = new Set([
     "bothSides",
     "left",
     "right",
     "largest"
   ]);
-  H_RELATIVE_VALUES$1 = new Set([
+  H_RELATIVE_VALUES$2 = new Set([
     "column",
     "page",
     "margin"
   ]);
-  V_RELATIVE_VALUES$1 = new Set([
+  V_RELATIVE_VALUES$2 = new Set([
     "paragraph",
     "page",
     "margin"
@@ -234808,7 +236239,7 @@ function print() { __p += __j.call(arguments, '') }
     "center",
     "bottom"
   ]);
-  WRAP_TYPES = new Set([
+  WRAP_TYPES$1 = new Set([
     "None",
     "Square",
     "Tight",
@@ -234816,18 +236247,18 @@ function print() { __p += __j.call(arguments, '') }
     "TopAndBottom",
     "Inline"
   ]);
-  WRAP_TEXT_VALUES = new Set([
+  WRAP_TEXT_VALUES$1 = new Set([
     "bothSides",
     "left",
     "right",
     "largest"
   ]);
-  H_RELATIVE_VALUES = new Set([
+  H_RELATIVE_VALUES$1 = new Set([
     "column",
     "page",
     "margin"
   ]);
-  V_RELATIVE_VALUES = new Set([
+  V_RELATIVE_VALUES$1 = new Set([
     "paragraph",
     "page",
     "margin"
@@ -234842,6 +236273,34 @@ function print() { __p += __j.call(arguments, '') }
     "center",
     "bottom"
   ]);
+  WRAP_TYPES = new Set([
+    "None",
+    "Square",
+    "Tight",
+    "Through",
+    "TopAndBottom",
+    "Inline"
+  ]);
+  WRAP_TEXT_VALUES = new Set([
+    "bothSides",
+    "left",
+    "right",
+    "largest"
+  ]);
+  H_RELATIVE_VALUES = new Set([
+    "column",
+    "page",
+    "margin"
+  ]);
+  V_RELATIVE_VALUES = new Set([
+    "paragraph",
+    "page",
+    "margin"
+  ]);
+  EMPTY_CHART_DATA = {
+    chartType: "unknown",
+    series: []
+  };
   INLINE_CONVERTERS_REGISTRY = {
     footnoteReference: { inlineConverter: footnoteReferenceToBlock },
     endnoteReference: { inlineConverter: endnoteReferenceToBlock },
@@ -234886,7 +236345,8 @@ function print() { __p += __j.call(arguments, '') }
     vectorShape: vectorShapeNodeToDrawingBlock,
     shapeGroup: shapeGroupNodeToDrawingBlock,
     shapeContainer: shapeContainerNodeToDrawingBlock,
-    shapeTextbox: shapeTextboxNodeToDrawingBlock
+    shapeTextbox: shapeTextboxNodeToDrawingBlock,
+    chart: chartNodeToDrawingBlock
   };
   DEFAULT_SIZE = 10 / 0.75;
   nodeHandlers2 = {
@@ -234903,7 +236363,8 @@ function print() { __p += __j.call(arguments, '') }
     vectorShape: handleVectorShapeNode,
     shapeGroup: handleShapeGroupNode,
     shapeContainer: handleShapeContainerNode,
-    shapeTextbox: handleShapeTextboxNode
+    shapeTextbox: handleShapeTextboxNode,
+    chart: handleChartNode
   };
   converters = {
     contentBlockNodeToDrawingBlock,
@@ -234912,6 +236373,7 @@ function print() { __p += __j.call(arguments, '') }
     shapeGroupNodeToDrawingBlock,
     shapeContainerNodeToDrawingBlock,
     shapeTextboxNodeToDrawingBlock,
+    chartNodeToDrawingBlock,
     tableNodeToBlock,
     paragraphToFlowBlocks
   };
@@ -244493,6 +245955,104 @@ function print() { __p += __j.call(arguments, '') }
       };
     }
   });
+  CHART_IMMUTABILITY_KEY = new PluginKey("chartImmutability");
+  chartPositionCache = /* @__PURE__ */ new WeakMap;
+  Chart = Node$13.create({
+    name: "chart",
+    group: "inline",
+    inline: true,
+    atom: true,
+    draggable: false,
+    selectable: true,
+    addOptions() {
+      return { htmlAttributes: {} };
+    },
+    addAttributes() {
+      return {
+        width: {
+          default: 400,
+          renderDOM: (attrs) => {
+            if (attrs.width == null)
+              return {};
+            return { "data-width": attrs.width };
+          }
+        },
+        height: {
+          default: 300,
+          renderDOM: (attrs) => {
+            if (attrs.height == null)
+              return {};
+            return { "data-height": attrs.height };
+          }
+        },
+        chartData: {
+          default: null,
+          rendered: false
+        },
+        chartRelId: {
+          default: null,
+          rendered: false
+        },
+        chartPartPath: {
+          default: null,
+          rendered: false
+        },
+        isAnchor: {
+          default: false,
+          rendered: false
+        },
+        anchorData: {
+          default: null,
+          rendered: false
+        },
+        wrap: {
+          default: null,
+          rendered: false
+        },
+        padding: {
+          default: null,
+          rendered: false
+        },
+        marginOffset: {
+          default: null,
+          rendered: false
+        },
+        originalAttributes: {
+          default: null,
+          rendered: false
+        },
+        originalChildren: {
+          default: null,
+          rendered: false
+        },
+        originalChildOrder: {
+          default: null,
+          rendered: false
+        },
+        originalXml: {
+          default: null,
+          rendered: false
+        },
+        drawingContent: {
+          ...Attribute2.json,
+          default: null,
+          rendered: false
+        }
+      };
+    },
+    parseDOM() {
+      return [{ tag: "sd-chart" }];
+    },
+    renderDOM({ htmlAttributes }) {
+      return ["sd-chart", {
+        ...htmlAttributes,
+        style: "display: inline-block;"
+      }];
+    },
+    addPmPlugins() {
+      return [createChartImmutabilityPlugin()];
+    }
+  });
   PassthroughBlock = Node$13.create({
     name: "passthroughBlock",
     group: "block",
@@ -249485,8 +251045,8 @@ function print() { __p += __j.call(arguments, '') }
     return isObjectLike_default(value) && hasOwnProperty$8.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
   };
   stubFalse_default = stubFalse;
-  freeExports$2 = typeof exports_src_CJCOedws_es == "object" && exports_src_CJCOedws_es && !exports_src_CJCOedws_es.nodeType && exports_src_CJCOedws_es;
-  freeModule$2 = freeExports$2 && typeof module_src_CJCOedws_es == "object" && module_src_CJCOedws_es && !module_src_CJCOedws_es.nodeType && module_src_CJCOedws_es;
+  freeExports$2 = typeof exports_src_asiscfsz_es == "object" && exports_src_asiscfsz_es && !exports_src_asiscfsz_es.nodeType && exports_src_asiscfsz_es;
+  freeModule$2 = freeExports$2 && typeof module_src_asiscfsz_es == "object" && module_src_asiscfsz_es && !module_src_asiscfsz_es.nodeType && module_src_asiscfsz_es;
   Buffer$1 = freeModule$2 && freeModule$2.exports === freeExports$2 ? _root_default.Buffer : undefined;
   isBuffer_default = (Buffer$1 ? Buffer$1.isBuffer : undefined) || stubFalse_default;
   typedArrayTags = {};
@@ -249494,8 +251054,8 @@ function print() { __p += __j.call(arguments, '') }
   typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] = typedArrayTags[objectTag$3] = typedArrayTags[regexpTag$1] = typedArrayTags[setTag$2] = typedArrayTags[stringTag$1] = typedArrayTags[weakMapTag$1] = false;
   _baseIsTypedArray_default = baseIsTypedArray;
   _baseUnary_default = baseUnary;
-  freeExports$1 = typeof exports_src_CJCOedws_es == "object" && exports_src_CJCOedws_es && !exports_src_CJCOedws_es.nodeType && exports_src_CJCOedws_es;
-  freeModule$1 = freeExports$1 && typeof module_src_CJCOedws_es == "object" && module_src_CJCOedws_es && !module_src_CJCOedws_es.nodeType && module_src_CJCOedws_es;
+  freeExports$1 = typeof exports_src_asiscfsz_es == "object" && exports_src_asiscfsz_es && !exports_src_asiscfsz_es.nodeType && exports_src_asiscfsz_es;
+  freeModule$1 = freeExports$1 && typeof module_src_asiscfsz_es == "object" && module_src_asiscfsz_es && !module_src_asiscfsz_es.nodeType && module_src_asiscfsz_es;
   freeProcess = freeModule$1 && freeModule$1.exports === freeExports$1 && _freeGlobal_default.process;
   _nodeUtil_default = function() {
     try {
@@ -249600,8 +251160,8 @@ function print() { __p += __j.call(arguments, '') }
   Stack.prototype.has = _stackHas_default;
   Stack.prototype.set = _stackSet_default;
   _Stack_default = Stack;
-  freeExports = typeof exports_src_CJCOedws_es == "object" && exports_src_CJCOedws_es && !exports_src_CJCOedws_es.nodeType && exports_src_CJCOedws_es;
-  freeModule = freeExports && typeof module_src_CJCOedws_es == "object" && module_src_CJCOedws_es && !module_src_CJCOedws_es.nodeType && module_src_CJCOedws_es;
+  freeExports = typeof exports_src_asiscfsz_es == "object" && exports_src_asiscfsz_es && !exports_src_asiscfsz_es.nodeType && exports_src_asiscfsz_es;
+  freeModule = freeExports && typeof module_src_asiscfsz_es == "object" && module_src_asiscfsz_es && !module_src_asiscfsz_es.nodeType && module_src_asiscfsz_es;
   Buffer4 = freeModule && freeModule.exports === freeExports ? _root_default.Buffer : undefined;
   allocUnsafe = Buffer4 ? Buffer4.allocUnsafe : undefined;
   _cloneBuffer_default = cloneBuffer;
@@ -257681,8 +259241,8 @@ var init_zipper_DqXT7uTa_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_CJCOedws_es();
-  init_SuperConverter_Cx2VynBq_es();
+  init_src_asiscfsz_es();
+  init_SuperConverter_BDyjQdwB_es();
   init_jszip_ChlR43oI_es();
   init_xml_js_DLE8mr0n_es();
   init_constants_CMPtQbp7_es();
@@ -264124,11 +265684,11 @@ function ensureSectPrElement2(current) {
     return cloneXmlElement2(current);
   return createSectPrElement2();
 }
-function findChild2(element3, childName) {
+function findChild3(element3, childName) {
   return element3.elements?.find((entry) => entry?.name === childName);
 }
 function ensureChild2(element3, childName) {
-  const existing = findChild2(element3, childName);
+  const existing = findChild3(element3, childName);
   if (existing)
     return existing;
   const created = { type: "element", name: childName, attributes: {}, elements: [] };
@@ -264163,7 +265723,7 @@ function writeSectPrBreakType2(sectPr, breakType) {
   setStringAttr2(typeNode, "w:val", breakType);
 }
 function readSectPrMargins2(sectPr) {
-  const pgMar = findChild2(sectPr, "w:pgMar");
+  const pgMar = findChild3(sectPr, "w:pgMar");
   if (!pgMar)
     return {};
   return {
@@ -264197,7 +265757,7 @@ function writeSectPrHeaderFooterMargins2(sectPr, margins) {
     setStringAttr2(pgMar, "w:footer", toTwipsString2(margins.footer));
 }
 function readSectPrPageSetup2(sectPr) {
-  const pgSz = findChild2(sectPr, "w:pgSz");
+  const pgSz = findChild3(sectPr, "w:pgSz");
   if (!pgSz)
     return;
   const width = toInchesFromTwips2(pgSz.attributes?.["w:w"]);
@@ -264233,7 +265793,7 @@ function writeSectPrPageSetup2(sectPr, setup) {
   }
 }
 function readSectPrColumns2(sectPr) {
-  const cols = findChild2(sectPr, "w:cols");
+  const cols = findChild3(sectPr, "w:cols");
   if (!cols)
     return;
   const count = toPositiveInteger2(cols.attributes?.["w:num"]);
@@ -264253,7 +265813,7 @@ function writeSectPrColumns2(sectPr, columns) {
     setBooleanAttr2(cols, "w:equalWidth", columns.equalWidth);
 }
 function readSectPrLineNumbering2(sectPr) {
-  const lnNumType = findChild2(sectPr, "w:lnNumType");
+  const lnNumType = findChild3(sectPr, "w:lnNumType");
   if (!lnNumType)
     return;
   const restartRaw = asString2(lnNumType.attributes?.["w:restart"]);
@@ -264282,7 +265842,7 @@ function writeSectPrLineNumbering2(sectPr, numbering) {
     setStringAttr2(lnNumType, "w:restart", numbering.restart);
 }
 function readSectPrPageNumbering2(sectPr) {
-  const pgNumType = findChild2(sectPr, "w:pgNumType");
+  const pgNumType = findChild3(sectPr, "w:pgNumType");
   if (!pgNumType)
     return;
   const formatRaw = asString2(pgNumType.attributes?.["w:fmt"]);
@@ -264309,7 +265869,7 @@ function writeSectPrTitlePage2(sectPr, enabled) {
   removeChildren2(sectPr, (entry) => entry.name === "w:titlePg");
 }
 function readSectPrVerticalAlign2(sectPr) {
-  const vAlign = findChild2(sectPr, "w:vAlign");
+  const vAlign = findChild3(sectPr, "w:vAlign");
   const raw = asString2(vAlign?.attributes?.["w:val"]);
   return isKnownValue2(raw, SECTION_VERTICAL_ALIGN_VALUES2) ? raw : undefined;
 }
@@ -264318,7 +265878,7 @@ function writeSectPrVerticalAlign2(sectPr, value) {
   setStringAttr2(vAlign, "w:val", value);
 }
 function readSectPrDirection2(sectPr) {
-  const bidi = findChild2(sectPr, "w:bidi");
+  const bidi = findChild3(sectPr, "w:bidi");
   if (!bidi)
     return;
   const value = toBooleanAttr2(bidi.attributes?.["w:val"]);
@@ -264401,13 +265961,13 @@ function writeBorderSpec2(parent, edge, border) {
     setBooleanAttr2(edgeElement, "w:frame", border.frame);
 }
 function readSectPrPageBorders2(sectPr) {
-  const pgBorders = findChild2(sectPr, "w:pgBorders");
+  const pgBorders = findChild3(sectPr, "w:pgBorders");
   if (!pgBorders)
     return;
-  const top = readBorderSpec2(findChild2(pgBorders, "w:top"));
-  const right2 = readBorderSpec2(findChild2(pgBorders, "w:right"));
-  const bottom2 = readBorderSpec2(findChild2(pgBorders, "w:bottom"));
-  const left2 = readBorderSpec2(findChild2(pgBorders, "w:left"));
+  const top = readBorderSpec2(findChild3(pgBorders, "w:top"));
+  const right2 = readBorderSpec2(findChild3(pgBorders, "w:right"));
+  const bottom2 = readBorderSpec2(findChild3(pgBorders, "w:bottom"));
+  const left2 = readBorderSpec2(findChild3(pgBorders, "w:left"));
   const display = toPageBorderDisplay2(pgBorders.attributes?.["w:display"]);
   const offsetFrom = toPageBorderOffsetFrom2(pgBorders.attributes?.["w:offsetFrom"]);
   const zOrder = toPageBorderZOrder2(pgBorders.attributes?.["w:zOrder"]);
@@ -305409,6 +306969,227 @@ function parseRelativeHeight2(value) {
 }
 var RELATIVE_HEIGHT_MIN2 = 0, RELATIVE_HEIGHT_MAX2 = 4294967295;
 
+// ../../packages/super-editor/src/core/super-converter/v3/handlers/wp/helpers/chart-helpers.js
+function normalizeChartTarget2(target) {
+  let cleaned = target;
+  if (cleaned.startsWith("/"))
+    cleaned = cleaned.slice(1);
+  if (cleaned.startsWith("./"))
+    cleaned = cleaned.slice(2);
+  while (cleaned.startsWith("../"))
+    cleaned = cleaned.slice(3);
+  if (!cleaned.startsWith("word/"))
+    cleaned = `word/${cleaned}`;
+  return cleaned;
+}
+function resolveChartPart2(docx, chartRelId, filename) {
+  if (!chartRelId || !docx)
+    return null;
+  const currentFile = filename || "document.xml";
+  const rels = docx[`word/_rels/${currentFile}.rels`] || docx["word/_rels/document.xml.rels"];
+  const relationships = findChild4(rels, "Relationships");
+  const chartRel = relationships?.elements?.find((el) => getAttr2(el, "Id") === chartRelId);
+  if (!chartRel)
+    return null;
+  const target = getAttr2(chartRel, "Target");
+  if (!target)
+    return null;
+  const chartPartPath = normalizeChartTarget2(target);
+  return { chartPartPath, chartRel };
+}
+function parseChartXml2(chartXml) {
+  const chartSpace = chartXml?.name === "c:chartSpace" ? chartXml : findChild4(chartXml, "c:chartSpace");
+  const chart = findChild4(chartSpace, "c:chart");
+  if (!chart)
+    return null;
+  const plotArea = findChild4(chart, "c:plotArea");
+  if (!plotArea)
+    return null;
+  const chartTypeEntry = findChartTypeElement2(plotArea);
+  if (!chartTypeEntry)
+    return null;
+  const { element: chartTypeEl, chartType } = chartTypeEntry;
+  const subType = extractGrouping2(chartTypeEl);
+  const barDirection = extractBarDirection2(chartTypeEl);
+  const series = parseSeries2(chartTypeEl, chartType);
+  const categoryAxis = parseAxis2(plotArea, "c:catAx");
+  const valueAxis = parseAxis2(plotArea, "c:valAx");
+  const legendPosition = parseLegendPosition2(chart);
+  const styleId = parseStyleId2(chartSpace);
+  return {
+    chartType,
+    ...subType && { subType },
+    ...barDirection && { barDirection },
+    series,
+    ...categoryAxis && { categoryAxis },
+    ...valueAxis && { valueAxis },
+    ...legendPosition && { legendPosition },
+    ...styleId != null && { styleId }
+  };
+}
+function findChartTypeElement2(plotArea) {
+  for (const el of plotArea.elements || []) {
+    if (CHART_TYPE_NAMES2.has(el.name)) {
+      return { element: el, chartType: CHART_TYPE_MAP2[el.name] };
+    }
+  }
+  for (const el of plotArea.elements || []) {
+    if (el.name?.startsWith("c:") && el.name.endsWith("Chart")) {
+      return { element: el, chartType: el.name.replace("c:", "") };
+    }
+  }
+  return null;
+}
+function extractGrouping2(chartTypeEl) {
+  const grouping = findChild4(chartTypeEl, "c:grouping");
+  return getAttr2(grouping, "val") || undefined;
+}
+function extractBarDirection2(chartTypeEl) {
+  const barDir = findChild4(chartTypeEl, "c:barDir");
+  const val = getAttr2(barDir, "val");
+  return val === "col" || val === "bar" ? val : undefined;
+}
+function parseSeries2(chartTypeEl, chartType) {
+  return findChildren3(chartTypeEl, "c:ser").map((seriesEl) => parseOneSeries2(seriesEl, chartType));
+}
+function parseOneSeries2(serEl, chartType) {
+  const name = extractSeriesName2(serEl);
+  const categories = extractCachedStrings2(findChild4(serEl, "c:cat"));
+  const values2 = extractCachedNumbers2(findChild4(serEl, "c:val"));
+  const xValues = extractCachedNumbers2(findChild4(serEl, "c:xVal"));
+  const yValues = extractCachedNumbers2(findChild4(serEl, "c:yVal"));
+  const bubbleSizes = extractCachedNumbers2(findChild4(serEl, "c:bubbleSize"));
+  if (chartType === "scatterChart" || chartType === "bubbleChart") {
+    const parsedCategoryValues = categories.map((value) => Number(value));
+    const numericCategoryValues = parsedCategoryValues.every((value) => Number.isFinite(value)) ? parsedCategoryValues : [];
+    const seriesXValues = xValues.length ? xValues : numericCategoryValues;
+    const seriesYValues = yValues.length ? yValues : values2;
+    const seriesCategories = categories.length ? categories : seriesXValues.map((value, index3) => formatChartLabel2(value, index3 + 1));
+    const seriesData = {
+      name,
+      categories: seriesCategories,
+      values: seriesYValues,
+      ...seriesXValues.length ? { xValues: seriesXValues } : {},
+      ...chartType === "bubbleChart" && bubbleSizes.length ? { bubbleSizes } : {}
+    };
+    return seriesData;
+  }
+  return { name, categories, values: values2 };
+}
+function formatChartLabel2(value, fallbackIndex) {
+  if (!Number.isFinite(value))
+    return `Category ${fallbackIndex}`;
+  if (Number.isInteger(value))
+    return String(value);
+  return String(Number(value.toFixed(3)));
+}
+function extractSeriesName2(serEl) {
+  const tx = findChild4(serEl, "c:tx");
+  const strRef = findChild4(tx, "c:strRef");
+  const strCache = findChild4(strRef, "c:strCache");
+  const pt = findChild4(strCache, "c:pt");
+  const v = findChild4(pt, "c:v");
+  return v?.elements?.[0]?.text ?? `Series ${getAttr2(findChild4(serEl, "c:idx"), "val") ?? ""}`.trim();
+}
+function extractCachedStrings2(parentEl) {
+  if (!parentEl)
+    return [];
+  const strRef = findChild4(parentEl, "c:strRef");
+  const strCache = findChild4(strRef, "c:strCache");
+  const numRef = findChild4(parentEl, "c:numRef");
+  const numCache = findChild4(numRef, "c:numCache");
+  const cache2 = strCache || numCache;
+  if (!cache2)
+    return [];
+  return findChildren3(cache2, "c:pt").sort((a2, b2) => (Number(getAttr2(a2, "idx")) || 0) - (Number(getAttr2(b2, "idx")) || 0)).map((pt) => findChild4(pt, "c:v")?.elements?.[0]?.text ?? "");
+}
+function extractCachedNumbers2(parentEl) {
+  if (!parentEl)
+    return [];
+  const numRef = findChild4(parentEl, "c:numRef");
+  const numCache = findChild4(numRef, "c:numCache");
+  if (!numCache)
+    return [];
+  return findChildren3(numCache, "c:pt").sort((a2, b2) => (Number(getAttr2(a2, "idx")) || 0) - (Number(getAttr2(b2, "idx")) || 0)).map((pt) => {
+    const text7 = findChild4(pt, "c:v")?.elements?.[0]?.text;
+    const num = Number(text7);
+    return Number.isFinite(num) ? num : 0;
+  });
+}
+function parseAxis2(plotArea, axisName) {
+  const axis = findChild4(plotArea, axisName);
+  if (!axis)
+    return;
+  const titleEl = findChild4(axis, "c:title");
+  const title = extractAxisTitle2(titleEl);
+  const scaling = findChild4(axis, "c:scaling");
+  const orientation = getAttr2(findChild4(scaling, "c:orientation"), "val");
+  const config12 = {};
+  if (title)
+    config12.title = title;
+  if (orientation === "minMax" || orientation === "maxMin")
+    config12.orientation = orientation;
+  return Object.keys(config12).length > 0 ? config12 : undefined;
+}
+function extractAxisTitle2(titleEl) {
+  if (!titleEl)
+    return;
+  const tx = findChild4(titleEl, "c:tx");
+  const rich = findChild4(tx, "c:rich");
+  const p4 = findChild4(rich, "a:p");
+  const r2 = findChild4(p4, "a:r");
+  const t = findChild4(r2, "a:t");
+  return t?.elements?.[0]?.text || undefined;
+}
+function parseLegendPosition2(chart) {
+  const legend = findChild4(chart, "c:legend");
+  if (!legend)
+    return;
+  const legendPos = findChild4(legend, "c:legendPos");
+  return getAttr2(legendPos, "val") || undefined;
+}
+function parseStyleId2(chartSpace) {
+  const altContent = findChild4(chartSpace, "mc:AlternateContent");
+  if (altContent) {
+    const choice = findChild4(altContent, "mc:Choice");
+    const c14Style = findChild4(choice, "c14:style");
+    const val2 = getAttr2(c14Style, "val");
+    if (val2 != null)
+      return Number(val2);
+    const fallback = findChild4(altContent, "mc:Fallback");
+    const fallbackStyle = findChild4(fallback, "c:style");
+    const fallbackVal = getAttr2(fallbackStyle, "val");
+    if (fallbackVal != null)
+      return Number(fallbackVal);
+  }
+  const cStyle = findChild4(chartSpace, "c:style");
+  const val = getAttr2(cStyle, "val");
+  return val != null ? Number(val) : undefined;
+}
+var CHART_URI = "http://schemas.openxmlformats.org/drawingml/2006/chart", CHART_TYPE_MAP2, CHART_TYPE_NAMES2, findChild4 = (node4, name) => node4?.elements?.find((el) => el.name === name), findChildren3 = (node4, name) => node4?.elements?.filter((el) => el.name === name) ?? [], getAttr2 = (node4, attr) => node4?.attributes?.[attr];
+var init_chart_helpers = __esm(() => {
+  CHART_TYPE_MAP2 = {
+    "c:barChart": "barChart",
+    "c:bar3DChart": "barChart",
+    "c:lineChart": "lineChart",
+    "c:line3DChart": "lineChart",
+    "c:pieChart": "pieChart",
+    "c:pie3DChart": "pieChart",
+    "c:ofPieChart": "ofPieChart",
+    "c:areaChart": "areaChart",
+    "c:area3DChart": "areaChart",
+    "c:scatterChart": "scatterChart",
+    "c:bubbleChart": "bubbleChart",
+    "c:bubble3DChart": "bubbleChart",
+    "c:doughnutChart": "doughnutChart",
+    "c:radarChart": "radarChart",
+    "c:stockChart": "stockChart",
+    "c:surfaceChart": "surfaceChart",
+    "c:surface3DChart": "surfaceChart"
+  };
+  CHART_TYPE_NAMES2 = new Set(Object.keys(CHART_TYPE_MAP2));
+});
+
 // ../../packages/super-editor/src/core/super-converter/v3/handlers/wp/helpers/encode-image-node-helpers.js
 function handleImageNode3(node4, params3, isAnchor) {
   if (!node4)
@@ -305554,6 +307335,9 @@ function handleImageNode3(node4, params3, isAnchor) {
     };
     return handleShapeGroup2(params3, node4, graphicData, size3, padding, shapeMarginOffset, anchorData, wrap6, isHidden2);
   }
+  if (uri === CHART_URI) {
+    return handleChartDrawing2(params3, node4, graphicData, size3, padding, marginOffset, anchorData, wrap6, isAnchor);
+  }
   const picture = graphicData?.elements.find((el) => el.name === "pic:pic");
   if (!picture || !picture.elements) {
     return null;
@@ -306224,6 +308008,40 @@ var DRAWING_XML_TAG2 = "w:drawing", SHAPE_URI2 = "http://schemas.microsoft.com/o
     }
   };
   return result;
+}, handleChartDrawing2 = (params3, node4, graphicData, size3, padding, marginOffset, anchorData, wrap6, isAnchor) => {
+  const chartEl = graphicData?.elements?.find((el) => el.name === "c:chart");
+  const chartRelId = chartEl?.attributes?.["r:id"];
+  if (!chartRelId)
+    return null;
+  const { docx, filename } = params3;
+  const resolved = resolveChartPart2(docx, chartRelId, filename);
+  if (!resolved)
+    return null;
+  const { chartPartPath } = resolved;
+  const chartXml = docx[chartPartPath];
+  const chartData = chartXml ? parseChartXml2(chartXml) : null;
+  const drawingNode = params3.nodes?.[0];
+  const { order: order4, originalChildren } = collectPreservedDrawingChildren2(node4);
+  return {
+    type: "chart",
+    attrs: {
+      width: size3.width || 400,
+      height: size3.height || 300,
+      chartData,
+      chartRelId,
+      chartPartPath,
+      isAnchor,
+      anchorData,
+      wrap: wrap6,
+      padding,
+      marginOffset,
+      originalAttributes: node4?.attributes,
+      originalChildren,
+      originalChildOrder: order4,
+      originalXml: drawingNode ? carbonCopy2(drawingNode) : null,
+      drawingContent: drawingNode || null
+    }
+  };
 }, buildShapePlaceholder2 = (node4, size3, padding, marginOffset, shapeType) => {
   const attrs = {
     drawingContent: {
@@ -306282,6 +308100,7 @@ var init_encode_image_node_helpers = __esm(() => {
   init_metafile_converter();
   init_tiff_converter();
   init_textbox_content_helpers();
+  init_chart_helpers();
 });
 
 // ../../packages/super-editor/src/core/super-converter/v3/handlers/wp/anchor/helpers/handle-anchor-node.js
@@ -307240,6 +309059,9 @@ function decode38(params3) {
   if (node4.attrs.isPict) {
     return null;
   }
+  if (node4.type === "chart" && node4.attrs.originalXml) {
+    return wrapTextInRun2(carbonCopy2(node4.attrs.originalXml), []);
+  }
   const childTranslator = node4.attrs.isAnchor ? translator131 : translator132;
   const resultNode = childTranslator.decode(params3);
   return wrapTextInRun2({
@@ -316334,6 +318156,7 @@ function exportSchemaToJson2(params3) {
     contentBlock: translator216,
     vectorShape: translateVectorShape2,
     shapeGroup: translateShapeGroup2,
+    chart: translator133,
     structuredContent: translator134,
     structuredContentBlock: translator134,
     documentPartObject: translator134,
@@ -330010,7 +331833,7 @@ var flatten3 = (node4, descend = true) => {
     }
   });
   return result;
-}, findChildren4 = (node4, predicate, descend) => {
+}, findChildren5 = (node4, predicate, descend) => {
   if (!node4) {
     throw new Error('Invalid "node" parameter');
   } else if (!predicate) {
@@ -330018,7 +331841,7 @@ var flatten3 = (node4, descend = true) => {
   }
   return flatten3(node4, descend).filter((child) => predicate(child.node));
 }, findInlineNodes2 = (node4, descend) => {
-  return findChildren4(node4, (child) => child.isInline, descend);
+  return findChildren5(node4, (child) => child.isInline, descend);
 };
 
 // ../../packages/super-editor/src/extensions/track-changes/trackChangesHelpers/getTrackChanges.js