origam 2.3.0 → 2.6.1

package/dist/src/utils/Calendar/rrule.util.cjs

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.expandRecurrence = expandRecurrence;
+exports.parseRRule = parseRRule;
+var _date = require("./date.util.cjs");
+const BY_DAY_MAP = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+function parseUntil(value) {
+  if (!value) return null;
+  const m = value.match(/^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})Z?)?$/);
+  if (!m) return null;
+  const [, yy, mm, dd, hh, mi, ss] = m;
+  const y = Number(yy);
+  const mo = Number(mm) - 1;
+  const d = Number(dd);
+  const h = hh ? Number(hh) : 23;
+  const mn = mi ? Number(mi) : 59;
+  const s = ss ? Number(ss) : 59;
+  return new Date(y, mo, d, h, mn, s);
+}
+function parseRRule(rrule) {
+  if (!rrule) return null;
+  const cleaned = rrule.replace(/^RRULE:/i, "").trim();
+  if (!cleaned) return null;
+  const parts = {};
+  for (const segment of cleaned.split(";")) {
+    const [key, value] = segment.split("=");
+    if (key && value !== void 0) parts[key.toUpperCase()] = value;
+  }
+  const freq = parts.FREQ;
+  if (freq !== "DAILY" && freq !== "WEEKLY" && freq !== "MONTHLY") return null;
+  const interval = parts.INTERVAL ? Math.max(1, Number(parts.INTERVAL)) : 1;
+  const count = parts.COUNT ? Math.max(0, Number(parts.COUNT)) : null;
+  const until = parts.UNTIL ? parseUntil(parts.UNTIL) : null;
+  const byDay = parts.BYDAY ? parts.BYDAY.split(",").map(token => BY_DAY_MAP[token.trim().toUpperCase()]).filter(value => value !== void 0) : null;
+  return {
+    freq,
+    interval,
+    count,
+    until,
+    byDay
+  };
+}
+function eventDuration(event) {
+  const start = (0, _date.toDate)(event.start);
+  const end = event.end ? (0, _date.toDate)(event.end) : null;
+  if (!start || !end) return 0;
+  return (0, _date.diffMinutes)(start, end);
+}
+function cloneOccurrence(template, occurrenceStart, durationMin) {
+  const end = durationMin > 0 ? new Date(occurrenceStart.getTime() + durationMin * 6e4) : void 0;
+  return {
+    ...template,
+    start: occurrenceStart,
+    end,
+    rrule: void 0
+  };
+}
+const MAX_OCCURRENCES = 366 * 3;
+function expandRecurrence(event, range) {
+  const start = (0, _date.toDate)(event.start);
+  if (!start) return [];
+  if (!event.rrule) {
+    if (start.getTime() > range.end.getTime()) return [];
+    const eventEnd = event.end ? (0, _date.toDate)(event.end) : null;
+    if (eventEnd && eventEnd.getTime() < range.start.getTime()) return [];
+    if (!eventEnd && start.getTime() < range.start.getTime()) return [];
+    return [event];
+  }
+  const rule = parseRRule(event.rrule);
+  if (!rule) return event.rrule ? [event] : [];
+  const duration = eventDuration(event);
+  const occurrences = [];
+  let cursor = new Date(start.getTime());
+  let emitted = 0;
+  while (cursor.getTime() <= range.end.getTime() && (!rule.until || cursor.getTime() <= rule.until.getTime()) && (rule.count == null || emitted < rule.count) && emitted < MAX_OCCURRENCES) {
+    const passesByDay = rule.freq === "WEEKLY" && rule.byDay ? rule.byDay.includes(cursor.getDay()) : true;
+    if (passesByDay && cursor.getTime() >= range.start.getTime() - duration * 6e4) {
+      occurrences.push(cloneOccurrence(event, new Date(cursor.getTime()), duration));
+    }
+    if (passesByDay) emitted++;
+    cursor = advance(cursor, rule, start);
+  }
+  return occurrences;
+}
+function advance(cursor, rule, anchor) {
+  if (rule.freq === "WEEKLY" && rule.byDay && rule.byDay.length > 0) {
+    return (0, _date.addDays)(cursor, 1);
+  }
+  if (rule.freq === "DAILY") return (0, _date.addDays)(cursor, rule.interval);
+  if (rule.freq === "WEEKLY") return (0, _date.addDays)(cursor, 7 * rule.interval);
+  const next = (0, _date.addMonths)(cursor, rule.interval);
+  next.setDate(anchor.getDate());
+  return next;
+}

