ooxml-core 0.21.2 → 0.22.0

package/dist/chart/index.mjs

@@ -378,4 +378,230 @@ function aggregateByCategory(values, rawCategories) {
   });
 }
 
-export { aggregateByCategory, axisTargetIntervals, computeBoxStats, computeHistogramBins, computeLinearRegression, computeRSquared, computeStackedSeriesPlots, fitPolynomial, groupRowsByCategory, niceAxisStep, niceValueAxisBounds, resolveBlankDisplay, scottBinCount, visibleRuns };
+// chart/treemap-squarify.ts
+function worstAspectRatio(areas, side) {
+  const sum = areas.reduce((total, area) => total + area, 0);
+  const max = Math.max(...areas);
+  const min = Math.min(...areas);
+  const sideSq = side * side;
+  const sumSq = sum * sum;
+  return Math.max(sideSq * max / sumSq, sumSq / (sideSq * min));
+}
+function squarify(nodes, box) {
+  const sorted = [...nodes].sort((a, b) => b.weight - a.weight);
+  const total = sorted.reduce((sum, node) => sum + node.weight, 0);
+  const scale = total > 0 ? box.w * box.h / total : box.w * box.h / sorted.length;
+  const items = sorted.map((node) => ({ node, area: (total > 0 ? node.weight : 1) * scale }));
+  const result = [];
+  let rect = { ...box };
+  let remaining = items;
+  for (let first = remaining[0]; first !== void 0; first = remaining[0]) {
+    const side = Math.min(rect.w, rect.h);
+    let row = [first];
+    let rowAreas = [first.area];
+    let worst = worstAspectRatio(rowAreas, side);
+    let cursor = 1;
+    for (let next = remaining[cursor]; next !== void 0; next = remaining[cursor]) {
+      const candidateAreas = [...rowAreas, next.area];
+      const candidateWorst = worstAspectRatio(candidateAreas, side);
+      if (candidateWorst > worst) {
+        break;
+      }
+      row = [...row, next];
+      rowAreas = candidateAreas;
+      worst = candidateWorst;
+      cursor++;
+    }
+    const rowTotalArea = rowAreas.reduce((sum, area) => sum + area, 0);
+    const thickness = side > 0 ? rowTotalArea / side : 0;
+    const layoutVertically = rect.w >= rect.h;
+    let offset = layoutVertically ? rect.y : rect.x;
+    for (const item of row) {
+      const length = thickness > 0 ? item.area / thickness : 0;
+      if (layoutVertically) {
+        result.push([item.node, { x: rect.x, y: offset, w: thickness, h: length }]);
+      } else {
+        result.push([item.node, { x: offset, y: rect.y, w: length, h: thickness }]);
+      }
+      offset += length;
+    }
+    rect = layoutVertically ? { ...rect, x: rect.x + thickness, w: rect.w - thickness } : { ...rect, y: rect.y + thickness, h: rect.h - thickness };
+    remaining = remaining.slice(row.length);
+  }
+  return result;
+}
+
+// chart/trendline-equation.ts
+var SIGNIFICANT_DIGITS = 4;
+function formatTrendlineCoefficient(value) {
+  if (!Number.isFinite(value) || value === 0) {
+    return "0";
+  }
+  const rounded = Number(value.toPrecision(SIGNIFICANT_DIGITS));
+  return rounded === 0 ? "0" : String(rounded);
+}
+function signedTerm(value) {
+  return { sign: value < 0 ? "-" : "+", abs: formatTrendlineCoefficient(Math.abs(value)) };
+}
+function formatLinearEquation(slope, intercept) {
+  const { sign, abs } = signedTerm(intercept);
+  return `y = ${formatTrendlineCoefficient(slope)}x ${sign} ${abs}`;
+}
+function formatExponentialEquation(a, b) {
+  return `y = ${formatTrendlineCoefficient(a)} e^(${formatTrendlineCoefficient(b)}x)`;
+}
+function formatLogarithmicEquation(slope, intercept) {
+  const { sign, abs } = signedTerm(intercept);
+  return `y = ${formatTrendlineCoefficient(slope)}ln(x) ${sign} ${abs}`;
+}
+function formatPowerEquation(a, b) {
+  return `y = ${formatTrendlineCoefficient(a)}x^${formatTrendlineCoefficient(b)}`;
+}
+function formatPolynomialEquation(coeffsAscending) {
+  const order = coeffsAscending.length - 1;
+  let out = "y = ";
+  for (let power = order; power >= 0; power--) {
+    const coeff = coeffsAscending[power] ?? 0;
+    const { sign, abs } = signedTerm(coeff);
+    const variable = power === 0 ? "" : power === 1 ? "x" : `x^${power}`;
+    out += power === order ? `${sign === "-" ? "-" : ""}${abs}${variable}` : ` ${sign} ${abs}${variable}`;
+  }
+  return out;
+}
+
+// chart/radar-geometry.ts
+function radarAngle(index, catCount) {
+  const n = Math.max(catCount, 1);
+  return Math.PI * 2 * index / n - Math.PI / 2;
+}
+function computeRadarPoints(values, maxVal, radius, cx, cy, catCount) {
+  const denom = maxVal > 0 ? maxVal : 1;
+  return values.slice(0, Math.max(catCount, 1)).map((val, i) => {
+    const angle = radarAngle(i, catCount), r = Math.abs(val) / denom * radius;
+    return { x: cx + r * Math.cos(angle), y: cy + r * Math.sin(angle) };
+  });
+}
+function radarRingPoints(cx, cy, rr, catCount) {
+  const n = Math.max(catCount, 1);
+  return Array.from({ length: n }, (_, i) => {
+    const angle = radarAngle(i, n);
+    return `${(cx + rr * Math.cos(angle)).toFixed(2)},${(cy + rr * Math.sin(angle)).toFixed(2)}`;
+  }).join(" ");
+}
+
+// chart/pie-best-fit.ts
+var PX_PER_PT = 4 / 3;
+var BEST_FIT_RIM_INSET = 4 * PX_PER_PT;
+var BEST_FIT_EDGE_TOLERANCE = 1.5 * PX_PER_PT;
+var BEST_FIT_OUTSIDE_GAP = 2 * PX_PER_PT;
+function farCorner(x, y, w, h) {
+  return Math.hypot(Math.abs(x) + w / 2, Math.abs(y) + h / 2);
+}
+function insideDistance(ux, uy, w, h, limit) {
+  if (farCorner(0, 0, w, h) > limit) {
+    return void 0;
+  }
+  let lo = 0;
+  let hi = limit;
+  for (let i = 0; i < 40; i++) {
+    const mid = (lo + hi) / 2;
+    if (farCorner(mid * ux, mid * uy, w, h) > limit) {
+      hi = mid;
+    } else {
+      lo = mid;
+    }
+  }
+  return lo;
+}
+function edgeOverhang(x, y, w, h, slice) {
+  let worst = Number.NEGATIVE_INFINITY;
+  const corners = [
+    [-w / 2, -h / 2],
+    [w / 2, -h / 2],
+    [-w / 2, h / 2],
+    [w / 2, h / 2]
+  ];
+  for (const [dx, dy] of corners) {
+    const px = x + dx;
+    const py = y + dy;
+    const fromStart = Math.cos(slice.startAngle) * py - Math.sin(slice.startAngle) * px;
+    const fromEnd = Math.sin(slice.endAngle) * px - Math.cos(slice.endAngle) * py;
+    worst = Math.max(worst, -fromStart, -fromEnd);
+  }
+  return worst;
+}
+function placeBestFitLabel(slice, w, h) {
+  const mid = (slice.startAngle + slice.endAngle) / 2;
+  const ux = Math.cos(mid);
+  const uy = Math.sin(mid);
+  const distance = insideDistance(ux, uy, w, h, slice.outerR - BEST_FIT_RIM_INSET);
+  if (distance !== void 0) {
+    const x = distance * ux;
+    const y = distance * uy;
+    const reflex = slice.endAngle - slice.startAngle >= Math.PI;
+    if (reflex || edgeOverhang(x, y, w, h, slice) <= BEST_FIT_EDGE_TOLERANCE) {
+      return { x: slice.cx + x, y: slice.cy + y, inside: true };
+    }
+  }
+  const extent = Math.abs(ux) * w / 2 + Math.abs(uy) * h / 2;
+  const outside = slice.outerR + BEST_FIT_OUTSIDE_GAP + extent;
+  return { x: slice.cx + outside * ux, y: slice.cy + outside * uy, inside: false };
+}
+
+// chart/pie-label-collision.ts
+var LABEL_COLLISION_GAP = 2;
+function boxDistanceToCentre(box, y, disc) {
+  const nearestX = Math.max(box.x - box.w / 2, Math.min(disc.cx, box.x + box.w / 2));
+  const nearestY = Math.max(y - box.h / 2, Math.min(disc.cy, y + box.h / 2));
+  return Math.hypot(nearestX - disc.cx, nearestY - disc.cy);
+}
+function clearOfDisc(box, y, disc) {
+  if (boxDistanceToCentre(box, y, disc) >= disc.r) {
+    return 0;
+  }
+  const sign = box.x >= disc.cx ? 1 : -1;
+  let dx = 0;
+  while (dx < disc.r * 2 && boxDistanceToCentre({ ...box, x: box.x + sign * dx }, y, disc) < disc.r) {
+    dx += 1;
+  }
+  return sign * dx;
+}
+function overlapsX(a, b) {
+  return Math.abs(a.x - b.x) < (a.w + b.w) / 2;
+}
+function sweepSide(boxes, minY, maxY) {
+  const sorted = [...boxes].sort((a, b) => a.y - b.y || a.id - b.id);
+  const ys = sorted.map((box) => box.y);
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = sorted[i - 1];
+    const box = sorted[i];
+    if (overlapsX(prev, box)) {
+      ys[i] = Math.max(ys[i], ys[i - 1] + (prev.h + box.h) / 2 + LABEL_COLLISION_GAP);
+    }
+  }
+  for (let i = sorted.length - 1; i >= 0; i--) {
+    const box = sorted[i];
+    const limit = i === sorted.length - 1 ? maxY - box.h / 2 : ys[i + 1] - (box.h + sorted[i + 1].h) / 2 - LABEL_COLLISION_GAP;
+    if (ys[i] > limit) {
+      ys[i] = Math.max(limit, minY + box.h / 2);
+    }
+  }
+  return new Map(sorted.map((box, i) => [box.id, ys[i]]));
+}
+function nudgeOutsideLabels(boxes, disc, minY, maxY) {
+  const resolved = /* @__PURE__ */ new Map();
+  for (const side of [
+    boxes.filter((box) => box.x >= disc.cx),
+    boxes.filter((box) => box.x < disc.cx)
+  ]) {
+    for (const [id, y] of sweepSide(side, minY, maxY)) {
+      resolved.set(id, y);
+    }
+  }
+  return boxes.map((box) => {
+    const y = resolved.get(box.id) ?? box.y;
+    return { id: box.id, dx: y === box.y ? 0 : clearOfDisc(box, y, disc), dy: y - box.y };
+  });
+}
+
+export { BEST_FIT_EDGE_TOLERANCE, BEST_FIT_OUTSIDE_GAP, BEST_FIT_RIM_INSET, LABEL_COLLISION_GAP, aggregateByCategory, axisTargetIntervals, computeBoxStats, computeHistogramBins, computeLinearRegression, computeRSquared, computeRadarPoints, computeStackedSeriesPlots, fitPolynomial, formatExponentialEquation, formatLinearEquation, formatLogarithmicEquation, formatPolynomialEquation, formatPowerEquation, formatTrendlineCoefficient, groupRowsByCategory, niceAxisStep, niceValueAxisBounds, nudgeOutsideLabels, placeBestFitLabel, radarAngle, radarRingPoints, resolveBlankDisplay, scottBinCount, squarify, visibleRuns };

