@json-to-office/shared 1.2.0 → 1.3.0

package/dist/chunk-BJNBJSQG.js

@@ -0,0 +1,691 @@
+// src/rendering/types.ts
+function assertNever(value, context) {
+  const described = describeUnhandled(value);
+  throw new Error(
+    context ? `Unhandled variant in ${context}: ${described}` : `Unhandled variant: ${described}`
+  );
+}
+function describeUnhandled(value) {
+  if (value === null || typeof value !== "object") {
+    return String(value);
+  }
+  const kind = value.kind;
+  const type = value.type;
+  if (typeof kind === "string") return `kind="${kind}"`;
+  if (typeof type === "string") return `type="${type}"`;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+
+// src/rendering/diagnostics.ts
+var UnsupportedRendererFeatureError = class _UnsupportedRendererFeatureError extends Error {
+  code = "UNSUPPORTED_RENDERER_FEATURE";
+  format;
+  rendererId;
+  /** Distinct unsupported features, in first-seen order. */
+  features;
+  /** Distinct IR paths that required them, in first-seen order. */
+  paths;
+  /** Every error-severity diagnostic that produced this failure. */
+  diagnostics;
+  constructor(init) {
+    const { format, rendererId, diagnostics } = init;
+    const features = distinct(diagnostics.map((d) => d.feature));
+    const paths = distinct(diagnostics.map((d) => d.path));
+    super(formatMessage(format, rendererId, diagnostics, features));
+    this.name = "UnsupportedRendererFeatureError";
+    this.format = format;
+    this.rendererId = rendererId;
+    this.features = features;
+    this.paths = paths;
+    this.diagnostics = [...diagnostics];
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _UnsupportedRendererFeatureError);
+    }
+  }
+};
+var UnknownRendererError = class _UnknownRendererError extends Error {
+  code = "UNKNOWN_RENDERER";
+  format;
+  /** What the caller asked for. */
+  rendererId;
+  /** Every id registered for this format, in registration order. */
+  availableIds;
+  constructor(format, rendererId, availableIds) {
+    const known = availableIds.map((id) => `"${id}"`).join(", ");
+    super(
+      `Unknown ${format} renderer "${rendererId}". Available renderers: ${known}.`
+    );
+    this.name = "UnknownRendererError";
+    this.format = format;
+    this.rendererId = rendererId;
+    this.availableIds = [...availableIds];
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _UnknownRendererError);
+    }
+  }
+};
+function distinct(values) {
+  return [...new Set(values)];
+}
+function formatMessage(format, rendererId, diagnostics, features) {
+  const featureList = features.map((f) => `"${f}"`).join(", ");
+  const lines = diagnostics.map(
+    (d) => `  - ${d.feature} at ${d.path}: ${d.message}`
+  );
+  return `The "${rendererId}" ${format} renderer does not support ${features.length} required feature(s): ${featureList}.
+${lines.join("\n")}`;
+}
+function rendererError(feature, path, message) {
+  return { feature, path, severity: "error", message };
+}
+function rendererWarning(feature, path, message) {
+  return { feature, path, severity: "warning", message };
+}
+function partitionDiagnostics(diagnostics) {
+  const errors = [];
+  const warnings = [];
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.severity === "error") errors.push(diagnostic);
+    else warnings.push(diagnostic);
+  }
+  return { errors, warnings };
+}
+
+// src/rendering/capabilities.ts
+var FeatureRequirementCollector = class {
+  requirements = [];
+  seen = /* @__PURE__ */ new Set();
+  /**
+   * Record that `feature` is needed at `path`.
+   *
+   * Duplicate (feature, path) pairs collapse, so a compiler can call this
+   * unconditionally inside a loop without inflating the diagnostics.
+   */
+  require(feature, path, detail) {
+    const key = `${feature}\0${path}`;
+    if (this.seen.has(key)) return;
+    this.seen.add(key);
+    this.requirements.push(
+      detail === void 0 ? { feature, path } : { feature, path, detail }
+    );
+  }
+  /** Every recorded requirement, in first-seen order. */
+  list() {
+    return this.requirements;
+  }
+  /** Distinct required features, in first-seen order. */
+  features() {
+    return [...new Set(this.requirements.map((r) => r.feature))];
+  }
+  /** True when nothing has been required yet. */
+  isEmpty() {
+    return this.requirements.length === 0;
+  }
+};
+function diagnoseUnsupportedFeatures(required, capabilities, rendererId) {
+  const diagnostics = [];
+  for (const requirement of required) {
+    if (capabilities.has(requirement.feature)) continue;
+    diagnostics.push(
+      rendererError(
+        requirement.feature,
+        requirement.path,
+        buildMessage(requirement, rendererId)
+      )
+    );
+  }
+  return diagnostics;
+}
+function buildMessage(requirement, rendererId) {
+  const base = `the "${rendererId}" renderer cannot express "${requirement.feature}"`;
+  return requirement.detail ? `${base} (${requirement.detail})` : base;
+}
+function assertRendererSupports(required, renderer) {
+  const diagnostics = diagnoseUnsupportedFeatures(
+    required,
+    renderer.capabilities,
+    renderer.id
+  );
+  if (diagnostics.length === 0) return;
+  throw new UnsupportedRendererFeatureError({
+    format: renderer.format,
+    rendererId: renderer.id,
+    diagnostics
+  });
+}
+var RendererRegistry = class {
+  constructor(format, defaultId) {
+    this.format = format;
+    this.defaultId = defaultId;
+  }
+  renderers = /* @__PURE__ */ new Map();
+  /**
+   * Register a lazily-constructed renderer.
+   *
+   * The factory is async and only invoked on selection, so an adapter whose
+   * backend is an optional dependency is never imported unless it is chosen.
+   */
+  register(id, factory) {
+    this.renderers.set(id, factory);
+  }
+  /** Renderer ids registered for this format, in registration order. */
+  ids() {
+    return [...this.renderers.keys()];
+  }
+  /** The id used when a caller does not pass one. */
+  getDefaultId() {
+    return this.defaultId;
+  }
+  has(id) {
+    return this.renderers.has(id);
+  }
+  /**
+   * Resolve a renderer, defaulting when `id` is omitted.
+   *
+   * An unknown id is `UnknownRendererError`, which carries the id asked for and
+   * the ones that exist, so a caller boundary can answer "bad request" rather
+   * than "the server broke". A missing optional dependency is re-thrown with an
+   * actionable install hint.
+   */
+  async resolve(id) {
+    const selected = id ?? this.defaultId;
+    const factory = this.renderers.get(selected);
+    if (!factory) {
+      throw new UnknownRendererError(this.format, selected, this.ids());
+    }
+    try {
+      return await factory();
+    } catch (error) {
+      throw enrichLoadFailure(error, this.format, selected);
+    }
+  }
+};
+function enrichLoadFailure(error, format, rendererId) {
+  const message = error instanceof Error ? error.message : String(error);
+  const isMissingModule = /Cannot find (?:module|package)|ERR_MODULE_NOT_FOUND|Failed to resolve/i.test(
+    message
+  );
+  if (!isMissingModule) {
+    return error instanceof Error ? error : new Error(message);
+  }
+  const pkg = missingPackageName(message) ?? `the "${rendererId}" backend`;
+  const enriched = new Error(
+    `The "${rendererId}" ${format} renderer requires ${pkg}, which is not installed. Install it with: pnpm add ${pkg}
+Original error: ${message}`
+  );
+  enriched.name = "RendererDependencyMissingError";
+  return enriched;
+}
+function missingPackageName(message) {
+  const match = /Cannot find (?:module|package) ['"]([^'"]+)['"]/.exec(message) ?? /Failed to resolve (?:module|import)[: ]+['"]?([^'"\s]+)/.exec(message);
+  return match?.[1];
+}
+
+// src/rendering/chart-parts.ts
+var CHART_WORKBOOK_SHEET_NAME = "Sheet1";
+var CHART_PACKAGE_RELATIONSHIP = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/package";
+var CHART_WORKBOOK_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function columnLetter(index) {
+  let remaining = index;
+  let letters = "";
+  while (remaining > 0) {
+    const rest = (remaining - 1) % 26;
+    letters = String.fromCharCode(65 + rest) + letters;
+    remaining = Math.floor((remaining - 1) / 26);
+  }
+  return letters;
+}
+function cellNumber(value) {
+  return Number.isFinite(value) ? String(value) : "0";
+}
+function inlineStringCell(reference, text) {
+  return `<c r="${reference}" t="inlineStr"><is><t>${escapeXml(text)}</t></is></c>`;
+}
+function numberCell(reference, value) {
+  return `<c r="${reference}"><v>${cellNumber(value)}</v></c>`;
+}
+function sheetXml(series) {
+  const rowCount = Math.max(
+    series[0]?.labels.length ?? 0,
+    ...series.map((entry) => entry.values.length)
+  );
+  const lastColumn = columnLetter(series.length + 1);
+  const rows = [];
+  const header = [
+    `<c r="A1"/>`,
+    ...series.map(
+      (entry, index) => inlineStringCell(
+        `${columnLetter(index + 2)}1`,
+        entry.name ?? `Series ${index + 1}`
+      )
+    )
+  ];
+  rows.push(`<row r="1">${header.join("")}</row>`);
+  for (let row = 0; row < rowCount; row++) {
+    const reference = row + 2;
+    const label = series[0]?.labels[row];
+    const cells = [
+      ...label !== void 0 ? [inlineStringCell(`A${reference}`, label)] : [],
+      ...series.flatMap(
+        (entry, index) => row < entry.values.length ? [
+          numberCell(
+            `${columnLetter(index + 2)}${reference}`,
+            entry.values[row]
+          )
+        ] : []
+      )
+    ];
+    if (cells.length === 0) continue;
+    rows.push(`<row r="${reference}">${cells.join("")}</row>`);
+  }
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><dimension ref="A1:${lastColumn}${Math.max(rowCount + 1, 1)}"/><sheetData>${rows.join("")}</sheetData></worksheet>`;
+}
+var WORKBOOK_XML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name="${CHART_WORKBOOK_SHEET_NAME}" sheetId="1" r:id="rId1"/></sheets></workbook>`;
+var WORKBOOK_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/></Relationships>`;
+var ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/></Relationships>`;
+var CONTENT_TYPES = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/><Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/></Types>`;
+function chartWorkbookParts(series) {
+  return [
+    ["[Content_Types].xml", CONTENT_TYPES],
+    ["_rels/.rels", ROOT_RELS],
+    ["xl/workbook.xml", WORKBOOK_XML],
+    ["xl/_rels/workbook.xml.rels", WORKBOOK_RELS],
+    ["xl/worksheets/sheet1.xml", sheetXml(series)]
+  ];
+}
+function seriesValueReference(seriesIndex, pointCount) {
+  const column = columnLetter(seriesIndex + 2);
+  return `${CHART_WORKBOOK_SHEET_NAME}!$${column}$2:$${column}$${pointCount + 1}`;
+}
+function categoryReference(pointCount) {
+  return `${CHART_WORKBOOK_SHEET_NAME}!$A$2:$A$${pointCount + 1}`;
+}
+function seriesNameReference(seriesIndex) {
+  return `${CHART_WORKBOOK_SHEET_NAME}!$${columnLetter(seriesIndex + 2)}$1`;
+}
+function chartWorkbookRelsXml(workbookName) {
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="${CHART_PACKAGE_RELATIONSHIP}" Target="../embeddings/${escapeXml(workbookName)}"/></Relationships>`;
+}
+function fillSeriesFormulas(seriesXml, seriesIndex, categoryCount, valueCount) {
+  if (categoryCount === 0 || valueCount === 0) return seriesXml;
+  const references = [
+    seriesNameReference(seriesIndex),
+    categoryReference(categoryCount),
+    // This series' own length, not the chart's: a range longer than the cells
+    // behind it claims data the workbook does not hold, and disagrees with the
+    // `c:ptCount` the backend already cached.
+    seriesValueReference(seriesIndex, valueCount)
+  ];
+  let next = 0;
+  return seriesXml.replace(/<c:f\/>/g, () => {
+    const reference = references[next++];
+    return reference === void 0 ? "<c:f/>" : `<c:f>${escapeXml(reference)}</c:f>`;
+  });
+}
+var STROKE_COLORED = /* @__PURE__ */ new Set([
+  "line",
+  "scatter",
+  "radar"
+]);
+var POINT_COLORED = /* @__PURE__ */ new Set(["pie", "doughnut"]);
+function dataPoint(index, hex, border) {
+  return `<c:dPt><c:idx val="${index}"/><c:bubble3D val="0"/><c:spPr><a:solidFill><a:srgbClr val="${hex}"/></a:solidFill>` + (border ? outline(border.widthPoints, border.color) : "") + `</c:spPr></c:dPt>`;
+}
+function paintSeries(seriesXml, color, chartType, palette, pointCount, chart) {
+  const fillFor = (hex) => `<a:solidFill><a:srgbClr val="${hex.toUpperCase()}"/></a:solidFill>`;
+  const stroke = STROKE_COLORED.has(chartType);
+  const border = stroke ? void 0 : chart.dataBorder;
+  if (POINT_COLORED.has(chartType)) {
+    if (palette.length === 0 || pointCount === 0) return seriesXml;
+    const points = Array.from(
+      { length: pointCount },
+      (_, index) => dataPoint(index, palette[index % palette.length].toUpperCase(), border)
+    ).join("");
+    for (const anchor of ["<c:dLbls>", "<c:cat>", "<c:val>"]) {
+      if (seriesXml.includes(anchor)) {
+        return seriesXml.replace(anchor, `${points}${anchor}`);
+      }
+    }
+    return seriesXml;
+  }
+  const parts = [];
+  if (!stroke) {
+    if (color) parts.push(fillFor(color));
+    if (border) parts.push(outline(border.widthPoints, border.color));
+    if (parts.length === 0) return seriesXml;
+    return seriesXml.replace("<c:spPr/>", `<c:spPr>${parts.join("")}</c:spPr>`);
+  }
+  if (!color && chart.lineWidthPoints === void 0) return seriesXml;
+  const fill = color ? fillFor(color) : "";
+  const line = outline(chart.lineWidthPoints, color);
+  const painted = seriesXml.replace("<c:spPr/>", `<c:spPr>${line}</c:spPr>`);
+  if (!color) return painted;
+  const markerSpPr = `<c:spPr>${fill}<a:ln>${fill}</a:ln></c:spPr>`;
+  const existing = painted.match(/<c:marker>[\s\S]*?<\/c:marker>/);
+  if (!existing) {
+    return painted.replace(
+      `<c:spPr>${line}</c:spPr>`,
+      `<c:spPr>${line}</c:spPr><c:marker>${markerSpPr}</c:marker>`
+    );
+  }
+  if (existing[0].includes("<c:spPr>")) return painted;
+  return painted.replace(
+    existing[0],
+    existing[0].replace("</c:marker>", `${markerSpPr}</c:marker>`)
+  );
+}
+function axisTitle(text) {
+  return `<c:title><c:tx><c:rich><a:bodyPr/><a:lstStyle/><a:p><a:r><a:t>${escapeXml(text)}</a:t></a:r></a:p></c:rich></c:tx><c:overlay val="0"/></c:title>`;
+}
+var POINTS_TO_EMU = 12700;
+var DASH_STYLES = {
+  solid: "solid",
+  dash: "dash",
+  dot: "sysDot"
+};
+function outline(widthPoints, hex) {
+  const width = widthPoints !== void 0 ? ` w="${Math.round(widthPoints * POINTS_TO_EMU)}"` : "";
+  const fill = hex ? `<a:solidFill><a:srgbClr val="${hex.toUpperCase()}"/></a:solidFill>` : "";
+  return `<a:ln${width}>${fill}</a:ln>`;
+}
+function gridLinesElement(gridLine) {
+  if (gridLine.style === "none") return "";
+  const parts = [];
+  if (gridLine.color) {
+    parts.push(
+      `<a:solidFill><a:srgbClr val="${gridLine.color.toUpperCase()}"/></a:solidFill>`
+    );
+  }
+  const dash = gridLine.style ? DASH_STYLES[gridLine.style] : void 0;
+  if (dash) parts.push(`<a:prstDash val="${dash}"/>`);
+  if (parts.length === 0 && gridLine.size === void 0) {
+    return "<c:majorGridlines/>";
+  }
+  const width = gridLine.size !== void 0 ? ` w="${Math.round(gridLine.size * POINTS_TO_EMU)}"` : "";
+  return `<c:majorGridlines><c:spPr><a:ln${width}>${parts.join("")}</a:ln></c:spPr></c:majorGridlines>`;
+}
+function defaultRunProperties(font) {
+  if (!font) return "<a:defRPr/>";
+  const attrs = (font.fontSize !== void 0 ? ` sz="${Math.round(font.fontSize * 100)}"` : "") + (font.bold !== void 0 ? ` b="${font.bold ? 1 : 0}"` : "");
+  const children = (font.color ? `<a:solidFill><a:srgbClr val="${font.color.toUpperCase()}"/></a:solidFill>` : "") + (font.fontFamily ? `<a:latin typeface="${escapeXml(font.fontFamily)}"/>` : "");
+  return children ? `<a:defRPr${attrs}>${children}</a:defRPr>` : `<a:defRPr${attrs}/>`;
+}
+function hasTextStyle(font) {
+  return !!font && Object.keys(font).length > 0;
+}
+function textProperties(rotation, font) {
+  const bodyPr = rotation !== void 0 ? `<a:bodyPr rot="${Math.round(rotation * 6e4)}" spcFirstLastPara="1" vertOverflow="ellipsis" vert="horz" wrap="square" anchorCtr="1"/>` : "<a:bodyPr/>";
+  return `<c:txPr>${bodyPr}<a:lstStyle/><a:p><a:pPr>` + defaultRunProperties(font) + `</a:pPr><a:endParaRPr lang="en-US"/></a:p></c:txPr>`;
+}
+function rewriteAxis(axisXml, edits) {
+  const axPos = axisXml.match(/<c:axPos[^>]*\/>/);
+  const crossAxAt = axisXml.indexOf("<c:crossAx");
+  if (!axPos || crossAxAt < 0) return axisXml;
+  const headEnd = axisXml.indexOf(axPos[0]) + axPos[0].length;
+  let head = axisXml.slice(0, headEnd);
+  const middle = axisXml.slice(headEnd, crossAxAt);
+  let tail = axisXml.slice(crossAxAt);
+  if (edits.hidden !== void 0) {
+    head = head.replace(
+      /<c:delete val="[^"]*"\/>/,
+      `<c:delete val="${edits.hidden ? 1 : 0}"/>`
+    );
+  }
+  if (edits.max !== void 0 || edits.min !== void 0) {
+    const bounds = (edits.max !== void 0 ? `<c:max val="${edits.max}"/>` : "") + (edits.min !== void 0 ? `<c:min val="${edits.min}"/>` : "");
+    head = head.replace("</c:scaling>", `${bounds}</c:scaling>`);
+  }
+  const existingMajorGrid = middle.match(
+    /<c:majorGridlines(?:\/>|>[\s\S]*?<\/c:majorGridlines>)/
+  )?.[0];
+  const existingMinorGrid = middle.match(
+    /<c:minorGridlines(?:\/>|>[\s\S]*?<\/c:minorGridlines>)/
+  )?.[0];
+  const existingTitle = middle.match(/<c:title>[\s\S]*?<\/c:title>/)?.[0];
+  const existingNumFmt = middle.match(/<c:numFmt[^>]*\/>/)?.[0];
+  const existingMajorTick = middle.match(/<c:majorTickMark[^>]*\/>/)?.[0];
+  const existingMinorTick = middle.match(/<c:minorTickMark[^>]*\/>/)?.[0];
+  const existingTickLblPos = middle.match(/<c:tickLblPos[^>]*\/>/)?.[0];
+  const existingSpPr = middle.match(/<c:spPr>[\s\S]*?<\/c:spPr>/)?.[0];
+  const existingTxPr = middle.match(/<c:txPr>[\s\S]*?<\/c:txPr>/)?.[0];
+  const rebuilt = [
+    edits.gridLine ? gridLinesElement(edits.gridLine) : existingMajorGrid ?? "",
+    existingMinorGrid ?? "",
+    // An axis that already carries a title keeps it: writing a second one is a
+    // repair prompt, not a duplicated label.
+    existingTitle ?? (edits.title ? axisTitle(edits.title) : ""),
+    edits.numberFormat !== void 0 ? `<c:numFmt formatCode="${escapeXml(edits.numberFormat)}" sourceLinked="0"/>` : existingNumFmt ?? "",
+    existingMajorTick ?? "",
+    existingMinorTick ?? "",
+    existingTickLblPos ?? "",
+    edits.lineVisible === false ? "<c:spPr><a:ln><a:noFill/></a:ln></c:spPr>" : existingSpPr ?? "",
+    edits.labelRotation !== void 0 || hasTextStyle(edits.labelFont) ? textProperties(edits.labelRotation, edits.labelFont) : existingTxPr ?? ""
+  ].join("");
+  if (edits.majorUnit !== void 0 && !tail.includes("<c:majorUnit")) {
+    const crosses = tail.match(/<c:cross(?:es|esAt|Between)[^>]*\/>/g);
+    const anchor = crosses?.[crosses.length - 1];
+    if (anchor) {
+      const at = tail.lastIndexOf(anchor) + anchor.length;
+      tail = tail.slice(0, at) + `<c:majorUnit val="${edits.majorUnit}"/>` + tail.slice(at);
+    }
+  }
+  return head + rebuilt + tail;
+}
+function editAxis(chartXml, tag, edits, occurrence = 0) {
+  if (!edits || Object.keys(edits).length === 0) return chartXml;
+  const open = `<c:${tag}>`;
+  let start = -1;
+  for (let seen = 0; seen <= occurrence; seen++) {
+    start = chartXml.indexOf(open, start + 1);
+    if (start < 0) return chartXml;
+  }
+  const end = chartXml.indexOf(`</c:${tag}>`, start);
+  if (end < 0) return chartXml;
+  return chartXml.slice(0, start) + rewriteAxis(chartXml.slice(start, end), edits) + chartXml.slice(end);
+}
+function setVaryColors(chartXml, chartType) {
+  if (POINT_COLORED.has(chartType)) return chartXml;
+  if (chartXml.includes("<c:varyColors")) return chartXml;
+  return chartXml.replace("<c:ser>", '<c:varyColors val="0"/><c:ser>');
+}
+function setBarGrouping(chartXml, grouping) {
+  const start = chartXml.indexOf("<c:barChart>");
+  if (start < 0) {
+    return chartXml.replace(
+      /<c:grouping val="[^"]*"\/>/,
+      `<c:grouping val="${escapeXml(grouping)}"/>`
+    );
+  }
+  const end = chartXml.indexOf("</c:barChart>", start);
+  if (end < 0) return chartXml;
+  let plot = chartXml.slice(start, end).replace(
+    /<c:grouping val="[^"]*"\/>/,
+    `<c:grouping val="${escapeXml(grouping)}"/>`
+  );
+  if (!plot.includes("<c:overlap")) {
+    const gapWidth = plot.match(/<c:gapWidth val="[^"]*"\/>/)?.[0];
+    if (gapWidth) {
+      const at = plot.indexOf(gapWidth) + gapWidth.length;
+      plot = plot.slice(0, at) + '<c:overlap val="100"/>' + plot.slice(at);
+    } else {
+      const axId = plot.indexOf("<c:axId");
+      if (axId >= 0) {
+        plot = plot.slice(0, axId) + '<c:overlap val="100"/>' + plot.slice(axId);
+      }
+    }
+  }
+  return chartXml.slice(0, start) + plot + chartXml.slice(end);
+}
+function styleChartTitle(chartXml, font) {
+  if (!hasTextStyle(font)) return chartXml;
+  const plotAreaAt = chartXml.indexOf("<c:plotArea>");
+  if (plotAreaAt < 0) return chartXml;
+  const head = chartXml.slice(0, plotAreaAt);
+  if (!head.includes("<c:title>")) return chartXml;
+  const styled = head.replace(
+    "<a:p><a:r>",
+    `<a:p><a:pPr>${defaultRunProperties(font)}</a:pPr><a:r>`
+  );
+  return styled + chartXml.slice(plotAreaAt);
+}
+function styleLegend(chartXml, font) {
+  if (!hasTextStyle(font)) return chartXml;
+  const start = chartXml.indexOf("<c:legend>");
+  if (start < 0) return chartXml;
+  const end = chartXml.indexOf("</c:legend>", start);
+  if (end < 0) return chartXml;
+  const legend = chartXml.slice(start, end).replace("<a:defRPr/>", defaultRunProperties(font));
+  return chartXml.slice(0, start) + legend + chartXml.slice(end);
+}
+function styleDataLabels(chartXml, font) {
+  if (!hasTextStyle(font)) return chartXml;
+  return chartXml.replace(
+    /<c:dLbls>(?!<c:txPr>)/g,
+    `<c:dLbls>${textProperties(void 0, font)}`
+  );
+}
+function spliceChartXml(chartXml, chart, relationshipId = "rId1") {
+  const pointCount = chart.series[0]?.labels.length ?? 0;
+  let seriesIndex = 0;
+  let result = chartXml.replace(/<c:ser>[\s\S]*?<\/c:ser>/g, (seriesXml) => {
+    const index = seriesIndex++;
+    const withFormulas = fillSeriesFormulas(
+      seriesXml,
+      index,
+      pointCount,
+      chart.series[index]?.values.length ?? pointCount
+    );
+    const color = chart.colors.length > 0 ? chart.colors[index % chart.colors.length] : void 0;
+    return paintSeries(
+      withFormulas,
+      color,
+      chart.chartType,
+      chart.colors,
+      pointCount,
+      chart
+    );
+  });
+  if (chart.chartType === "scatter") {
+    result = editAxis(result, "valAx", chart.categoryAxis, 0);
+    result = editAxis(result, "valAx", chart.valueAxis, 1);
+  } else {
+    result = editAxis(result, "catAx", chart.categoryAxis);
+    result = editAxis(result, "valAx", chart.valueAxis);
+  }
+  result = styleChartTitle(result, chart.titleFont);
+  result = styleLegend(result, chart.legendFont);
+  result = styleDataLabels(result, chart.dataLabelFont);
+  if (chart.radarStyle) {
+    result = result.replace(
+      /<c:radarStyle val="[^"]*"\/>/,
+      `<c:radarStyle val="${escapeXml(chart.radarStyle)}"/>`
+    );
+  }
+  if (chart.legendPosition) {
+    result = result.replace(
+      /<c:legendPos val="[^"]*"\/>/,
+      `<c:legendPos val="${escapeXml(chart.legendPosition)}"/>`
+    );
+  }
+  if (chart.barGrouping && chart.barGrouping !== "clustered") {
+    result = setBarGrouping(result, chart.barGrouping);
+  }
+  result = setVaryColors(result, chart.chartType);
+  if (result.includes("<c:externalData")) return result;
+  return result.replace(
+    "</c:chartSpace>",
+    `<c:externalData r:id="${escapeXml(relationshipId)}"><c:autoUpdate val="0"/></c:externalData></c:chartSpace>`
+  );
+}
+var VALUE_SEPARATOR = "
";
+var SERIES_SEPARATOR = "";
+var NAMED_ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+function decodeXmlEntities(value) {
+  return value.replace(
+    /&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g,
+    (match, body) => {
+      if (body.startsWith("#x") || body.startsWith("#X")) {
+        return String.fromCodePoint(Number.parseInt(body.slice(2), 16));
+      }
+      if (body.startsWith("#")) {
+        return String.fromCodePoint(Number.parseInt(body.slice(1), 10));
+      }
+      return NAMED_ENTITIES[body] ?? match;
+    }
+  );
+}
+function chartPartSignature(chartXml) {
+  return (chartXml.match(/<c:ser>[\s\S]*?<\/c:ser>/g) ?? []).map(
+    (series) => [...series.matchAll(/<c:v>([\s\S]*?)<\/c:v>/g)].map((match) => decodeXmlEntities(match[1])).join(VALUE_SEPARATOR)
+  ).join(SERIES_SEPARATOR);
+}
+function chartInputSignature(chart) {
+  const categories = chart.series[0]?.labels ?? [];
+  return chart.series.map(
+    (series, index) => [
+      series.name ?? `Series ${index + 1}`,
+      ...categories,
+      ...series.values.map((value) => String(value))
+    ].join(VALUE_SEPARATOR)
+  ).join(SERIES_SEPARATOR);
+}
+function matchChartParts(parts, charts) {
+  const unmatched = new Set(charts.keys());
+  const matched = [];
+  for (const [ordinal, xml] of parts) {
+    const signature = chartPartSignature(xml);
+    const index = [...unmatched].find(
+      (candidate) => chartInputSignature(charts[candidate]) === signature
+    );
+    if (index === void 0) continue;
+    unmatched.delete(index);
+    matched.push({ ordinal, xml, chart: charts[index] });
+  }
+  if (unmatched.size > 0) {
+    const names = [...unmatched].map((index) => charts[index].series[0]?.name ?? `chart ${index + 1}`).join(", ");
+    throw new Error(
+      `Could not match ${unmatched.size} chart(s) to an emitted chart part (${names}). The package would ship a chart without its workbook.`
+    );
+  }
+  return matched;
+}
+
+export {
+  assertNever,
+  UnsupportedRendererFeatureError,
+  UnknownRendererError,
+  rendererError,
+  rendererWarning,
+  partitionDiagnostics,
+  FeatureRequirementCollector,
+  diagnoseUnsupportedFeatures,
+  assertRendererSupports,
+  RendererRegistry,
+  CHART_WORKBOOK_SHEET_NAME,
+  CHART_PACKAGE_RELATIONSHIP,
+  CHART_WORKBOOK_CONTENT_TYPE,
+  columnLetter,
+  chartWorkbookParts,
+  seriesValueReference,
+  categoryReference,
+  seriesNameReference,
+  chartWorkbookRelsXml,
+  spliceChartXml,
+  chartPartSignature,
+  chartInputSignature,
+  matchChartParts
+};
+//# sourceMappingURL=chunk-BJNBJSQG.js.map