package/dist/src/utils/Calendar/rrule.util.d.ts

@@ -0,0 +1,49 @@
+/**
+ * RRULE subset parser + recurrence expander.
+ *
+ * Supports — and ONLY supports — the following RFC 5545 directives:
+ * - `FREQ=DAILY | WEEKLY | MONTHLY`
+ * - `INTERVAL=N` (default 1)
+ * - `COUNT=N` (caps occurrences)
+ * - `UNTIL=YYYYMMDDTHHMMSSZ` (ISO 8601 basic with optional `Z`)
+ * - `BYDAY=MO,TU,...` (only for `FREQ=WEEKLY`)
+ *
+ * Everything else (`BYMONTHDAY`, `BYSETPOS`, `BYMONTH`, `BYHOUR`,
+ * `WKST`, `EXDATE`, …) is silently ignored. This matches what
+ * @origam/Calendar promises in its docs: a minimal subset that
+ * handles 95% of "every Monday/Wednesday/Friday at 10am"-style
+ * patterns without dragging in a full RRULE engine like `rrule.js`.
+ *
+ * Pure / SSR-safe: no `Date.now()` at module scope, no DOM access.
+ */
+import type { IEvent } from '../../interfaces';
+interface IParsedRule {
+    freq: 'DAILY' | 'WEEKLY' | 'MONTHLY';
+    interval: number;
+    count: number | null;
+    until: Date | null;
+    byDay: Array<number> | null;
+}
+/**
+ * Parse a raw RRULE string into a normalized rule object. Returns
+ * `null` when the directive is malformed or uses an unsupported
+ * `FREQ` value — the caller should fall back to single-occurrence
+ * rendering in that case.
+ */
+export declare function parseRRule(rrule: string): IParsedRule | null;
+/**
+ * Expand an event with an `rrule` into the list of concrete
+ * occurrences that fall inside `[range.start, range.end]`. Events
+ * without an `rrule` are passed through as a single-element list.
+ *
+ * The expander stops at the first of:
+ * - `range.end`
+ * - `rule.until`
+ * - `rule.count` reached
+ * - `MAX_OCCURRENCES` reached (safety net)
+ */
+export declare function expandRecurrence(event: IEvent, range: {
+    start: Date;
+    end: Date;
+}): Array<IEvent>;
+export {};

package/dist/src/utils/Calendar/rrule.util.js