package/dist/chart/pie-best-fit.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Where PowerPoint puts a pie data label at `c:dLblPos val="bestFit"`.
+ *
+ * COM ground truth (`chart-pie-best-fit.pptx`: eight pies of different slice
+ * sizes, boxed 12pt labels, measured from `Slide.Export` pixels at two pie
+ * sizes, R = 89.6pt and 190.3pt):
+ *
+ *  - A label that fits inside its slice sits INSIDE it, on the slice's
+ *    mid-angle, pushed out until the box corner farthest from the centre is
+ *    4pt inside the rim. The 4pt is the same for both pie sizes, so it is a
+ *    fixed inset, not a fraction of the radius. (The renderer used to put
+ *    every such label at 0.7 of the radius, well short of PowerPoint's.)
+ *  - "Fits" means that box, so placed, stays inside the slice's two edges:
+ *    PowerPoint tolerates about 1.5pt of overhang (a 10% slice with a
+ *    two-line label is on the boundary: one of three stays inside).
+ *  - A label that does not fit goes OUTSIDE, on the mid-angle, with the box
+ *    side facing the pie 2pt beyond the rim. PowerPoint then nudges outside
+ *    labels apart when they collide and draws leader lines to the nudged
+ *    ones; that pass is `chart-pie-label-collision` (an approximation).
+ *
+ * All lengths are in the chart's px space (1pt = 4/3px).
+ *
+ * @module chart/pie-best-fit
+ */
+/** COM: the farthest box corner of an inside label sits this far inside the rim. */
+export declare const BEST_FIT_RIM_INSET: number;
+/** COM: how far a box may overhang a slice edge and still count as inside. */
+export declare const BEST_FIT_EDGE_TOLERANCE: number;
+/** COM: the gap between the rim and an outside label's box. */
+export declare const BEST_FIT_OUTSIDE_GAP: number;
+/** A slice as the placement needs it: centre, radius and its two edge angles. */
+export interface BestFitSlice {
+    cx: number;
+    cy: number;
+    outerR: number;
+    /** Radians, SVG convention (0 = 3 o'clock, clockwise positive). */
+    startAngle: number;
+    endAngle: number;
+}
+/** Where the label box's centre goes, and whether that is inside the slice. */
+export interface BestFitPlacement {
+    x: number;
+    y: number;
+    inside: boolean;
+}
+/**
+ * Place a `w x h` label box for a slice at `bestFit` (see the module doc).
+ * A slice of half the pie or more always has room, so its label stays inside.
+ */
+export declare function placeBestFitLabel(slice: BestFitSlice, w: number, h: number): BestFitPlacement;
+//# sourceMappingURL=pie-best-fit.d.ts.map

package/dist/chart/pie-best-fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pie-best-fit.d.ts","sourceRoot":"","sources":["../../chart/pie-best-fit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,oFAAoF;AACpF,eAAO,MAAM,kBAAkB,QAAgB,CAAC;AAChD,8EAA8E;AAC9E,eAAO,MAAM,uBAAuB,QAAkB,CAAC;AACvD,+DAA+D;AAC/D,eAAO,MAAM,oBAAoB,QAAgB,CAAC;AAElD,iFAAiF;AACjF,MAAM,WAAW,YAAY;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,OAAO,CAAC;CAChB;AAsDD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAiB7F"}

package/dist/chart/pie-label-collision.d.ts

@@ -0,0 +1,48 @@
+/**
+ * chart-pie-label-collision.ts: nudge colliding OUTSIDE pie labels apart.
+ *
+ * At `c:dLblPos val="bestFit"` PowerPoint puts a label that does not fit in its
+ * slice outside the rim; when two such labels overlap it moves them apart
+ * (vertically, within their own side of the pie) and draws a leader line to
+ * each one it moved. This module is the pure geometry half: it takes the
+ * outside label boxes and returns how far each one moves. The caller decides
+ * what to draw (a moved label gets a leader line; see `chart-pie-labels`).
+ *
+ * The algorithm is a per-side sweep: labels on the right (or left) of the pie
+ * are sorted top to bottom, each is pushed below the previous one when they
+ * overlap, and if the stack then runs past the bottom bound it is shifted back
+ * up. Constants are not COM-measured; the gap is one line of breathing room.
+ *
+ * @module chart/pie-label-collision
+ */
+/** Minimum vertical gap (px) kept between two nudged labels. */
+export declare const LABEL_COLLISION_GAP = 2;
+/** One outside label box: its centre and size, keyed by an opaque id. */
+export interface OutsideLabelBox {
+    id: number;
+    /** Box centre, in the same space as `pieCx`. */
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** How far one label moves (`dx`/`dy` are 0 when it stays put). */
+export interface LabelNudge {
+    id: number;
+    dx: number;
+    dy: number;
+}
+/** The pie disc a nudged label must never be pushed into. */
+export interface PieDisc {
+    cx: number;
+    cy: number;
+    r: number;
+}
+/**
+ * Compute the vertical nudges that separate overlapping outside labels.
+ * `disc` splits the labels into a left and a right column and keeps every
+ * nudged label outside the pie; `minY`/`maxY` bound the drawing area. Labels
+ * that do not collide get `dx: 0, dy: 0`.
+ */
+export declare function nudgeOutsideLabels(boxes: ReadonlyArray<OutsideLabelBox>, disc: PieDisc, minY: number, maxY: number): LabelNudge[];
+//# sourceMappingURL=pie-label-collision.d.ts.map

package/dist/chart/pie-label-collision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pie-label-collision.d.ts","sourceRoot":"","sources":["../../chart/pie-label-collision.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,gEAAgE;AAChE,eAAO,MAAM,mBAAmB,IAAI,CAAC;AAErC,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,mEAAmE;AACnE,MAAM,WAAW,UAAU;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AAED,6DAA6D;AAC7D,MAAM,WAAW,OAAO;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;CACV;AA+DD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC,EACrC,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACV,UAAU,EAAE,CAcd"}

package/dist/chart/radar-geometry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * chart-radar-geometry.ts: radar (spider) chart polar-coordinate geometry,
+ * split out of `chart-view-model-points.ts` to keep that file within the
+ * repo's ~300-LOC limit. Re-exported from there (and from `chart-view-model.ts`)
+ * so the public import surface is unchanged.
+ *
+ * @module chart/radar-geometry
+ */
+/** Angle (radians) of the i-th radar spoke; 0 points up (-90°), clockwise. */
+export declare function radarAngle(index: number, catCount: number): number;
+export interface RadarPoint {
+    x: number;
+    y: number;
+}
+/** Project a series' values onto radar (polar) coordinates around (cx, cy). */
+export declare function computeRadarPoints(values: ReadonlyArray<number>, maxVal: number, radius: number, cx: number, cy: number, catCount: number): RadarPoint[];
+/** Points string for a radar gridline ring at radius `rr`. */
+export declare function radarRingPoints(cx: number, cy: number, rr: number, catCount: number): string;
+//# sourceMappingURL=radar-geometry.d.ts.map

package/dist/chart/radar-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radar-geometry.d.ts","sourceRoot":"","sources":["../../chart/radar-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,8EAA8E;AAC9E,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGlE;AAED,MAAM,WAAW,UAAU;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,EAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,GACd,UAAU,EAAE,CAOd;AAED,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAM5F"}

package/dist/chart/treemap-squarify.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Squarified treemap layout algorithm, generic over any weighted node.
+ * Split out of `chart-treemap-hierarchy.ts` (which supplies the node/box
+ * shapes and drives the recursive render) to keep each file under the
+ * repo's ~300-LOC budget.
+ *
+ * @module chart/treemap-squarify
+ */
+export interface TreemapBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+interface WeightedNode {
+    weight: number;
+}
+/**
+ * Squarified treemap layout (Bruls, Huizing & van Wijk): repeatedly lays out
+ * the widest possible "row" of items along the box's shorter side, adding
+ * items to the row only while doing so keeps improving (or not worsening)
+ * that row's worst aspect ratio, so cells stay close to square instead of
+ * degenerating into thin slivers the way a plain alternating slice-and-dice
+ * split does. COM-verified against charts-com.pptx slide 28 (chartEx3.xml):
+ * PowerPoint's own treemap mixes row and column splits within the SAME
+ * parent region (e.g. a tall cell beside a further row/column split), which
+ * a single alternating dimension split can never reproduce.
+ */
+export declare function squarify<TNode extends WeightedNode>(nodes: readonly TNode[], box: TreemapBox): Array<[TNode, TreemapBox]>;
+export {};
+//# sourceMappingURL=treemap-squarify.d.ts.map

package/dist/chart/treemap-squarify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treemap-squarify.d.ts","sourceRoot":"","sources":["../../chart/treemap-squarify.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,UAAU;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,UAAU,YAAY;IACrB,MAAM,EAAE,MAAM,CAAC;CACf;AAYD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,SAAS,YAAY,EAClD,KAAK,EAAE,SAAS,KAAK,EAAE,EACvB,GAAG,EAAE,UAAU,GACb,KAAK,CAAC,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAkD5B"}

package/dist/chart/trendline-equation.d.ts

@@ -0,0 +1,39 @@
+/**
+ * chart-trendline-equation-format.ts: Excel-style trendline equation text
+ * formatting.
+ *
+ * Excel's own trendline equation display (`c:trendlineLbl` with
+ * `c:dispEq val="1"`) rounds every coefficient to a handful of SIGNIFICANT
+ * digits in plain decimal notation, not a fixed number of decimal places: a
+ * small slope like 0.003742 stays "0.003742"-ish (four significant figures),
+ * where `.toFixed(2)` would flatten it to "0.00" and silently erase the fit.
+ * It also lays out each trendline family in its own fixed shape (exponential
+ * as `y = a e^(bx)`, a polynomial in DESCENDING powers), which this module
+ * is the single source of truth for so it cannot drift between the fit types.
+ *
+ * @module chart/trendline-equation
+ */
+/**
+ * Format one coefficient to `SIGNIFICANT_DIGITS` significant figures in plain
+ * decimal notation (falls back to exponential only where `Number#toString`
+ * itself would, i.e. extreme magnitudes), with insignificant trailing zeros
+ * dropped. `-0` normalises to `"0"`.
+ */
+export declare function formatTrendlineCoefficient(value: number): string;
+/** `y = mx + b` (linear) or `y = mx - b` when the intercept is negative. */
+export declare function formatLinearEquation(slope: number, intercept: number): string;
+/** `y = a e^(bx)`: Excel's own exponential trendline layout. */
+export declare function formatExponentialEquation(a: number, b: number): string;
+/** `y = a ln(x) + b` (logarithmic), `-` glue when the intercept is negative. */
+export declare function formatLogarithmicEquation(slope: number, intercept: number): string;
+/** `y = a x^b` (power). */
+export declare function formatPowerEquation(a: number, b: number): string;
+/**
+ * `y = a_n x^n + ... + a_1 x + a_0`: a polynomial in DESCENDING powers of x
+ * (Excel's own layout), from `coeffsAscending` ([a0, a1, ..., an], the order
+ * `fitPolynomial` returns them in). The highest-order term never shows a
+ * redundant leading `+`; `x^1` drops its exponent; the constant term (`x^0`)
+ * drops the variable entirely.
+ */
+export declare function formatPolynomialEquation(coeffsAscending: readonly number[]): string;
+//# sourceMappingURL=trendline-equation.d.ts.map

package/dist/chart/trendline-equation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trendline-equation.d.ts","sourceRoot":"","sources":["../../chart/trendline-equation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWhE;AAOD,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAG7E;AAED,gEAAgE;AAChE,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,gFAAgF;AAChF,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAGlF;AAED,2BAA2B;AAC3B,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,eAAe,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAanF"}

package/dist/collab/index.cjs

@@ -1274,7 +1274,7 @@ function createTransportProvider({ doc, awareness }, { transport, maxMessageByte
 // collab/websocket-transport.ts
 var OPEN = 1;
 function roomUrl(server, roomId) {
-  return `${server.replace(/\/+$/u, "")}/${encodeURIComponent(roomId)}`;
+  return `${trimTrailingSlashes(server)}/${encodeURIComponent(roomId)}`;
 }
 function createWebSocketTransport(options) {
   const { baseDelayMs = 250, maxDelayMs = 1e4, maxRetries = Infinity } = options;
@@ -1345,6 +1345,11 @@ function createWebSocketTransport(options) {
     }
   };
 }
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end--;
+  return value.slice(0, end);
+}
 
 exports.BROADCAST_THROTTLE_MS = BROADCAST_THROTTLE_MS;
 exports.BoundedMap = BoundedMap;

package/dist/collab/index.mjs

@@ -1250,7 +1250,7 @@ function createTransportProvider({ doc, awareness }, { transport, maxMessageByte
 // collab/websocket-transport.ts
 var OPEN = 1;
 function roomUrl(server, roomId) {
-  return `${server.replace(/\/+$/u, "")}/${encodeURIComponent(roomId)}`;
+  return `${trimTrailingSlashes(server)}/${encodeURIComponent(roomId)}`;
 }
 function createWebSocketTransport(options) {
   const { baseDelayMs = 250, maxDelayMs = 1e4, maxRetries = Infinity } = options;
@@ -1321,5 +1321,10 @@ function createWebSocketTransport(options) {
     }
   };
 }
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end--;
+  return value.slice(0, end);
+}
 
 export { BROADCAST_THROTTLE_MS, BoundedMap, COLLABORATION_ROLES, COLLAB_LEAVE_MESSAGE, CONNECTION_TIMEOUT_MS, CURSOR_PALETTE, DEFAULT_COLOR, DEFAULT_MAX_PACKAGE_BYTES, DEPARTURE_CHANNEL, Emitter, INITIAL_SYNC_GRACE_MS, IdempotencyCache, LEGACY_PPTX_DEPARTURE_CHANNEL, LEGACY_PPTX_LEAVE_MESSAGE, LOCAL_ORIGIN, MAX_LABEL_CHARS, MAX_UPDATE_BYTES, MESSAGE_AWARENESS, MESSAGE_QUERY_AWARENESS, MESSAGE_SYNC, PRESENCE_FIELD, PRESENCE_HEARTBEAT_MS, STALE_PRESENCE_MS, SequenceTracker, adaptYjsProvider, applyUpdateSafe, asSelectionIds, assignUserColor, bindDocument, borrowAwareness, buildRoster, canBroadcast, canWrite, clampCoordinate, classifyVersion, clearLocalAwareness, createAssetSync, createBroadcastTransport, createClientId, createCollabSession, createDepartureChannel, createIdGenerator, createMemoryHub, createPresencePublisher, createSyncGate, createTransportProvider, createWebSocketTransport, deriveCanvasPresence, derivePresence, encodeDiff, encodeSnapshot, encodeStateVector2 as encodeStateVector, formatCursorLabel, freezeDeep, fromBase64, getUserInitials, isMixedContentBlocked, isNonNegativeSafeInteger, isPresenceFresh, isValidId, isValidRoomId, mergeUpdates2 as mergeUpdates, observeExternalSession, packageAdapter, presenceToCursors, registerTeardown, removeAwarenessStatesLocally, restoreSnapshot, roomUrl, sanitizeAvatarUrl, sanitizeCanvasPayload, sanitizeColor, sanitizeIdentity, sanitizeIndex, sanitizeRole, sanitizeUserName, shouldAutoFollowBroadcaster, shouldRoomReplaceLoad, stripHtmlTags, toBase64, transportProvider, validateDisplayName, validateRoomId, validateUpdate };

package/dist/color/contrast.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Readable-text-colour selection for fills whose text colour was left implicit.
+ *
+ * PowerPoint stores no colour for a great many runs and resolves one at paint
+ * time from what is behind them. Renderers that instead pick a fixed colour get
+ * white text on white panels, so both the 2D and 3D SmartArt paths need the same
+ * decision, made the same way.
+ *
+ * @module color/contrast
+ */
+/** Parse `#rgb`/`#rrggbb` into `[r, g, b]` (0..255); falls back to mid-grey. */
+export declare function parseHex(hex: string): [number, number, number];
+/**
+ * Pick a readable text colour (near-black or near-white) for a given fill,
+ * using the WCAG relative-luminance threshold.
+ */
+export declare function contrastTextColor(fill: string): string;
+//# sourceMappingURL=contrast.d.ts.map

package/dist/color/contrast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contrast.d.ts","sourceRoot":"","sources":["../../color/contrast.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAY9D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAItD"}

package/dist/color/index.cjs

@@ -160,16 +160,49 @@ function linearToSrgb255(linear) {
   return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
 }
 
+// color/contrast.ts
+function parseHex(hex) {
+  let h = hex.trim().replace(/^#/u, "");
+  if (h.length === 3) {
+    h = h.split("").map((c) => c + c).join("");
+  }
+  if (h.length !== 6 || /[^0-9a-fA-F]/u.test(h)) {
+    return [128, 128, 128];
+  }
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+function contrastTextColor(fill) {
+  const [r, g, b] = parseHex(fill);
+  const lum = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return lum > 0.6 ? "#1a1a1a" : "#ffffff";
+}
+
+// color/unit-rgb.ts
+function hexToRgbUnit(hex) {
+  const clean = hex.replace(/^#/u, "");
+  const r = Number.parseInt(clean.substring(0, 2), 16) / 255;
+  const g = Number.parseInt(clean.substring(2, 4), 16) / 255;
+  const b = Number.parseInt(clean.substring(4, 6), 16) / 255;
+  return {
+    r: Number.isFinite(r) ? r : 0,
+    g: Number.isFinite(g) ? g : 0,
+    b: Number.isFinite(b) ? b : 0
+  };
+}
+
 exports.blendColorOntoWhite = blendColorOntoWhite;
 exports.clampUnitInterval = clampUnitInterval;
 exports.colorWithOpacity = colorWithOpacity;
+exports.contrastTextColor = contrastTextColor;
 exports.hexToRgbChannels = hexToRgbChannels;
+exports.hexToRgbUnit = hexToRgbUnit;
 exports.hslToRgb = hslToRgb;
 exports.linearToSrgb255 = linearToSrgb255;
 exports.normalizeHexColor = normalizeHexColor;
 exports.parseDrawingFraction = parseDrawingFraction;
 exports.parseDrawingHueDegrees = parseDrawingHueDegrees;
 exports.parseDrawingPercent = parseDrawingPercent;
+exports.parseHex = parseHex;
 exports.parseOoxmlPercent = parseOoxmlPercent;
 exports.rgbToHsl = rgbToHsl;
 exports.scrgbLinearToSrgb8 = scrgbLinearToSrgb8;

package/dist/color/index.d.ts

@@ -1,3 +1,5 @@
 export * from './color-primitives.js';
 export * from './color-linear.js';
+export * from './contrast.js';
+export * from './unit-rgb.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/color/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../color/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../color/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC"}

package/dist/color/index.mjs

@@ -158,4 +158,34 @@ function linearToSrgb255(linear) {
   return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
 }
 
-export { blendColorOntoWhite, clampUnitInterval, colorWithOpacity, hexToRgbChannels, hslToRgb, linearToSrgb255, normalizeHexColor, parseDrawingFraction, parseDrawingHueDegrees, parseDrawingPercent, parseOoxmlPercent, rgbToHsl, scrgbLinearToSrgb8, srgb255ToLinear, toHex };
+// color/contrast.ts
+function parseHex(hex) {
+  let h = hex.trim().replace(/^#/u, "");
+  if (h.length === 3) {
+    h = h.split("").map((c) => c + c).join("");
+  }
+  if (h.length !== 6 || /[^0-9a-fA-F]/u.test(h)) {
+    return [128, 128, 128];
+  }
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+}
+function contrastTextColor(fill) {
+  const [r, g, b] = parseHex(fill);
+  const lum = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return lum > 0.6 ? "#1a1a1a" : "#ffffff";
+}
+
+// color/unit-rgb.ts
+function hexToRgbUnit(hex) {
+  const clean = hex.replace(/^#/u, "");
+  const r = Number.parseInt(clean.substring(0, 2), 16) / 255;
+  const g = Number.parseInt(clean.substring(2, 4), 16) / 255;
+  const b = Number.parseInt(clean.substring(4, 6), 16) / 255;
+  return {
+    r: Number.isFinite(r) ? r : 0,
+    g: Number.isFinite(g) ? g : 0,
+    b: Number.isFinite(b) ? b : 0
+  };
+}
+
+export { blendColorOntoWhite, clampUnitInterval, colorWithOpacity, contrastTextColor, hexToRgbChannels, hexToRgbUnit, hslToRgb, linearToSrgb255, normalizeHexColor, parseDrawingFraction, parseDrawingHueDegrees, parseDrawingPercent, parseHex, parseOoxmlPercent, rgbToHsl, scrgbLinearToSrgb8, srgb255ToLinear, toHex };

package/dist/color/unit-rgb.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Colour-unit conversion helpers shared across the SVG `<filter>` builders in
+ * `render/`.
+ *
+ * `hexToRgbUnit` used to exist as three private, byte-identical copies:
+ * `visual-effects.ts` (DAG duotone filter), `image-effects.ts` (image duotone
+ * filter), and Angular's `duotone-filter.ts`. This is the one canonical copy;
+ * the other two shared modules now import it instead of redefining it.
+ */
+/**
+ * Parse a hex colour (`#RRGGBB`/`RRGGBB`, `#` optional) to normalised 0-1 RGB
+ * components. Any channel that fails to parse (missing/invalid hex digits,
+ * including a short 3-digit `#RGB` shorthand, which this does NOT expand)
+ * produces `0`, matching every prior copy's behaviour exactly.
+ */
+export declare function hexToRgbUnit(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+};
+//# sourceMappingURL=unit-rgb.d.ts.map

package/dist/color/unit-rgb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-rgb.d.ts","sourceRoot":"","sources":["../../color/unit-rgb.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAU7E"}

package/dist/docx/embedded.cjs

@@ -1149,7 +1149,7 @@ async function applyCoreProperties(zip, next, prior) {
   await ensureContentTypeOverride(zip, CORE_PATH, CORE_TYPE);
   const rels = zip.file("_rels/.rels");
   const relsXml = await rels?.async("string") ?? '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
-  if (!relsXml.includes(CORE_REL)) {
+  if (!relsXml.includes(`Type="${CORE_REL}"`)) {
     const ids = [...relsXml.matchAll(/Id="rId(\d+)"/g)].map((match) => Number(match[1]));
     const id = `rId${Math.max(0, ...ids) + 1}`;
     zip.file(

package/dist/docx/embedded.mjs

@@ -1143,7 +1143,7 @@ async function applyCoreProperties(zip, next, prior) {
   await ensureContentTypeOverride(zip, CORE_PATH, CORE_TYPE);
   const rels = zip.file("_rels/.rels");
   const relsXml = await rels?.async("string") ?? '<?xml version="1.0" encoding="UTF-8" standalone="yes"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>';
-  if (!relsXml.includes(CORE_REL)) {
+  if (!relsXml.includes(`Type="${CORE_REL}"`)) {
     const ids = [...relsXml.matchAll(/Id="rId(\d+)"/g)].map((match) => Number(match[1]));
     const id = `rId${Math.max(0, ...ids) + 1}`;
     zip.file(