ooxml-core 0.8.0 → 0.10.0

package/README.md

@@ -35,22 +35,30 @@ import { parseXml } from 'ooxml-core/xml'; // one area
 import { xml, opc } from 'ooxml-core'; // or by namespace (shared building blocks)
 ```
 
-| Area       | What it is                                                                                                                                                                                                                                                                                                                                                                                                         |
-| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `xml`      | The shared XML model: strict DOM parsing and serialization, namespaces, namespace-aware helpers.                                                                                                                                                                                                                                                                                                                   |
-| `opc`      | Open Packaging Conventions: relationships, content types, part paths, zip helpers, safe hyperlinks.                                                                                                                                                                                                                                                                                                                |
-| `units`    | Branded EMU, twip and point types, constants and conversions.                                                                                                                                                                                                                                                                                                                                                      |
-| `color`    | Hex, RGB, HSL and linear colour primitives, OOXML percent and angle parsing.                                                                                                                                                                                                                                                                                                                                       |
-| `geometry` | DrawingML preset shapes, connection sites, clip paths, callouts and boolean shape operations.                                                                                                                                                                                                                                                                                                                      |
-| `diagram`  | SmartArt (DiagramML), format-neutral: data model, layout/colour/quick-style parts, the cached `dsp:drawing` shape tree, relationship resolution and a loader. Used by `docx`; `pptx` re-imports its parsers.                                                                                                                                                                                                       |
-| `digest`   | Synchronous pure-TypeScript SHA-1, SHA-256, SHA-384 and SHA-512, ECMA-376 digest name normalisation (`SHA-512`, `SHA512`, `sha_512`, ...) and the agile password hash Office protection elements store (`hashPassword`, `verifyPasswordHash`). No Web Crypto, so it works on `http://`. Used by `xlsx` sheet and workbook protection.                                                                              |
-| `collab`   | Format-neutral real-time collaboration on Yjs: session and provider lifecycle, awareness/presence, transport-neutral sync (WebSocket, in-memory, any byte channel), update codecs, ordering helpers, asset sync and the product adapter seam. See `docs/collab-area.md`.                                                                                                                                           |
-| `docx`     | WordprocessingML: model, parser, preserving serializer, editing, validation. Also `/docx/embedded`. `/docx/layout` is the DOM-free pagination engine (an approximation of Word, not parity) and `/docx/load` detects and loads DOCX and legacy .doc (ole2 inlined).                                                                                                                                                |
-| `pptx`     | PresentationML: model, parser, serializer, editing, charts, SmartArt, converters, CLI, signatures. Subpaths `/pptx/converter`, `/pptx/cli`, `/pptx/signature-node`.                                                                                                                                                                                                                                                |
-| `xlsx`     | SpreadsheetML: workbook model, `.xlsx`/`.xlsm` reader and preserving writer, formula engine (dependency graph, dynamic arrays, 380+ functions), Excel number formats, editing commands with undo, and the DOM-free grid layout (sizes, colours, conditional formats, charts as SVG). `/xlsx/load` detects and loads `.xlsx`, `.xlsm`, legacy `.xls` (ole2 inlined) and CSV. An approximation of Excel, not parity. |
+| Area       | What it is                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `xml`      | The shared XML model: strict DOM parsing and serialization, namespaces, namespace-aware helpers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `opc`      | Open Packaging Conventions: relationships, content types, part paths, zip helpers, the hyperlink safety policy (`hyperlinkPolicy`) and document properties (core, app and custom, `opc/properties`) and digital signatures (`signature`: detection, the parts a writer strips, XML-DSig parsing and digest checks; the Node verifier is `/pptx/signature-node`).                                                                                                                                                                                                                                                                                                                                                                                    |
+| `units`    | Branded EMU, twip and point types, constants and conversions.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `color`    | Hex, RGB, HSL and linear colour primitives, OOXML percent and angle parsing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `geometry` | DrawingML preset shapes, connection sites, clip paths, callouts and boolean shape operations.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `diagram`  | SmartArt (DiagramML), format-neutral: data model, layout/colour/quick-style parts, the cached `dsp:drawing` shape tree, relationship resolution and a loader. Used by `docx`; `pptx` re-imports its parsers.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| `digest`   | Synchronous pure-TypeScript SHA-1, SHA-256, SHA-384 and SHA-512, ECMA-376 digest name normalisation (`SHA-512`, `SHA512`, `sha_512`, ...) and the agile password hash Office protection elements store (`hashPassword`, `verifyPasswordHash`). No Web Crypto, so it works on `http://`. Used by `xlsx` sheet and workbook protection.                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `crypto`   | ECMA-376 package encryption ([MS-OFFCRYPTO]) for every format: `decryptOoxmlPackage`, `encryptOoxmlPackage` (agile AES-256/SHA-512 by default, or Standard), `isEncryptedOoxmlPackage`, and typed errors with a `code` (`password-required`, `incorrect-password`, `data-integrity`). The compound-file container comes from ole2 (inlined); not in the root entry.                                                                                                                                                                                                                                                                                                                                                                                 |
+| `collab`   | Format-neutral real-time collaboration on Yjs: session and provider lifecycle, awareness/presence, transport-neutral sync (WebSocket, in-memory, any byte channel), update codecs, ordering helpers, asset sync and the product adapter seam. See `docs/collab-area.md`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `docx`     | WordprocessingML: model, parser, preserving serializer, editing, validation. Also `/docx/embedded`. `/docx/layout` is the DOM-free pagination engine (an approximation of Word, not parity) and `/docx/load` detects and loads DOCX (also password-protected, `{ password }`) and legacy .doc (ole2 inlined).                                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `pptx`     | PresentationML: model, parser, serializer, editing, charts, SmartArt, converters, CLI, signatures. Subpaths `/pptx/converter`, `/pptx/cli`, `/pptx/signature-node`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `xlsx`     | SpreadsheetML: workbook model, `.xlsx`/`.xlsm` reader and preserving writer, formula engine (dependency graph, dynamic arrays, 380+ functions), Excel number formats, editing commands with undo, and the DOM-free grid layout (sizes, colours, conditional formats, charts as SVG, drawing anchors). SmartArt is shown from the cached drawing (not re-laid out) and kept verbatim on save. `/xlsx/load` detects and loads `.xlsx`, `.xlsm` (also password-protected: `loadWorkbook(bytes, { password })`, `saveWorkbook(workbook, 'xlsx', { password })`), legacy `.xls` (ole2 inlined) and CSV, and refuses `.xlsb` with a typed error. Digital signatures are detected and reported, never kept on save. An approximation of Excel, not parity. |
 
 Legacy binary formats (`.doc`, `.xls`, `.ppt`) and the compound-file container live in the sibling package [`ole2`](https://github.com/ChristopherVR/ole2); this package never contains binary codecs, and `ole2` never contains modern OOXML.
 
+The `chart` subpath provides shared chart data calculations (regression, quartiles,
+blank values and stacked series). The `text` subpath provides script-category
+segmentation primitives. These areas are DOM-free and do not import a product model.
+SVG curve flattening is available from `geometry`. See the
+[PowerPoint reuse audit](docs/pptx-shared-logic-audit.md) for extraction evidence
+and remaining candidates.
+
 ## Install
 
 ```bash

package/dist/chart/blank-display.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Blank-value display resolution for `c:dispBlanksAs`.
+ *
+ * A chart series carries an optional `blanks` mask (from core) marking category
+ * slots whose numeric cache point was absent. This module turns that mask into
+ * per-point render instructions per the chart's `c:dispBlanksAs` mode:
+ *
+ * - `gap`  - the blank point is omitted and the line breaks around it.
+ * - `zero` - the blank point plots as `0` (its placeholder value).
+ * - `span` - the blank is linearly interpolated from its nearest real neighbours.
+ *
+ * When the mode is unset the output preserves existing behaviour exactly (all
+ * points visible, placeholder `0` values), so charts without an explicit
+ * `c:dispBlanksAs` render unchanged.
+ *
+ * @module chart-blank-display
+ */
+/** Values of `c:dispBlanksAs`. */
+export type DispBlanksAs = 'gap' | 'zero' | 'span';
+/** Per-point render instructions after applying a blank mode. */
+export interface BlankDisplay {
+    /** Effective values (interpolated for `span`; `0` placeholder otherwise). */
+    values: number[];
+    /** Whether each point is drawn. `false` only for blanks under `gap`. */
+    visible: boolean[];
+}
+/**
+ * Resolve display values + visibility for a series given its blank mask and mode.
+ *
+ * @param values - Effective values aligned to display order (blanks carry `0`).
+ * @param blanks - Blank mask aligned index-for-index with `values`.
+ * @param mode - `c:dispBlanksAs` mode; `undefined` preserves existing behaviour.
+ */
+export declare function resolveBlankDisplay(values: ReadonlyArray<number>, blanks: ReadonlyArray<boolean> | undefined, mode: DispBlanksAs | undefined): BlankDisplay;
+/** Contiguous runs of visible indices, used to break a line at gaps. */
+export declare function visibleRuns(visible: ReadonlyArray<boolean>): number[][];
+//# sourceMappingURL=blank-display.d.ts.map

package/dist/chart/blank-display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blank-display.d.ts","sourceRoot":"","sources":["../../src/chart/blank-display.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,kCAAkC;AAClC,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAC;AAEnD,iEAAiE;AACjE,MAAM,WAAW,YAAY;IAC5B,6EAA6E;IAC7E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,wEAAwE;IACxE,OAAO,EAAE,OAAO,EAAE,CAAC;CACnB;AA+BD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAClC,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,EAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,SAAS,EAC1C,IAAI,EAAE,YAAY,GAAG,SAAS,GAC5B,YAAY,CAad;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG,MAAM,EAAE,EAAE,CAevE"}

package/dist/chart/box-stats.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Row indexes sharing each unique category label, in first-appearance order.
+ *
+ * A `cx:boxWhisker` chart's raw data repeats its category label once per
+ * underlying observation (COM-verified against `charts-com.pptx` slide 32 /
+ * `chartEx7.xml`: `Category 1` appears on 9 consecutive rows, `Category 2` on
+ * 7, `Category 3` on 6), because every row IS one observation, not one
+ * category. A box's quartiles must be computed from the observations that
+ * share its category label, not from one value per row.
+ */
+export interface CategoryRowGroups {
+    /** Unique category labels, in first-appearance (authoring) order. */
+    uniqueCategories: string[];
+    /** Every raw row index whose category label equals the map key. */
+    rowIndexesByCategory: ReadonlyMap<string, number[]>;
+}
+/** Group raw (possibly repeated) category labels by unique text. */
+export declare function groupRowsByCategory(rawCategories: ReadonlyArray<string>): CategoryRowGroups;
+export interface BoxStats {
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    max: number;
+}
+/** Compute quartiles, preserving the legacy floor-index result when method is absent. */
+export declare function computeBoxStats(values: ReadonlyArray<number>, method?: 'inclusive' | 'exclusive'): BoxStats | undefined;
+//# sourceMappingURL=box-stats.d.ts.map

package/dist/chart/box-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"box-stats.d.ts","sourceRoot":"","sources":["../../src/chart/box-stats.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,iBAAiB;IACjC,qEAAqE;IACrE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,mEAAmE;IACnE,oBAAoB,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACpD;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,iBAAiB,CAc3F;AAED,MAAM,WAAW,QAAQ;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;CACZ;AAeD,yFAAyF;AACzF,wBAAgB,eAAe,CAC9B,MAAM,EAAE,aAAa,CAAC,MAAM,CAAC,EAC7B,MAAM,CAAC,EAAE,WAAW,GAAG,WAAW,GAChC,QAAQ,GAAG,SAAS,CAqBtB"}

package/dist/chart/index.cjs

@@ -0,0 +1,229 @@
+'use strict';
+
+// src/chart/regression.ts
+function computeLinearRegression(xVals, yVals) {
+  const n = xVals.length;
+  if (n < 2) {
+    return { slope: 0, intercept: 0, rSquared: 0 };
+  }
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumXX = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += xVals[i];
+    sumY += yVals[i];
+    sumXY += xVals[i] * yVals[i];
+    sumXX += xVals[i] * xVals[i];
+  }
+  const denom = n * sumXX - sumX * sumX;
+  if (Math.abs(denom) < 1e-12) {
+    return { slope: 0, intercept: sumY / n, rSquared: 0 };
+  }
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
+  const ssRes = yVals.reduce((s, y, i) => s + (y - (slope * xVals[i] + intercept)) ** 2, 0);
+  const meanY = sumY / n;
+  const ssTot = yVals.reduce((s, y) => s + (y - meanY) ** 2, 0);
+  const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+  return { slope, intercept, rSquared };
+}
+function fitPolynomial(xVals, yVals, order) {
+  const n = xVals.length;
+  const m = order + 1;
+  const matrix = Array.from({ length: m }, () => Array(m + 1).fill(0));
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < m; j++) {
+      let sum2 = 0;
+      for (let k = 0; k < n; k++) {
+        sum2 += xVals[k] ** (i + j);
+      }
+      matrix[i][j] = sum2;
+    }
+    let sum = 0;
+    for (let k = 0; k < n; k++) {
+      sum += yVals[k] * xVals[k] ** i;
+    }
+    matrix[i][m] = sum;
+  }
+  for (let i = 0; i < m; i++) {
+    let maxRow = i;
+    for (let k = i + 1; k < m; k++) {
+      if (Math.abs(matrix[k][i]) > Math.abs(matrix[maxRow][i])) {
+        maxRow = k;
+      }
+    }
+    [matrix[i], matrix[maxRow]] = [matrix[maxRow], matrix[i]];
+    const pivot = matrix[i][i];
+    if (Math.abs(pivot) < 1e-12) {
+      continue;
+    }
+    for (let j = i; j <= m; j++) {
+      matrix[i][j] = matrix[i][j] / pivot;
+    }
+    for (let k = 0; k < m; k++) {
+      if (k === i) {
+        continue;
+      }
+      const factor = matrix[k][i];
+      for (let j = i; j <= m; j++) {
+        matrix[k][j] = matrix[k][j] - factor * matrix[i][j];
+      }
+    }
+  }
+  return matrix.map((row) => row[m]);
+}
+function computeRSquared(xVals, yVals, evalFn) {
+  const n = xVals.length;
+  if (n === 0) {
+    return 0;
+  }
+  const meanY = yVals.reduce((s, y) => s + y, 0) / n;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (let i = 0; i < n; i++) {
+    ssRes += (yVals[i] - evalFn(xVals[i])) ** 2;
+    ssTot += (yVals[i] - meanY) ** 2;
+  }
+  return ssTot > 0 ? 1 - ssRes / ssTot : 0;
+}
+
+// src/chart/box-stats.ts
+function groupRowsByCategory(rawCategories) {
+  const uniqueCategories = [];
+  const rowIndexesByCategory = /* @__PURE__ */ new Map();
+  rawCategories.forEach((rawLabel, rowIndex) => {
+    const label = rawLabel ?? "";
+    let rows = rowIndexesByCategory.get(label);
+    if (!rows) {
+      rows = [];
+      rowIndexesByCategory.set(label, rows);
+      uniqueCategories.push(label);
+    }
+    rows.push(rowIndex);
+  });
+  return { uniqueCategories, rowIndexesByCategory };
+}
+function percentile(sorted, p, method) {
+  const rank = method === "inclusive" ? (sorted.length - 1) * p : (sorted.length + 1) * p - 1;
+  const clamped = Math.max(0, Math.min(rank, sorted.length - 1));
+  const lower = Math.floor(clamped);
+  const upper = Math.ceil(clamped);
+  const fraction = clamped - lower;
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * fraction;
+}
+function computeBoxStats(values, method) {
+  if (values.length < 2) {
+    return void 0;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  if (!method) {
+    return {
+      min: sorted[0],
+      q1: sorted[Math.floor(sorted.length * 0.25)],
+      median: sorted[Math.floor(sorted.length * 0.5)],
+      q3: sorted[Math.floor(sorted.length * 0.75)],
+      max: sorted[sorted.length - 1]
+    };
+  }
+  return {
+    min: sorted[0],
+    q1: percentile(sorted, 0.25, method),
+    median: percentile(sorted, 0.5, method),
+    q3: percentile(sorted, 0.75, method),
+    max: sorted[sorted.length - 1]
+  };
+}
+
+// src/chart/blank-display.ts
+function interpolate(values, blank) {
+  const out = [...values];
+  for (let i = 0; i < out.length; i++) {
+    if (!blank[i]) {
+      continue;
+    }
+    let prev = i - 1;
+    while (prev >= 0 && blank[prev]) {
+      prev--;
+    }
+    let next = i + 1;
+    while (next < out.length && blank[next]) {
+      next++;
+    }
+    const hasPrev = prev >= 0;
+    const hasNext = next < out.length;
+    if (hasPrev && hasNext) {
+      const t = (i - prev) / (next - prev);
+      out[i] = values[prev] + (values[next] - values[prev]) * t;
+    } else if (hasPrev) {
+      out[i] = values[prev];
+    } else if (hasNext) {
+      out[i] = values[next];
+    }
+  }
+  return out;
+}
+function resolveBlankDisplay(values, blanks, mode) {
+  const visible = values.map(() => true);
+  if (!blanks || !blanks.some(Boolean) || mode === void 0 || mode === "zero") {
+    return { values: [...values], visible };
+  }
+  if (mode === "span") {
+    return { values: interpolate(values, blanks), visible };
+  }
+  return {
+    values: [...values],
+    visible: values.map((_v, i) => !blanks[i])
+  };
+}
+function visibleRuns(visible) {
+  const runs = [];
+  let current = [];
+  for (let i = 0; i < visible.length; i++) {
+    if (visible[i]) {
+      current.push(i);
+    } else if (current.length > 0) {
+      runs.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) {
+    runs.push(current);
+  }
+  return runs;
+}
+
+// src/chart/stacked-series.ts
+function categoryAbsTotals(seriesValues, catCount) {
+  return Array.from(
+    { length: catCount },
+    (_, ci) => seriesValues.reduce((sum, values) => sum + Math.abs(values[ci] ?? 0), 0)
+  );
+}
+function computeStackedSeriesPlots(seriesValues, catCount, percent) {
+  const totals = percent ? categoryAbsTotals(seriesValues, catCount) : void 0, posRunning = new Array(catCount).fill(0), negRunning = new Array(catCount).fill(0);
+  return seriesValues.map((values) => {
+    const cumulative = [], base = [], own = [];
+    for (let ci = 0; ci < catCount; ci++) {
+      const raw = values[ci] ?? 0, total = totals?.[ci] ?? 0, val = percent ? total > 0 ? raw / total * 100 : 0 : raw, isNeg = val < 0, from = isNeg ? negRunning[ci] : posRunning[ci], to = from + val;
+      base.push(from);
+      cumulative.push(to);
+      own.push(val);
+      if (isNeg) {
+        negRunning[ci] = to;
+      } else {
+        posRunning[ci] = to;
+      }
+    }
+    return { cumulative, base, own };
+  });
+}
+
+exports.computeBoxStats = computeBoxStats;
+exports.computeLinearRegression = computeLinearRegression;
+exports.computeRSquared = computeRSquared;
+exports.computeStackedSeriesPlots = computeStackedSeriesPlots;
+exports.fitPolynomial = fitPolynomial;
+exports.groupRowsByCategory = groupRowsByCategory;
+exports.resolveBlankDisplay = resolveBlankDisplay;
+exports.visibleRuns = visibleRuns;

package/dist/chart/index.d.ts

@@ -0,0 +1,6 @@
+/** Format-neutral, DOM-free chart data algorithms shared by Office formats. */
+export * from './regression.js';
+export * from './box-stats.js';
+export * from './blank-display.js';
+export * from './stacked-series.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/chart/index.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/dist/chart/index.mjs

@@ -0,0 +1,220 @@
+// src/chart/regression.ts
+function computeLinearRegression(xVals, yVals) {
+  const n = xVals.length;
+  if (n < 2) {
+    return { slope: 0, intercept: 0, rSquared: 0 };
+  }
+  let sumX = 0;
+  let sumY = 0;
+  let sumXY = 0;
+  let sumXX = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += xVals[i];
+    sumY += yVals[i];
+    sumXY += xVals[i] * yVals[i];
+    sumXX += xVals[i] * xVals[i];
+  }
+  const denom = n * sumXX - sumX * sumX;
+  if (Math.abs(denom) < 1e-12) {
+    return { slope: 0, intercept: sumY / n, rSquared: 0 };
+  }
+  const slope = (n * sumXY - sumX * sumY) / denom;
+  const intercept = (sumY - slope * sumX) / n;
+  const ssRes = yVals.reduce((s, y, i) => s + (y - (slope * xVals[i] + intercept)) ** 2, 0);
+  const meanY = sumY / n;
+  const ssTot = yVals.reduce((s, y) => s + (y - meanY) ** 2, 0);
+  const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+  return { slope, intercept, rSquared };
+}
+function fitPolynomial(xVals, yVals, order) {
+  const n = xVals.length;
+  const m = order + 1;
+  const matrix = Array.from({ length: m }, () => Array(m + 1).fill(0));
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < m; j++) {
+      let sum2 = 0;
+      for (let k = 0; k < n; k++) {
+        sum2 += xVals[k] ** (i + j);
+      }
+      matrix[i][j] = sum2;
+    }
+    let sum = 0;
+    for (let k = 0; k < n; k++) {
+      sum += yVals[k] * xVals[k] ** i;
+    }
+    matrix[i][m] = sum;
+  }
+  for (let i = 0; i < m; i++) {
+    let maxRow = i;
+    for (let k = i + 1; k < m; k++) {
+      if (Math.abs(matrix[k][i]) > Math.abs(matrix[maxRow][i])) {
+        maxRow = k;
+      }
+    }
+    [matrix[i], matrix[maxRow]] = [matrix[maxRow], matrix[i]];
+    const pivot = matrix[i][i];
+    if (Math.abs(pivot) < 1e-12) {
+      continue;
+    }
+    for (let j = i; j <= m; j++) {
+      matrix[i][j] = matrix[i][j] / pivot;
+    }
+    for (let k = 0; k < m; k++) {
+      if (k === i) {
+        continue;
+      }
+      const factor = matrix[k][i];
+      for (let j = i; j <= m; j++) {
+        matrix[k][j] = matrix[k][j] - factor * matrix[i][j];
+      }
+    }
+  }
+  return matrix.map((row) => row[m]);
+}
+function computeRSquared(xVals, yVals, evalFn) {
+  const n = xVals.length;
+  if (n === 0) {
+    return 0;
+  }
+  const meanY = yVals.reduce((s, y) => s + y, 0) / n;
+  let ssRes = 0;
+  let ssTot = 0;
+  for (let i = 0; i < n; i++) {
+    ssRes += (yVals[i] - evalFn(xVals[i])) ** 2;
+    ssTot += (yVals[i] - meanY) ** 2;
+  }
+  return ssTot > 0 ? 1 - ssRes / ssTot : 0;
+}
+
+// src/chart/box-stats.ts
+function groupRowsByCategory(rawCategories) {
+  const uniqueCategories = [];
+  const rowIndexesByCategory = /* @__PURE__ */ new Map();
+  rawCategories.forEach((rawLabel, rowIndex) => {
+    const label = rawLabel ?? "";
+    let rows = rowIndexesByCategory.get(label);
+    if (!rows) {
+      rows = [];
+      rowIndexesByCategory.set(label, rows);
+      uniqueCategories.push(label);
+    }
+    rows.push(rowIndex);
+  });
+  return { uniqueCategories, rowIndexesByCategory };
+}
+function percentile(sorted, p, method) {
+  const rank = method === "inclusive" ? (sorted.length - 1) * p : (sorted.length + 1) * p - 1;
+  const clamped = Math.max(0, Math.min(rank, sorted.length - 1));
+  const lower = Math.floor(clamped);
+  const upper = Math.ceil(clamped);
+  const fraction = clamped - lower;
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * fraction;
+}
+function computeBoxStats(values, method) {
+  if (values.length < 2) {
+    return void 0;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  if (!method) {
+    return {
+      min: sorted[0],
+      q1: sorted[Math.floor(sorted.length * 0.25)],
+      median: sorted[Math.floor(sorted.length * 0.5)],
+      q3: sorted[Math.floor(sorted.length * 0.75)],
+      max: sorted[sorted.length - 1]
+    };
+  }
+  return {
+    min: sorted[0],
+    q1: percentile(sorted, 0.25, method),
+    median: percentile(sorted, 0.5, method),
+    q3: percentile(sorted, 0.75, method),
+    max: sorted[sorted.length - 1]
+  };
+}
+
+// src/chart/blank-display.ts
+function interpolate(values, blank) {
+  const out = [...values];
+  for (let i = 0; i < out.length; i++) {
+    if (!blank[i]) {
+      continue;
+    }
+    let prev = i - 1;
+    while (prev >= 0 && blank[prev]) {
+      prev--;
+    }
+    let next = i + 1;
+    while (next < out.length && blank[next]) {
+      next++;
+    }
+    const hasPrev = prev >= 0;
+    const hasNext = next < out.length;
+    if (hasPrev && hasNext) {
+      const t = (i - prev) / (next - prev);
+      out[i] = values[prev] + (values[next] - values[prev]) * t;
+    } else if (hasPrev) {
+      out[i] = values[prev];
+    } else if (hasNext) {
+      out[i] = values[next];
+    }
+  }
+  return out;
+}
+function resolveBlankDisplay(values, blanks, mode) {
+  const visible = values.map(() => true);
+  if (!blanks || !blanks.some(Boolean) || mode === void 0 || mode === "zero") {
+    return { values: [...values], visible };
+  }
+  if (mode === "span") {
+    return { values: interpolate(values, blanks), visible };
+  }
+  return {
+    values: [...values],
+    visible: values.map((_v, i) => !blanks[i])
+  };
+}
+function visibleRuns(visible) {
+  const runs = [];
+  let current = [];
+  for (let i = 0; i < visible.length; i++) {
+    if (visible[i]) {
+      current.push(i);
+    } else if (current.length > 0) {
+      runs.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) {
+    runs.push(current);
+  }
+  return runs;
+}
+
+// src/chart/stacked-series.ts
+function categoryAbsTotals(seriesValues, catCount) {
+  return Array.from(
+    { length: catCount },
+    (_, ci) => seriesValues.reduce((sum, values) => sum + Math.abs(values[ci] ?? 0), 0)
+  );
+}
+function computeStackedSeriesPlots(seriesValues, catCount, percent) {
+  const totals = percent ? categoryAbsTotals(seriesValues, catCount) : void 0, posRunning = new Array(catCount).fill(0), negRunning = new Array(catCount).fill(0);
+  return seriesValues.map((values) => {
+    const cumulative = [], base = [], own = [];
+    for (let ci = 0; ci < catCount; ci++) {
+      const raw = values[ci] ?? 0, total = totals?.[ci] ?? 0, val = percent ? total > 0 ? raw / total * 100 : 0 : raw, isNeg = val < 0, from = isNeg ? negRunning[ci] : posRunning[ci], to = from + val;
+      base.push(from);
+      cumulative.push(to);
+      own.push(val);
+      if (isNeg) {
+        negRunning[ci] = to;
+      } else {
+        posRunning[ci] = to;
+      }
+    }
+    return { cumulative, base, own };
+  });
+}
+
+export { computeBoxStats, computeLinearRegression, computeRSquared, computeStackedSeriesPlots, fitPolynomial, groupRowsByCategory, resolveBlankDisplay, visibleRuns };

package/dist/chart/regression.d.ts

@@ -0,0 +1,40 @@
+/**
+ * chart-overlays-regression.ts: least-squares regression / polynomial-fit
+ * math for chart trendlines. Split out of chart-overlays.ts to keep that
+ * module under the repo's file-size guideline.
+ *
+ * Ported / adapted from:
+ *   packages/react/src/viewer/utils/chart-trendlines.tsx (regression engine)
+ *   packages/shared/src/render/chart-trendlines.ts (shared port)
+ *
+ * @module chart-overlays-regression
+ */
+/** Result of an ordinary least-squares linear regression. */
+export interface LinearFit {
+    slope: number;
+    intercept: number;
+    rSquared: number;
+}
+/**
+ * Ordinary least-squares linear regression of `yVals` on `xVals`.
+ * Returns all zeros for fewer than 2 points. A near-zero denominator
+ * (constant-x data) gives slope=0, intercept=mean(y), rSquared=0.
+ * Input arrays are finite paired observations of equal length.
+ *
+ * Mirrors `computeLinearRegression` in chart-trendlines.tsx (React) and
+ * chart-trendlines.ts (shared).
+ */
+export declare function computeLinearRegression(xVals: number[], yVals: number[]): LinearFit;
+/**
+ * Fit polynomial coefficients (ascending order: [a0, a1, ..., a_order]) via
+ * Gaussian elimination on the normal equations.
+ * Input arrays are finite paired observations; order is a nonnegative integer.
+ * Mirrors `fitPolynomial` in chart-trendlines.tsx (React).
+ */
+export declare function fitPolynomial(xVals: number[], yVals: number[], order: number): number[];
+/**
+ * Coefficient of determination (R-squared) of an arbitrary fit function
+ * against data. Mirrors `computeRSquared` in chart-trendlines.tsx (React).
+ */
+export declare function computeRSquared(xVals: number[], yVals: number[], evalFn: (x: number) => number): number;
+//# sourceMappingURL=regression.d.ts.map

package/dist/chart/regression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regression.d.ts","sourceRoot":"","sources":["../../src/chart/regression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,6DAA6D;AAC7D,MAAM,WAAW,SAAS;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,SAAS,CA+BnF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA+CvF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,GAC3B,MAAM,CAaR"}