@@ -0,0 +1,92 @@
+import { addDays, addMonths, diffMinutes, toDate } from "./date.util.js";
+const BY_DAY_MAP = {
+  SU: 0,
+  MO: 1,
+  TU: 2,
+  WE: 3,
+  TH: 4,
+  FR: 5,
+  SA: 6
+};
+function parseUntil(value) {
+  if (!value) return null;
+  const m = value.match(/^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})Z?)?$/);
+  if (!m) return null;
+  const [, yy, mm, dd, hh, mi, ss] = m;
+  const y = Number(yy);
+  const mo = Number(mm) - 1;
+  const d = Number(dd);
+  const h = hh ? Number(hh) : 23;
+  const mn = mi ? Number(mi) : 59;
+  const s = ss ? Number(ss) : 59;
+  return new Date(y, mo, d, h, mn, s);
+}
+export function parseRRule(rrule) {
+  if (!rrule) return null;
+  const cleaned = rrule.replace(/^RRULE:/i, "").trim();
+  if (!cleaned) return null;
+  const parts = {};
+  for (const segment of cleaned.split(";")) {
+    const [key, value] = segment.split("=");
+    if (key && value !== void 0) parts[key.toUpperCase()] = value;
+  }
+  const freq = parts.FREQ;
+  if (freq !== "DAILY" && freq !== "WEEKLY" && freq !== "MONTHLY") return null;
+  const interval = parts.INTERVAL ? Math.max(1, Number(parts.INTERVAL)) : 1;
+  const count = parts.COUNT ? Math.max(0, Number(parts.COUNT)) : null;
+  const until = parts.UNTIL ? parseUntil(parts.UNTIL) : null;
+  const byDay = parts.BYDAY ? parts.BYDAY.split(",").map((token) => BY_DAY_MAP[token.trim().toUpperCase()]).filter((value) => value !== void 0) : null;
+  return { freq, interval, count, until, byDay };
+}
+function eventDuration(event) {
+  const start = toDate(event.start);
+  const end = event.end ? toDate(event.end) : null;
+  if (!start || !end) return 0;
+  return diffMinutes(start, end);
+}
+function cloneOccurrence(template, occurrenceStart, durationMin) {
+  const end = durationMin > 0 ? new Date(occurrenceStart.getTime() + durationMin * 6e4) : void 0;
+  return {
+    ...template,
+    start: occurrenceStart,
+    end,
+    rrule: void 0
+  };
+}
+const MAX_OCCURRENCES = 366 * 3;
+export function expandRecurrence(event, range) {
+  const start = toDate(event.start);
+  if (!start) return [];
+  if (!event.rrule) {
+    if (start.getTime() > range.end.getTime()) return [];
+    const eventEnd = event.end ? toDate(event.end) : null;
+    if (eventEnd && eventEnd.getTime() < range.start.getTime()) return [];
+    if (!eventEnd && start.getTime() < range.start.getTime()) return [];
+    return [event];
+  }
+  const rule = parseRRule(event.rrule);
+  if (!rule) return event.rrule ? [event] : [];
+  const duration = eventDuration(event);
+  const occurrences = [];
+  let cursor = new Date(start.getTime());
+  let emitted = 0;
+  while (cursor.getTime() <= range.end.getTime() && (!rule.until || cursor.getTime() <= rule.until.getTime()) && (rule.count == null || emitted < rule.count) && emitted < MAX_OCCURRENCES) {
+    const passesByDay = rule.freq === "WEEKLY" && rule.byDay ? rule.byDay.includes(cursor.getDay()) : true;
+    if (passesByDay && cursor.getTime() >= range.start.getTime() - duration * 6e4) {
+      occurrences.push(cloneOccurrence(event, new Date(cursor.getTime()), duration));
+    }
+    if (passesByDay) emitted++;
+    cursor = advance(cursor, rule, start);
+  }
+  return occurrences;
+}
+function advance(cursor, rule, anchor) {
+  if (rule.freq === "WEEKLY" && rule.byDay && rule.byDay.length > 0) {
+    return addDays(cursor, 1);
+  }
+  if (rule.freq === "DAILY") return addDays(cursor, rule.interval);
+  if (rule.freq === "WEEKLY") return addDays(cursor, 7 * rule.interval);
+  const next = addMonths(cursor, rule.interval);
+  next.setDate(anchor.getDate());
+  return next;
+}

