ooxml-core 0.7.0 → 0.9.0

package/dist/index.mjs

@@ -186,6 +186,363 @@ function linearToSrgb255(linear) {
   return 255 * (c <= 31308e-7 ? c * 12.92 : 1.055 * c ** (1 / 2.4) - 0.055);
 }
 
+// src/chart/index.ts
+var chart_exports = {};
+__export(chart_exports, {
+  computeBoxStats: () => computeBoxStats,
+  computeLinearRegression: () => computeLinearRegression,
+  computeRSquared: () => computeRSquared,
+  computeStackedSeriesPlots: () => computeStackedSeriesPlots,
+  fitPolynomial: () => fitPolynomial,
+  groupRowsByCategory: () => groupRowsByCategory,
+  resolveBlankDisplay: () => resolveBlankDisplay,
+  visibleRuns: () => visibleRuns
+});
+
+// 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, val2 = percent ? total > 0 ? raw / total * 100 : 0 : raw, isNeg = val2 < 0, from = isNeg ? negRunning[ci] : posRunning[ci], to = from + val2;
+      base.push(from);
+      cumulative.push(to);
+      own.push(val2);
+      if (isNeg) {
+        negRunning[ci] = to;
+      } else {
+        posRunning[ci] = to;
+      }
+    }
+    return { cumulative, base, own };
+  });
+}
+
+// src/text/index.ts
+var text_exports = {};
+__export(text_exports, {
+  detectFontScript: () => detectFontScript,
+  hasDistinctScriptFonts: () => hasDistinctScriptFonts,
+  resolveFontForScript: () => resolveFontForScript,
+  segmentByScript: () => segmentByScript
+});
+
+// src/text/unicode-script-detection.ts
+function detectFontScript(codePoint) {
+  if (codePoint >= 11904 && codePoint <= 40959 || // CJK radicals, unified ideographs
+  codePoint >= 44032 && codePoint <= 55215 || // Hangul syllables
+  codePoint >= 63744 && codePoint <= 64255 || // CJK compatibility ideographs
+  codePoint >= 65072 && codePoint <= 65103 || // CJK compatibility forms
+  codePoint >= 131072 && codePoint <= 195103 || // CJK extension B-F
+  codePoint >= 12288 && codePoint <= 12351 || // CJK symbols & punctuation
+  codePoint >= 12352 && codePoint <= 12447 || // Hiragana
+  codePoint >= 12448 && codePoint <= 12543 || // Katakana
+  codePoint >= 12784 && codePoint <= 12799 || // Katakana extensions
+  codePoint >= 65280 && codePoint <= 65519) {
+    return "eastAsia";
+  }
+  if (codePoint >= 1424 && codePoint <= 1535 || // Hebrew
+  codePoint >= 1536 && codePoint <= 1791 || // Arabic
+  codePoint >= 1792 && codePoint <= 1871 || // Syriac
+  codePoint >= 1872 && codePoint <= 1919 || // Arabic Supplement
+  codePoint >= 1920 && codePoint <= 1983 || // Thaana
+  codePoint >= 1984 && codePoint <= 2047 || // NKo
+  codePoint >= 2048 && codePoint <= 2111 || // Samaritan
+  codePoint >= 2304 && codePoint <= 2431 || // Devanagari
+  codePoint >= 2432 && codePoint <= 2559 || // Bengali
+  codePoint >= 2560 && codePoint <= 2687 || // Gurmukhi
+  codePoint >= 2688 && codePoint <= 2815 || // Gujarati
+  codePoint >= 2816 && codePoint <= 2943 || // Oriya
+  codePoint >= 2944 && codePoint <= 3071 || // Tamil
+  codePoint >= 3072 && codePoint <= 3199 || // Telugu
+  codePoint >= 3200 && codePoint <= 3327 || // Kannada
+  codePoint >= 3328 && codePoint <= 3455 || // Malayalam
+  codePoint >= 3456 && codePoint <= 3583 || // Sinhala
+  codePoint >= 3584 && codePoint <= 3711 || // Thai
+  codePoint >= 3712 && codePoint <= 3839 || // Lao
+  codePoint >= 3840 && codePoint <= 4095 || // Tibetan
+  codePoint >= 4096 && codePoint <= 4255 || // Myanmar
+  codePoint >= 4256 && codePoint <= 4351 || // Georgian
+  codePoint >= 6016 && codePoint <= 6143 || // Khmer
+  codePoint >= 64336 && codePoint <= 65023 || // Arabic Presentation Forms-A
+  codePoint >= 65136 && codePoint <= 65279) {
+    return "complexScript";
+  }
+  if (codePoint >= 8592 && codePoint <= 8703 || // Arrows
+  codePoint >= 8704 && codePoint <= 8959 || // Mathematical operators
+  codePoint >= 8960 && codePoint <= 9215 || // Misc technical
+  codePoint >= 9472 && codePoint <= 9599 || // Box drawing
+  codePoint >= 9600 && codePoint <= 9631 || // Block elements
+  codePoint >= 9632 && codePoint <= 9727 || // Geometric shapes
+  codePoint >= 9728 && codePoint <= 9983 || // Misc symbols
+  codePoint >= 9984 && codePoint <= 10175 || // Dingbats
+  codePoint >= 57344 && codePoint <= 63743 || // Private Use Area
+  codePoint >= 126976 && codePoint <= 129535) {
+    return "symbol";
+  }
+  return "latin";
+}
+function segmentByScript(text) {
+  if (!text) {
+    return [];
+  }
+  const runs = [];
+  let currentScript = null;
+  let currentStart = 0;
+  let currentText = "";
+  for (let i = 0; i < text.length; i++) {
+    const codePoint = text.codePointAt(i);
+    if (codePoint === void 0) {
+      continue;
+    }
+    const charLength = codePoint > 65535 ? 2 : 1;
+    const char = text.substring(i, i + charLength);
+    const isNeutral = codePoint <= 127 && !/[a-zA-Z0-9]/u.test(char);
+    const script = isNeutral ? currentScript ?? "latin" : detectFontScript(codePoint);
+    if (script !== currentScript && currentScript !== null) {
+      runs.push({
+        text: currentText,
+        script: currentScript,
+        startIndex: currentStart
+      });
+      currentStart = i;
+      currentText = "";
+    }
+    currentScript = script;
+    currentText += char;
+    if (charLength === 2) {
+      i++;
+    }
+  }
+  if (currentText && currentScript) {
+    runs.push({
+      text: currentText,
+      script: currentScript,
+      startIndex: currentStart
+    });
+  }
+  return runs;
+}
+function resolveFontForScript(script, fonts) {
+  switch (script) {
+    case "latin":
+      return fonts.latin;
+    case "eastAsia":
+      return fonts.eastAsia || fonts.latin;
+    case "complexScript":
+      return fonts.complexScript || fonts.latin;
+    case "symbol":
+      return fonts.symbol || fonts.latin;
+  }
+}
+function hasDistinctScriptFonts(fonts) {
+  const base = fonts.latin;
+  if (!base) {
+    return false;
+  }
+  return Boolean(fonts.eastAsia) && fonts.eastAsia !== base || Boolean(fonts.complexScript) && fonts.complexScript !== base || Boolean(fonts.symbol) && fonts.symbol !== base;
+}
+
 // src/diagram/index.ts
 var diagram_exports = {};
 __export(diagram_exports, {
@@ -2212,6 +2569,7 @@ __export(geometry_exports, {
   evaluateFormula: () => evaluateFormula,
   evaluateGuides: () => evaluateGuides,
   findAllIntersections: () => findAllIntersections,
+  flattenSvgPath: () => flattenSvgPath,
   fmtNum: () => fmtNum,
   fragmentShapes: () => fragmentShapes,
   gd: () => gd,
@@ -17159,6 +17517,197 @@ function subtractSvgPaths(path1, path2) {
   return subtractShapes(path1, path2);
 }
 
+// src/geometry/svg-path-curves.ts
+function sampleCubic(p0, p1, p2, p3, segments, out) {
+  for (let i = 1; i <= segments; i++) {
+    const t = i / segments;
+    const mt = 1 - t;
+    const x = mt * mt * mt * p0.x + 3 * mt * mt * t * p1.x + 3 * mt * t * t * p2.x + t * t * t * p3.x;
+    const y = mt * mt * mt * p0.y + 3 * mt * mt * t * p1.y + 3 * mt * t * t * p2.y + t * t * t * p3.y;
+    out.push({ x, y });
+  }
+}
+function sampleQuadratic(p0, p1, p2, segments, out) {
+  for (let i = 1; i <= segments; i++) {
+    const t = i / segments;
+    const mt = 1 - t;
+    const x = mt * mt * p0.x + 2 * mt * t * p1.x + t * t * p2.x;
+    const y = mt * mt * p0.y + 2 * mt * t * p1.y + t * t * p2.y;
+    out.push({ x, y });
+  }
+}
+function sampleArc(start, rxIn, ryIn, xAxisRotationDeg, largeArcFlag, sweepFlag, end, segments, out) {
+  if (rxIn === 0 || ryIn === 0 || start.x === end.x && start.y === end.y) {
+    out.push(end);
+    return;
+  }
+  const phi = xAxisRotationDeg * Math.PI / 180;
+  const cosPhi = Math.cos(phi);
+  const sinPhi = Math.sin(phi);
+  let rx = Math.abs(rxIn);
+  let ry = Math.abs(ryIn);
+  const dx2 = (start.x - end.x) / 2;
+  const dy2 = (start.y - end.y) / 2;
+  const x1p = cosPhi * dx2 + sinPhi * dy2;
+  const y1p = -sinPhi * dx2 + cosPhi * dy2;
+  const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+  if (lambda > 1) {
+    const scale = Math.sqrt(lambda);
+    rx *= scale;
+    ry *= scale;
+  }
+  const sign = largeArcFlag !== sweepFlag ? 1 : -1;
+  const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+  const coef = sign * Math.sqrt(Math.max(0, num / den));
+  const cxp = coef * (rx * y1p) / ry;
+  const cyp = coef * -(ry * x1p) / rx;
+  const cx = cosPhi * cxp - sinPhi * cyp + (start.x + end.x) / 2;
+  const cy = sinPhi * cxp + cosPhi * cyp + (start.y + end.y) / 2;
+  const angle = (ux, uy, vx, vy) => {
+    const sign2 = ux * vy - uy * vx < 0 ? -1 : 1;
+    const dot = Math.max(
+      -1,
+      Math.min(1, (ux * vx + uy * vy) / (Math.hypot(ux, uy) * Math.hypot(vx, vy)))
+    );
+    return sign2 * Math.acos(dot);
+  };
+  const theta1 = angle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
+  let deltaTheta = angle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
+  if (!sweepFlag && deltaTheta > 0) {
+    deltaTheta -= 2 * Math.PI;
+  } else if (sweepFlag && deltaTheta < 0) {
+    deltaTheta += 2 * Math.PI;
+  }
+  const steps = Math.max(2, Math.round(segments * (Math.abs(deltaTheta) / (Math.PI / 2))));
+  for (let i = 1; i <= steps; i++) {
+    const theta = theta1 + deltaTheta * i / steps;
+    const x = cx + rx * Math.cos(theta) * cosPhi - ry * Math.sin(theta) * sinPhi;
+    const y = cy + rx * Math.cos(theta) * sinPhi + ry * Math.sin(theta) * cosPhi;
+    out.push({ x, y });
+  }
+}
+
+// src/geometry/svg-path-flatten.ts
+var COMMAND_RE = /[MLCQZAHVSmlcqzahvs][^MLCQZAHVSmlcqzahvs]*/gu;
+var NUMBER_RE = /-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/gu;
+function tokenize(d) {
+  const tokens = [];
+  const matches = d.match(COMMAND_RE);
+  if (!matches) {
+    return tokens;
+  }
+  for (const raw of matches) {
+    const type = raw.charAt(0);
+    const nums = raw.slice(1).match(NUMBER_RE);
+    tokens.push({ type, values: nums ? nums.map((n) => Number.parseFloat(n)) : [] });
+  }
+  return tokens;
+}
+function flattenSvgPath(d, curveSegments = 16) {
+  if (!Number.isFinite(curveSegments) || curveSegments < 1) curveSegments = 16;
+  curveSegments = Math.min(4096, Math.floor(curveSegments));
+  const tokens = tokenize(d);
+  const loops = [];
+  let current = [];
+  let cursor = { x: 0, y: 0 };
+  let subpathStart = { x: 0, y: 0 };
+  let lastControl;
+  let lastCommand = "";
+  const closeLoop = () => {
+    if (current.length > 0) {
+      loops.push(current);
+    }
+    current = [];
+  };
+  for (const token of tokens) {
+    const type = token.type;
+    const upper = type.toUpperCase();
+    const relative = type !== upper;
+    const v = token.values;
+    if (v.some((value) => !Number.isFinite(value)) || upper === "M" && v.length < 2) continue;
+    if (upper === "M") {
+      closeLoop();
+      const x = relative ? cursor.x + at(v, 0) : at(v, 0);
+      const y = relative ? cursor.y + at(v, 1) : at(v, 1);
+      cursor = { x, y };
+      subpathStart = cursor;
+      current.push(cursor);
+      for (let i = 2; i + 1 < v.length; i += 2) {
+        const lx = relative ? cursor.x + at(v, i) : at(v, i);
+        const ly = relative ? cursor.y + at(v, i + 1) : at(v, i + 1);
+        cursor = { x: lx, y: ly };
+        current.push(cursor);
+      }
+    } else if (upper === "L") {
+      for (let i = 0; i + 1 < v.length; i += 2) {
+        const x = relative ? cursor.x + at(v, i) : at(v, i);
+        const y = relative ? cursor.y + at(v, i + 1) : at(v, i + 1);
+        cursor = { x, y };
+        current.push(cursor);
+      }
+    } else if (upper === "H") {
+      for (const value of v) {
+        const x = relative ? cursor.x + value : value;
+        cursor = { x, y: cursor.y };
+        current.push(cursor);
+      }
+    } else if (upper === "V") {
+      for (const value of v) {
+        const y = relative ? cursor.y + value : value;
+        cursor = { x: cursor.x, y };
+        current.push(cursor);
+      }
+    } else if (upper === "C") {
+      for (let i = 0; i + 5 < v.length; i += 6) {
+        const p1 = relative ? { x: cursor.x + at(v, i), y: cursor.y + at(v, i + 1) } : { x: at(v, i), y: at(v, i + 1) };
+        const p2 = relative ? { x: cursor.x + at(v, i + 2), y: cursor.y + at(v, i + 3) } : { x: at(v, i + 2), y: at(v, i + 3) };
+        const p3 = relative ? { x: cursor.x + at(v, i + 4), y: cursor.y + at(v, i + 5) } : { x: at(v, i + 4), y: at(v, i + 5) };
+        sampleCubic(cursor, p1, p2, p3, curveSegments, current);
+        cursor = p3;
+        lastControl = p2;
+      }
+    } else if (upper === "S") {
+      for (let i = 0; i + 3 < v.length; i += 4) {
+        const p1 = lastCommand === "C" || lastCommand === "S" ? {
+          x: 2 * cursor.x - (lastControl?.x ?? cursor.x),
+          y: 2 * cursor.y - (lastControl?.y ?? cursor.y)
+        } : cursor;
+        const p2 = relative ? { x: cursor.x + at(v, i), y: cursor.y + at(v, i + 1) } : { x: at(v, i), y: at(v, i + 1) };
+        const p3 = relative ? { x: cursor.x + at(v, i + 2), y: cursor.y + at(v, i + 3) } : { x: at(v, i + 2), y: at(v, i + 3) };
+        sampleCubic(cursor, p1, p2, p3, curveSegments, current);
+        cursor = p3;
+        lastControl = p2;
+      }
+    } else if (upper === "Q") {
+      for (let i = 0; i + 3 < v.length; i += 4) {
+        const p1 = relative ? { x: cursor.x + at(v, i), y: cursor.y + at(v, i + 1) } : { x: at(v, i), y: at(v, i + 1) };
+        const p2 = relative ? { x: cursor.x + at(v, i + 2), y: cursor.y + at(v, i + 3) } : { x: at(v, i + 2), y: at(v, i + 3) };
+        sampleQuadratic(cursor, p1, p2, curveSegments, current);
+        cursor = p2;
+        lastControl = p1;
+      }
+    } else if (upper === "A") {
+      for (let i = 0; i + 6 < v.length; i += 7) {
+        const rx = at(v, i);
+        const ry = at(v, i + 1);
+        const rot = at(v, i + 2);
+        const largeArc = at(v, i + 3) !== 0;
+        const sweep = at(v, i + 4) !== 0;
+        const end = relative ? { x: cursor.x + at(v, i + 5), y: cursor.y + at(v, i + 6) } : { x: at(v, i + 5), y: at(v, i + 6) };
+        sampleArc(cursor, rx, ry, rot, largeArc, sweep, end, curveSegments, current);
+        cursor = end;
+      }
+    } else if (upper === "Z") {
+      cursor = subpathStart;
+      current.push(cursor);
+    }
+    lastCommand = upper;
+  }
+  closeLoop();
+  return loops;
+}
+
 // src/units/index.ts
 var units_exports = {};
 __export(units_exports, {
@@ -17302,7 +17851,7 @@ __export(math_exports, {
   readRunText: () => readRunText,
   rowsToLatex: () => rowsToLatex,
   soleChild: () => soleChild,
-  tokenize: () => tokenize,
+  tokenize: () => tokenize2,
   tryParseScripts: () => tryParseScripts,
   wrapDelimited: () => wrapDelimited
 });
@@ -17318,7 +17867,7 @@ function stripXmlOrderSuffix(tagName) {
 // src/math/latex-omml-siblings.ts
 var LETTER_RE = /[a-zA-Z]/u;
 var WHITESPACE_RE = /\s/u;
-function tokenize(latex) {
+function tokenize2(latex) {
   const tokens = [];
   let i = 0;
   while (i < latex.length) {
@@ -18673,7 +19222,7 @@ function convertLatexToOmml(latex) {
   if (trimmed.length === 0) {
     return {};
   }
-  const tokens = tokenize(trimmed);
+  const tokens = tokenize2(trimmed);
   const parser = new LatexParser(tokens);
   const nodes = parser.parseAll();
   if (nodes.length === 0) {
@@ -19266,4 +19815,4 @@ function parseOmml(xml) {
   return ommlFromElement(parseXml(xml, { label: "OMML" }).documentElement);
 }
 
-export { color_exports as color, diagram_exports as diagram, digest_exports as digest, geometry_exports as geometry, math_exports as math, opc_exports as opc, units_exports as units, xml_exports as xml };
+export { chart_exports as chart, color_exports as color, diagram_exports as diagram, digest_exports as digest, geometry_exports as geometry, math_exports as math, opc_exports as opc, text_exports as text, units_exports as units, xml_exports as xml };