ooxml-core 0.8.0 → 0.9.0

package/README.md

@@ -51,6 +51,13 @@ import { xml, opc } from 'ooxml-core'; // or by namespace (shared building block
 
 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"}

package/dist/chart/stacked-series.d.ts

@@ -0,0 +1,39 @@
+/**
+ * chart-stacked-series.ts: running-sum plot geometry for stacked and
+ * percentStacked LINE / AREA charts.
+ *
+ * Bar/column stacking (`computeStackedBarRects` in chart-view-model.ts) draws
+ * one rect per segment stacked on a shared baseline. Line/area stacking is
+ * different: each series is plotted at its cumulative height, so the
+ * top-most series traces the category total (line) or the topmost band edge
+ * (area). This module owns that running-sum math, shared by `buildLines` and
+ * `buildAreas` in chart-cartesian-line-area.ts so the two kinds cannot drift.
+ *
+ * @module chart-stacked-series
+ */
+/** How a line/area series' values combine with its siblings for plotting. */
+export type LineAreaStacking = 'clustered' | 'stacked' | 'percentStacked';
+/** Per-category stacked plot geometry for one series. */
+export interface StackedSeriesPlot {
+    /** Cumulative value through and including this series: the plotted line/area top. */
+    cumulative: number[];
+    /** Cumulative value before this series: the area band's lower edge. */
+    base: number[];
+    /**
+     * This series' own contribution at each category: the raw value for plain
+     * `stacked`, or its percent share of the category's absolute total for
+     * `percentStacked`. Used for data-label/tooltip text, which reads the
+     * series' value rather than the running sum it is plotted at.
+     */
+    own: number[];
+}
+/**
+ * Build running-sum stacked/percentStacked plot values for a set of line or
+ * area series, one entry per series in `seriesValues` order (series 0 sits at
+ * the bottom of the stack, exactly like stacked bar segments). Positive and
+ * negative values accumulate on separate running sums, so a chart mixing
+ * signs stacks above and below zero independently instead of the values
+ * cancelling out.
+ */
+export declare function computeStackedSeriesPlots(seriesValues: ReadonlyArray<ReadonlyArray<number>>, catCount: number, percent: boolean): StackedSeriesPlot[];
+//# sourceMappingURL=stacked-series.d.ts.map

package/dist/chart/stacked-series.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stacked-series.d.ts","sourceRoot":"","sources":["../../src/chart/stacked-series.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,6EAA6E;AAC7E,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG,SAAS,GAAG,gBAAgB,CAAC;AAE1E,yDAAyD;AACzD,MAAM,WAAW,iBAAiB;IACjC,qFAAqF;IACrF,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,uEAAuE;IACvE,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;;;OAKG;IACH,GAAG,EAAE,MAAM,EAAE,CAAC;CACd;AAiBD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACxC,YAAY,EAAE,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAClD,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACd,iBAAiB,EAAE,CA2BrB"}