package/dist/src/utils/Chart/box-plot.util.cjs

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeQuartiles = computeQuartiles;
+exports.isRawDatum = isRawDatum;
+const interpolate = (sorted, p) => {
+  const n = sorted.length;
+  if (n === 0) return 0;
+  if (n === 1) return sorted[0];
+  const pos = p * (n - 1);
+  const lo = Math.floor(pos);
+  const hi = Math.ceil(pos);
+  const frac = pos - lo;
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + frac * (sorted[hi] - sorted[lo]);
+};
+function computeQuartiles(samples) {
+  const finite = samples.filter(v => Number.isFinite(v));
+  if (finite.length === 0) {
+    return {
+      min: 0,
+      q1: 0,
+      median: 0,
+      q3: 0,
+      max: 0,
+      iqr: 0,
+      outliers: []
+    };
+  }
+  const sorted = [...finite].sort((a, b) => a - b);
+  const q1 = interpolate(sorted, 0.25);
+  const median = interpolate(sorted, 0.5);
+  const q3 = interpolate(sorted, 0.75);
+  const iqr = q3 - q1;
+  const lowerFence = q1 - 1.5 * iqr;
+  const upperFence = q3 + 1.5 * iqr;
+  const outliers = [];
+  const inliers = [];
+  for (const v of sorted) {
+    if (v < lowerFence || v > upperFence) {
+      outliers.push(v);
+    } else {
+      inliers.push(v);
+    }
+  }
+  const whiskerMin = inliers.length > 0 ? inliers[0] : sorted[0];
+  const whiskerMax = inliers.length > 0 ? inliers[inliers.length - 1] : sorted[sorted.length - 1];
+  return {
+    min: whiskerMin,
+    q1,
+    median,
+    q3,
+    max: whiskerMax,
+    iqr,
+    outliers
+  };
+}
+function isRawDatum(datum) {
+  return typeof datum === "object" && datum !== null && Array.isArray(datum.samples);
+}

package/dist/src/utils/Chart/box-plot.util.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tukey five-number summary computation with 1.5·IQR outlier detection.
+ *
+ * Algorithm:
+ *  1. Sort samples ascending.
+ *  2. Compute Q1 and Q3 via linear interpolation at the 25th and 75th
+ *     percentile positions (same as PERCENTILE.INC in Excel / numpy).
+ *  3. Compute IQR = Q3 − Q1.
+ *  4. Lower fence = Q1 − 1.5·IQR; upper fence = Q3 + 1.5·IQR.
+ *  5. Whisker min = smallest sample >= lower fence.
+ *     Whisker max = largest sample <= upper fence.
+ *  6. Outliers = samples outside [lower fence, upper fence].
+ */
+import type { IBoxPlotStats } from '../../interfaces/Chart/chart-box-plot.interface';
+export type { IBoxPlotStats };
+/**
+ * Computes the five-number Tukey summary for the given sample array.
+ *
+ * @param samples - Array of numeric observations (need not be sorted,
+ *   may be empty).
+ * @returns Statistical summary with whisker bounds and outlier list.
+ */
+export declare function computeQuartiles(samples: Array<number>): IBoxPlotStats;
+/**
+ * Returns `true` if the given datum is a raw-samples datum (has a
+ * `samples` array property rather than pre-aggregated stats).
+ */
+export declare function isRawDatum(datum: unknown): datum is {
+    category: string;
+    samples: Array<number>;
+    color?: string;
+};

package/dist/src/utils/Chart/box-plot.util.js

@@ -0,0 +1,47 @@
+const interpolate = (sorted, p) => {
+  const n = sorted.length;
+  if (n === 0) return 0;
+  if (n === 1) return sorted[0];
+  const pos = p * (n - 1);
+  const lo = Math.floor(pos);
+  const hi = Math.ceil(pos);
+  const frac = pos - lo;
+  if (lo === hi) return sorted[lo];
+  return sorted[lo] + frac * (sorted[hi] - sorted[lo]);
+};
+export function computeQuartiles(samples) {
+  const finite = samples.filter((v) => Number.isFinite(v));
+  if (finite.length === 0) {
+    return { min: 0, q1: 0, median: 0, q3: 0, max: 0, iqr: 0, outliers: [] };
+  }
+  const sorted = [...finite].sort((a, b) => a - b);
+  const q1 = interpolate(sorted, 0.25);
+  const median = interpolate(sorted, 0.5);
+  const q3 = interpolate(sorted, 0.75);
+  const iqr = q3 - q1;
+  const lowerFence = q1 - 1.5 * iqr;
+  const upperFence = q3 + 1.5 * iqr;
+  const outliers = [];
+  const inliers = [];
+  for (const v of sorted) {
+    if (v < lowerFence || v > upperFence) {
+      outliers.push(v);
+    } else {
+      inliers.push(v);
+    }
+  }
+  const whiskerMin = inliers.length > 0 ? inliers[0] : sorted[0];
+  const whiskerMax = inliers.length > 0 ? inliers[inliers.length - 1] : sorted[sorted.length - 1];
+  return {
+    min: whiskerMin,
+    q1,
+    median,
+    q3,
+    max: whiskerMax,
+    iqr,
+    outliers
+  };
+}
+export function isRawDatum(datum) {
+  return typeof datum === "object" && datum !== null && Array.isArray(datum.samples);
+}

package/dist/src/utils/Chart/mercator.util.cjs

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mercatorProject = mercatorProject;
+exports.multiPolygonCentroid = multiPolygonCentroid;
+exports.multiPolygonToSvgPath = multiPolygonToSvgPath;
+exports.polygonToSvgPath = polygonToSvgPath;
+const LNG_MIN = -180;
+const LNG_MAX = 180;
+const LAT_MAX_MERCATOR = 85.051129;
+function mercatorY(lat) {
+  const radLat = lat * Math.PI / 180;
+  return Math.log(Math.tan(Math.PI / 4 + radLat / 2));
+}
+const MERC_Y_MIN = mercatorY(-LAT_MAX_MERCATOR);
+const MERC_Y_MAX = mercatorY(LAT_MAX_MERCATOR);
+function mercatorProject(lng, lat, width = 1e3, height = 500) {
+  const clampedLat = Math.max(-LAT_MAX_MERCATOR, Math.min(LAT_MAX_MERCATOR, lat));
+  const x = (lng - LNG_MIN) / (LNG_MAX - LNG_MIN) * width;
+  const my = mercatorY(clampedLat);
+  const y = (MERC_Y_MAX - my) / (MERC_Y_MAX - MERC_Y_MIN) * height;
+  return [Math.round(x * 10) / 10, Math.round(y * 10) / 10];
+}
+function polygonToSvgPath(polygon, width = 1e3, height = 500) {
+  if (polygon.length < 3) return "";
+  const projected = polygon.map(([lng, lat]) => mercatorProject(lng, lat, width, height));
+  const [first, ...rest] = projected;
+  const parts = [`M${first[0]},${first[1]}`];
+  for (const [px, py] of rest) {
+    parts.push(`L${px},${py}`);
+  }
+  parts.push("Z");
+  return parts.join(" ");
+}
+function multiPolygonToSvgPath(multi, width = 1e3, height = 500) {
+  return multi.map(polygon => polygonToSvgPath(polygon, width, height)).filter(Boolean).join(" ");
+}
+function multiPolygonCentroid(multi, width = 1e3, height = 500) {
+  let lngSum = 0;
+  let latSum = 0;
+  let count = 0;
+  for (const polygon of multi) {
+    for (const [lng, lat] of polygon) {
+      lngSum += lng;
+      latSum += lat;
+      count++;
+    }
+  }
+  if (count === 0) return [width / 2, height / 2];
+  return mercatorProject(lngSum / count, latSum / count, width, height);
+}

package/dist/src/utils/Chart/mercator.util.d.ts

@@ -0,0 +1,51 @@
+/**
+ * mercator.util.ts
+ *
+ * Web Mercator projection helpers for the OrigamChartMap component.
+ *
+ * Reference system: 1000 × 500 canvas, longitude [-180, 180], latitude [-85, 85].
+ * The projection clips at ±85° latitude to avoid Mercator divergence at the poles.
+ *
+ * Verified reference point:
+ *   Paris (lng=2.35, lat=48.85) → ~(506, 162) on a 1000×500 canvas.
+ */
+/**
+ * Projects a geographic coordinate (WGS-84) into SVG pixel space.
+ * Uses the Web Mercator (EPSG:3857) formula normalised to [0, width] × [0, height].
+ *
+ * @param lng   Longitude in degrees, range [-180, 180]
+ * @param lat   Latitude in degrees, range [-85, 85]
+ * @param width  SVG canvas width  (default 1000)
+ * @param height SVG canvas height (default 500)
+ * @returns [x, y] in SVG pixel space
+ */
+export declare function mercatorProject(lng: number, lat: number, width?: number, height?: number): [number, number];
+/**
+ * Converts a single polygon (array of [lng, lat] pairs) to an SVG path string.
+ *
+ * @param polygon  Array of [lng, lat] geographic pairs
+ * @param width    SVG canvas width  (default 1000)
+ * @param height   SVG canvas height (default 500)
+ * @returns SVG `d` attribute string (closed polygon with Z)
+ */
+export declare function polygonToSvgPath(polygon: Array<[number, number]>, width?: number, height?: number): string;
+/**
+ * Converts a multi-polygon (array of polygon rings) to a single compound SVG path string.
+ * All polygons are joined into one `d` attribute, allowing SVG fill rules to apply.
+ *
+ * @param multi   Array of polygons, each polygon is Array<[lng, lat]>
+ * @param width   SVG canvas width  (default 1000)
+ * @param height  SVG canvas height (default 500)
+ * @returns SVG `d` attribute string (multiple M…Z subpaths)
+ */
+export declare function multiPolygonToSvgPath(multi: Array<Array<[number, number]>>, width?: number, height?: number): string;
+/**
+ * Computes the geographic centroid of a set of polygons (arithmetic mean of all vertices).
+ * Returns the centroid projected into SVG pixel space.
+ *
+ * @param multi   Multi-polygon data (Array<Array<[lng, lat]>>)
+ * @param width   SVG canvas width  (default 1000)
+ * @param height  SVG canvas height (default 500)
+ * @returns [x, y] centroid in SVG pixel space
+ */
+export declare function multiPolygonCentroid(multi: Array<Array<[number, number]>>, width?: number, height?: number): [number, number];

package/dist/src/utils/Chart/mercator.util.js

@@ -0,0 +1,44 @@
+const LNG_MIN = -180;
+const LNG_MAX = 180;
+const LAT_MAX_MERCATOR = 85.051129;
+function mercatorY(lat) {
+  const radLat = lat * Math.PI / 180;
+  return Math.log(Math.tan(Math.PI / 4 + radLat / 2));
+}
+const MERC_Y_MIN = mercatorY(-LAT_MAX_MERCATOR);
+const MERC_Y_MAX = mercatorY(LAT_MAX_MERCATOR);
+export function mercatorProject(lng, lat, width = 1e3, height = 500) {
+  const clampedLat = Math.max(-LAT_MAX_MERCATOR, Math.min(LAT_MAX_MERCATOR, lat));
+  const x = (lng - LNG_MIN) / (LNG_MAX - LNG_MIN) * width;
+  const my = mercatorY(clampedLat);
+  const y = (MERC_Y_MAX - my) / (MERC_Y_MAX - MERC_Y_MIN) * height;
+  return [Math.round(x * 10) / 10, Math.round(y * 10) / 10];
+}
+export function polygonToSvgPath(polygon, width = 1e3, height = 500) {
+  if (polygon.length < 3) return "";
+  const projected = polygon.map(([lng, lat]) => mercatorProject(lng, lat, width, height));
+  const [first, ...rest] = projected;
+  const parts = [`M${first[0]},${first[1]}`];
+  for (const [px, py] of rest) {
+    parts.push(`L${px},${py}`);
+  }
+  parts.push("Z");
+  return parts.join(" ");
+}
+export function multiPolygonToSvgPath(multi, width = 1e3, height = 500) {
+  return multi.map((polygon) => polygonToSvgPath(polygon, width, height)).filter(Boolean).join(" ");
+}
+export function multiPolygonCentroid(multi, width = 1e3, height = 500) {
+  let lngSum = 0;
+  let latSum = 0;
+  let count = 0;
+  for (const polygon of multi) {
+    for (const [lng, lat] of polygon) {
+      lngSum += lng;
+      latSum += lat;
+      count++;
+    }
+  }
+  if (count === 0) return [width / 2, height / 2];
+  return mercatorProject(lngSum / count, latSum / count, width, height);
+}

package/dist/src/utils/Chart/path.util.cjs

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.steppedPathLength = exports.steppedPath = exports.smoothPath = exports.polygonPath = exports.polarToCartesian = exports.pathLength = exports.monotonePath = exports.linePath = exports.areaPath = exports.arcPath = void 0;
+const linePath = points => {
+  if (!points.length) return "";
+  const [first, ...rest] = points;
+  const head = `M${formatNum(first[0])},${formatNum(first[1])}`;
+  const tail = rest.map(([x, y]) => `L${formatNum(x)},${formatNum(y)}`).join(" ");
+  return tail.length ? `${head} ${tail}` : head;
+};
+exports.linePath = linePath;
+const smoothPath = points => {
+  if (points.length < 3) return linePath(points);
+  const [first] = points;
+  let d = `M${formatNum(first[0])},${formatNum(first[1])}`;
+  for (let i = 0; i < points.length - 1; i++) {
+    const p0 = points[i - 1] ?? points[i];
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const p3 = points[i + 2] ?? p2;
+    const cp1x = p1[0] + (p2[0] - p0[0]) / 6;
+    const cp1y = p1[1] + (p2[1] - p0[1]) / 6;
+    const cp2x = p2[0] - (p3[0] - p1[0]) / 6;
+    const cp2y = p2[1] - (p3[1] - p1[1]) / 6;
+    d += ` C${formatNum(cp1x)},${formatNum(cp1y)} ${formatNum(cp2x)},${formatNum(cp2y)} ${formatNum(p2[0])},${formatNum(p2[1])}`;
+  }
+  return d;
+};
+exports.smoothPath = smoothPath;
+const monotonePath = points => {
+  if (points.length < 3) return linePath(points);
+  const n = points.length;
+  const dx = [];
+  const dy = [];
+  const m = [];
+  for (let i = 0; i < n - 1; i++) {
+    dx.push(points[i + 1][0] - points[i][0]);
+    dy.push(points[i + 1][1] - points[i][1]);
+    m.push(dx[i] === 0 ? 0 : dy[i] / dx[i]);
+  }
+  const t = new Array(n);
+  t[0] = m[0];
+  t[n - 1] = m[n - 2];
+  for (let i = 1; i < n - 1; i++) {
+    if (m[i - 1] * m[i] <= 0) {
+      t[i] = 0;
+    } else {
+      const w1 = 2 * dx[i] + dx[i - 1];
+      const w2 = dx[i] + 2 * dx[i - 1];
+      t[i] = (w1 + w2) / (w1 / m[i - 1] + w2 / m[i]);
+    }
+  }
+  let d = `M${formatNum(points[0][0])},${formatNum(points[0][1])}`;
+  for (let i = 0; i < n - 1; i++) {
+    const cp1x = points[i][0] + dx[i] / 3;
+    const cp1y = points[i][1] + t[i] * dx[i] / 3;
+    const cp2x = points[i + 1][0] - dx[i] / 3;
+    const cp2y = points[i + 1][1] - t[i + 1] * dx[i] / 3;
+    d += ` C${formatNum(cp1x)},${formatNum(cp1y)} ${formatNum(cp2x)},${formatNum(cp2y)} ${formatNum(points[i + 1][0])},${formatNum(points[i + 1][1])}`;
+  }
+  return d;
+};
+exports.monotonePath = monotonePath;
+const steppedPath = points => {
+  if (!points.length) return "";
+  const [first, ...rest] = points;
+  let d = `M${formatNum(first[0])},${formatNum(first[1])}`;
+  let prevY = first[1];
+  for (const [x, y] of rest) {
+    d += ` L${formatNum(x)},${formatNum(prevY)} L${formatNum(x)},${formatNum(y)}`;
+    prevY = y;
+  }
+  return d;
+};
+exports.steppedPath = steppedPath;
+const areaPath = (points, baselineY, smooth = false) => {
+  if (!points.length) return "";
+  let lineD;
+  if (smooth === "monotone") lineD = monotonePath(points);else if (smooth === "stepped") lineD = steppedPath(points);else if (smooth === true) lineD = smoothPath(points);else lineD = linePath(points);
+  const lastX = points[points.length - 1][0];
+  const firstX = points[0][0];
+  return `${lineD} L${formatNum(lastX)},${formatNum(baselineY)} L${formatNum(firstX)},${formatNum(baselineY)} Z`;
+};
+exports.areaPath = areaPath;
+const arcPath = (cx, cy, outerR, innerR, startAngle, endAngle) => {
+  const sweep = endAngle - startAngle;
+  if (Math.abs(sweep) < 1e-6) return "";
+  const toSvg = a => a - Math.PI / 2;
+  const sa = toSvg(startAngle);
+  const ea = toSvg(endAngle);
+  const largeArc = Math.abs(sweep) > Math.PI ? 1 : 0;
+  const sweepFlag = sweep > 0 ? 1 : 0;
+  const x1 = cx + outerR * Math.cos(sa);
+  const y1 = cy + outerR * Math.sin(sa);
+  const x2 = cx + outerR * Math.cos(ea);
+  const y2 = cy + outerR * Math.sin(ea);
+  if (innerR <= 0) {
+    return `M${formatNum(cx)},${formatNum(cy)} L${formatNum(x1)},${formatNum(y1)} A${formatNum(outerR)},${formatNum(outerR)} 0 ${largeArc},${sweepFlag} ${formatNum(x2)},${formatNum(y2)} Z`;
+  }
+  const ix1 = cx + innerR * Math.cos(sa);
+  const iy1 = cy + innerR * Math.sin(sa);
+  const ix2 = cx + innerR * Math.cos(ea);
+  const iy2 = cy + innerR * Math.sin(ea);
+  const innerSweepFlag = sweep > 0 ? 0 : 1;
+  return [`M${formatNum(x1)},${formatNum(y1)}`, `A${formatNum(outerR)},${formatNum(outerR)} 0 ${largeArc},${sweepFlag} ${formatNum(x2)},${formatNum(y2)}`, `L${formatNum(ix2)},${formatNum(iy2)}`, `A${formatNum(innerR)},${formatNum(innerR)} 0 ${largeArc},${innerSweepFlag} ${formatNum(ix1)},${formatNum(iy1)}`, "Z"].join(" ");
+};
+exports.arcPath = arcPath;
+const polygonPath = points => {
+  if (!points.length) return "";
+  const [first, ...rest] = points;
+  const head = `M${formatNum(first[0])},${formatNum(first[1])}`;
+  const tail = rest.map(([x, y]) => `L${formatNum(x)},${formatNum(y)}`).join(" ");
+  return tail.length ? `${head} ${tail} Z` : `${head} Z`;
+};
+exports.polygonPath = polygonPath;
+const pathLength = points => {
+  if (points.length < 2) return 0;
+  let total = 0;
+  for (let i = 1; i < points.length; i++) {
+    const dx = points[i][0] - points[i - 1][0];
+    const dy = points[i][1] - points[i - 1][1];
+    total += Math.sqrt(dx * dx + dy * dy);
+  }
+  return total;
+};
+exports.pathLength = pathLength;
+const steppedPathLength = points => {
+  if (points.length < 2) return 0;
+  let total = 0;
+  for (let i = 1; i < points.length; i++) {
+    const dx = Math.abs(points[i][0] - points[i - 1][0]);
+    const dy = Math.abs(points[i][1] - points[i - 1][1]);
+    total += dx + dy;
+  }
+  return total;
+};
+exports.steppedPathLength = steppedPathLength;
+const polarToCartesian = (cx, cy, radius, angle) => {
+  const a = angle - Math.PI / 2;
+  return [cx + radius * Math.cos(a), cy + radius * Math.sin(a)];
+};
+exports.polarToCartesian = polarToCartesian;
+const formatNum = n => {
+  if (!Number.isFinite(n)) return "0";
+  const rounded = Math.round(n * 1e3) / 1e3;
+  return rounded === 0 ? "0" : String(rounded);
+};