@stroke-stabilizer/core 0.2.16 → 0.3.1

package/dist/index.cjs

@@ -502,10 +502,10 @@ class StabilizedPointer {
     return "updateParams" in filter && typeof filter.updateParams === "function";
   }
 }
-const FILTER_TYPE$6 = "noise";
+const FILTER_TYPE$7 = "noise";
 class NoiseFilterImpl {
   constructor(params) {
-    this.type = FILTER_TYPE$6;
+    this.type = FILTER_TYPE$7;
     this.lastPoint = null;
     this.params = { ...params };
   }
@@ -533,10 +533,10 @@ class NoiseFilterImpl {
 function noiseFilter(params) {
   return new NoiseFilterImpl(params);
 }
-const FILTER_TYPE$5 = "kalman";
+const FILTER_TYPE$6 = "kalman";
 class KalmanFilterImpl {
   constructor(params) {
-    this.type = FILTER_TYPE$5;
+    this.type = FILTER_TYPE$6;
     this.state = null;
     this.params = { ...params };
   }
@@ -568,6 +568,8 @@ class KalmanFilterImpl {
       x: newX,
       y: newY,
       pressure: point.pressure,
+      tiltX: point.tiltX,
+      tiltY: point.tiltY,
       timestamp: point.timestamp
     };
   }
@@ -581,10 +583,10 @@ class KalmanFilterImpl {
 function kalmanFilter(params) {
   return new KalmanFilterImpl(params);
 }
-const FILTER_TYPE$4 = "movingAverage";
+const FILTER_TYPE$5 = "movingAverage";
 class MovingAverageFilterImpl {
   constructor(params) {
-    this.type = FILTER_TYPE$4;
+    this.type = FILTER_TYPE$5;
     this.window = [];
     this.params = { ...params };
   }
@@ -597,6 +599,10 @@ class MovingAverageFilterImpl {
     let sumY = 0;
     let sumPressure = 0;
     let pressureCount = 0;
+    let sumTiltX = 0;
+    let tiltXCount = 0;
+    let sumTiltY = 0;
+    let tiltYCount = 0;
     for (const p of this.window) {
       sumX += p.x;
       sumY += p.y;
@@ -604,14 +610,26 @@ class MovingAverageFilterImpl {
         sumPressure += p.pressure;
         pressureCount++;
       }
+      if (p.tiltX !== void 0) {
+        sumTiltX += p.tiltX;
+        tiltXCount++;
+      }
+      if (p.tiltY !== void 0) {
+        sumTiltY += p.tiltY;
+        tiltYCount++;
+      }
     }
     const avgX = sumX / this.window.length;
     const avgY = sumY / this.window.length;
     const avgPressure = pressureCount > 0 ? sumPressure / pressureCount : void 0;
+    const avgTiltX = tiltXCount > 0 ? sumTiltX / tiltXCount : void 0;
+    const avgTiltY = tiltYCount > 0 ? sumTiltY / tiltYCount : void 0;
     return {
       x: avgX,
       y: avgY,
       pressure: avgPressure,
+      tiltX: avgTiltX,
+      tiltY: avgTiltY,
       timestamp: point.timestamp
     };
   }
@@ -628,10 +646,10 @@ class MovingAverageFilterImpl {
 function movingAverageFilter(params) {
   return new MovingAverageFilterImpl(params);
 }
-const FILTER_TYPE$3 = "string";
+const FILTER_TYPE$4 = "string";
 class StringFilterImpl {
   constructor(params) {
-    this.type = FILTER_TYPE$3;
+    this.type = FILTER_TYPE$4;
     this.anchorPoint = null;
     this.params = { ...params };
   }
@@ -647,6 +665,8 @@ class StringFilterImpl {
       return {
         ...this.anchorPoint,
         pressure: point.pressure,
+        tiltX: point.tiltX,
+        tiltY: point.tiltY,
         timestamp: point.timestamp
       };
     }
@@ -657,6 +677,8 @@ class StringFilterImpl {
       x: newX,
       y: newY,
       pressure: point.pressure,
+      tiltX: point.tiltX,
+      tiltY: point.tiltY,
       timestamp: point.timestamp
     };
     return this.anchorPoint;
@@ -671,10 +693,10 @@ class StringFilterImpl {
 function stringFilter(params) {
   return new StringFilterImpl(params);
 }
-const FILTER_TYPE$2 = "ema";
+const FILTER_TYPE$3 = "ema";
 class EmaFilterImpl {
   constructor(params) {
-    this.type = FILTER_TYPE$2;
+    this.type = FILTER_TYPE$3;
     this.lastPoint = null;
     this.params = { ...params };
   }
@@ -692,10 +714,24 @@ class EmaFilterImpl {
     } else {
       newPressure = point.pressure;
     }
+    let newTiltX;
+    if (point.tiltX !== void 0 && this.lastPoint.tiltX !== void 0) {
+      newTiltX = alpha * point.tiltX + (1 - alpha) * this.lastPoint.tiltX;
+    } else {
+      newTiltX = point.tiltX;
+    }
+    let newTiltY;
+    if (point.tiltY !== void 0 && this.lastPoint.tiltY !== void 0) {
+      newTiltY = alpha * point.tiltY + (1 - alpha) * this.lastPoint.tiltY;
+    } else {
+      newTiltY = point.tiltY;
+    }
     this.lastPoint = {
       x: newX,
       y: newY,
       pressure: newPressure,
+      tiltX: newTiltX,
+      tiltY: newTiltY,
       timestamp: point.timestamp
     };
     return this.lastPoint;
@@ -710,7 +746,7 @@ class EmaFilterImpl {
 function emaFilter(params) {
   return new EmaFilterImpl(params);
 }
-const FILTER_TYPE$1 = "oneEuro";
+const FILTER_TYPE$2 = "oneEuro";
 class LowPassFilter {
   constructor() {
     this.y = null;
@@ -736,12 +772,14 @@ class LowPassFilter {
 }
 class OneEuroFilterImpl {
   constructor(params) {
-    this.type = FILTER_TYPE$1;
+    this.type = FILTER_TYPE$2;
     this.xFilter = new LowPassFilter();
     this.yFilter = new LowPassFilter();
     this.dxFilter = new LowPassFilter();
     this.dyFilter = new LowPassFilter();
     this.pressureFilter = new LowPassFilter();
+    this.tiltXFilter = new LowPassFilter();
+    this.tiltYFilter = new LowPassFilter();
     this.lastTimestamp = null;
     this.params = {
       dCutoff: 1,
@@ -782,10 +820,24 @@ class OneEuroFilterImpl {
       this.pressureFilter.setAlpha(alpha);
       newPressure = this.pressureFilter.filter(point.pressure);
     }
+    let newTiltX;
+    if (point.tiltX !== void 0) {
+      const alpha = this.computeAlpha(minCutoff, rate);
+      this.tiltXFilter.setAlpha(alpha);
+      newTiltX = this.tiltXFilter.filter(point.tiltX);
+    }
+    let newTiltY;
+    if (point.tiltY !== void 0) {
+      const alpha = this.computeAlpha(minCutoff, rate);
+      this.tiltYFilter.setAlpha(alpha);
+      newTiltY = this.tiltYFilter.filter(point.tiltY);
+    }
     return {
       x: newX,
       y: newY,
       pressure: newPressure,
+      tiltX: newTiltX,
+      tiltY: newTiltY,
       timestamp: point.timestamp
     };
   }
@@ -817,16 +869,18 @@ class OneEuroFilterImpl {
     this.dxFilter.reset();
     this.dyFilter.reset();
     this.pressureFilter.reset();
+    this.tiltXFilter.reset();
+    this.tiltYFilter.reset();
     this.lastTimestamp = null;
   }
 }
 function oneEuroFilter(params) {
   return new OneEuroFilterImpl(params);
 }
-const FILTER_TYPE = "linearPrediction";
+const FILTER_TYPE$1 = "linearPrediction";
 class LinearPredictionFilterImpl {
   constructor(params) {
-    this.type = FILTER_TYPE;
+    this.type = FILTER_TYPE$1;
     this.history = [];
     this.lastOutput = null;
     this.params = {
@@ -851,6 +905,8 @@ class LinearPredictionFilterImpl {
     let outputX = predictedX;
     let outputY = predictedY;
     let outputPressure = point.pressure;
+    let outputTiltX = point.tiltX;
+    let outputTiltY = point.tiltY;
     if (this.lastOutput !== null && this.params.smoothing !== void 0) {
       const s = this.params.smoothing;
       outputX = s * predictedX + (1 - s) * this.lastOutput.x;
@@ -858,11 +914,19 @@ class LinearPredictionFilterImpl {
       if (point.pressure !== void 0 && this.lastOutput.pressure !== void 0) {
         outputPressure = s * point.pressure + (1 - s) * this.lastOutput.pressure;
       }
+      if (point.tiltX !== void 0 && this.lastOutput.tiltX !== void 0) {
+        outputTiltX = s * point.tiltX + (1 - s) * this.lastOutput.tiltX;
+      }
+      if (point.tiltY !== void 0 && this.lastOutput.tiltY !== void 0) {
+        outputTiltY = s * point.tiltY + (1 - s) * this.lastOutput.tiltY;
+      }
     }
     this.lastOutput = {
       x: outputX,
       y: outputY,
       pressure: outputPressure,
+      tiltX: outputTiltX,
+      tiltY: outputTiltY,
       timestamp: point.timestamp
     };
     return this.lastOutput;
@@ -958,6 +1022,84 @@ class LinearPredictionFilterImpl {
 function linearPredictionFilter(params) {
   return new LinearPredictionFilterImpl(params);
 }
+const FILTER_TYPE = "douglasPeucker";
+class DouglasPeuckerFilterImpl {
+  constructor(params) {
+    this.type = FILTER_TYPE;
+    this.points = [];
+    this.params = { ...params };
+  }
+  process(point) {
+    this.points.push(point);
+    return point;
+  }
+  updateParams(params) {
+    this.params = { ...this.params, ...params };
+  }
+  reset() {
+    this.points = [];
+  }
+  /**
+   * Get the simplified points without clearing the buffer
+   */
+  getSimplified() {
+    if (this.points.length <= 2) {
+      return [...this.points];
+    }
+    return simplifyDouglasPeucker(this.points, this.params.epsilon);
+  }
+  /**
+   * Get all collected points
+   */
+  getPoints() {
+    return [...this.points];
+  }
+}
+function perpendicularDistance(point, lineStart, lineEnd) {
+  const dx = lineEnd.x - lineStart.x;
+  const dy = lineEnd.y - lineStart.y;
+  const lengthSq = dx * dx + dy * dy;
+  if (lengthSq === 0) {
+    const pdx = point.x - lineStart.x;
+    const pdy = point.y - lineStart.y;
+    return Math.sqrt(pdx * pdx + pdy * pdy);
+  }
+  const numerator = Math.abs(
+    dy * point.x - dx * point.y + lineEnd.x * lineStart.y - lineEnd.y * lineStart.x
+  );
+  return numerator / Math.sqrt(lengthSq);
+}
+function simplifyDouglasPeucker(points, epsilon) {
+  if (points.length <= 2) {
+    return points;
+  }
+  let maxDistance = 0;
+  let maxIndex = 0;
+  const first = points[0];
+  const last = points[points.length - 1];
+  for (let i = 1; i < points.length - 1; i++) {
+    const distance = perpendicularDistance(points[i], first, last);
+    if (distance > maxDistance) {
+      maxDistance = distance;
+      maxIndex = i;
+    }
+  }
+  if (maxDistance > epsilon) {
+    const left = simplifyDouglasPeucker(points.slice(0, maxIndex + 1), epsilon);
+    const right = simplifyDouglasPeucker(points.slice(maxIndex), epsilon);
+    return [...left.slice(0, -1), ...right];
+  }
+  return [first, last];
+}
+function douglasPeuckerFilter(params) {
+  return new DouglasPeuckerFilterImpl(params);
+}
+function simplify(points, epsilon) {
+  if (points.length <= 2) {
+    return [...points];
+  }
+  return simplifyDouglasPeucker(points, epsilon);
+}
 function createStabilizedPointer(level) {
   const clampedLevel = Math.max(0, Math.min(100, level));
   const pointer = new StabilizedPointer();
@@ -1078,20 +1220,442 @@ function bilateralKernel(params) {
     }
   };
 }
+function toSVGPath(points, options = {}) {
+  const { precision = 2, relative = false, closePath = false } = options;
+  if (points.length === 0) {
+    return "";
+  }
+  const format = (n) => n.toFixed(precision);
+  const parts = [];
+  const first = points[0];
+  parts.push(`${relative ? "m" : "M"} ${format(first.x)} ${format(first.y)}`);
+  if (relative) {
+    let prevX = first.x;
+    let prevY = first.y;
+    for (let i = 1; i < points.length; i++) {
+      const p = points[i];
+      const dx = p.x - prevX;
+      const dy = p.y - prevY;
+      parts.push(`l ${format(dx)} ${format(dy)}`);
+      prevX = p.x;
+      prevY = p.y;
+    }
+  } else {
+    for (let i = 1; i < points.length; i++) {
+      const p = points[i];
+      parts.push(`L ${format(p.x)} ${format(p.y)}`);
+    }
+  }
+  if (closePath) {
+    parts.push(relative ? "z" : "Z");
+  }
+  return parts.join(" ");
+}
+function toSVGPathSmooth(points, options = {}) {
+  const {
+    precision = 2,
+    relative = false,
+    closePath = false,
+    tension = 0.5
+  } = options;
+  if (points.length === 0) {
+    return "";
+  }
+  if (points.length === 1) {
+    const p = points[0];
+    return `${relative ? "m" : "M"} ${p.x.toFixed(precision)} ${p.y.toFixed(precision)}`;
+  }
+  if (points.length === 2) {
+    return toSVGPath(points, options);
+  }
+  const format = (n) => n.toFixed(precision);
+  const parts = [];
+  const first = points[0];
+  parts.push(`${relative ? "m" : "M"} ${format(first.x)} ${format(first.y)}`);
+  for (let i = 1; i < points.length - 1; i++) {
+    const prev = points[i - 1];
+    const curr = points[i];
+    const next = points[i + 1];
+    const midX = (curr.x + next.x) / 2;
+    const midY = (curr.y + next.y) / 2;
+    const cpX = curr.x + (midX - curr.x) * (1 - tension);
+    const cpY = curr.y + (midY - curr.y) * (1 - tension);
+    if (relative) {
+      const dx = cpX - prev.x;
+      const dy = cpY - prev.y;
+      const endDx = midX - prev.x;
+      const endDy = midY - prev.y;
+      parts.push(
+        `q ${format(dx)} ${format(dy)} ${format(endDx)} ${format(endDy)}`
+      );
+    } else {
+      parts.push(
+        `Q ${format(cpX)} ${format(cpY)} ${format(midX)} ${format(midY)}`
+      );
+    }
+  }
+  const last = points[points.length - 1];
+  const secondLast = points[points.length - 2];
+  if (relative) {
+    const midX = (secondLast.x + last.x) / 2;
+    const midY = (secondLast.y + last.y) / 2;
+    parts.push(`l ${format(last.x - midX)} ${format(last.y - midY)}`);
+  } else {
+    parts.push(`L ${format(last.x)} ${format(last.y)}`);
+  }
+  if (closePath) {
+    parts.push(relative ? "z" : "Z");
+  }
+  return parts.join(" ");
+}
+function toSVGPathCubic(points, options = {}) {
+  const {
+    precision = 2,
+    relative = false,
+    closePath = false,
+    smoothing = 0.25
+  } = options;
+  if (points.length === 0) {
+    return "";
+  }
+  if (points.length === 1) {
+    const p = points[0];
+    return `${relative ? "m" : "M"} ${p.x.toFixed(precision)} ${p.y.toFixed(precision)}`;
+  }
+  if (points.length === 2) {
+    return toSVGPath(points, options);
+  }
+  const format = (n) => n.toFixed(precision);
+  const parts = [];
+  const first = points[0];
+  parts.push(`${relative ? "m" : "M"} ${format(first.x)} ${format(first.y)}`);
+  for (let i = 0; i < points.length - 1; i++) {
+    const p0 = points[Math.max(0, i - 1)];
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const p3 = points[Math.min(points.length - 1, i + 2)];
+    const cp1x = p1.x + (p2.x - p0.x) * smoothing;
+    const cp1y = p1.y + (p2.y - p0.y) * smoothing;
+    const cp2x = p2.x - (p3.x - p1.x) * smoothing;
+    const cp2y = p2.y - (p3.y - p1.y) * smoothing;
+    if (relative) {
+      const dx1 = cp1x - p1.x;
+      const dy1 = cp1y - p1.y;
+      const dx2 = cp2x - p1.x;
+      const dy2 = cp2y - p1.y;
+      const dx = p2.x - p1.x;
+      const dy = p2.y - p1.y;
+      parts.push(
+        `c ${format(dx1)} ${format(dy1)} ${format(dx2)} ${format(dy2)} ${format(dx)} ${format(dy)}`
+      );
+    } else {
+      parts.push(
+        `C ${format(cp1x)} ${format(cp1y)} ${format(cp2x)} ${format(cp2y)} ${format(p2.x)} ${format(p2.y)}`
+      );
+    }
+  }
+  if (closePath) {
+    parts.push(relative ? "z" : "Z");
+  }
+  return parts.join(" ");
+}
+class StrokePredictor {
+  constructor(config = {}) {
+    this.history = [];
+    this.config = {
+      historySize: config.historySize ?? 4,
+      maxPredictionMs: config.maxPredictionMs ?? 50,
+      minVelocity: config.minVelocity ?? 0.1
+    };
+  }
+  /**
+   * Add a point to the predictor's history
+   */
+  addPoint(point) {
+    let vx = 0;
+    let vy = 0;
+    if (this.history.length > 0) {
+      const last = this.history[this.history.length - 1];
+      const dt = point.timestamp - last.point.timestamp;
+      if (dt > 0) {
+        vx = (point.x - last.point.x) / dt;
+        vy = (point.y - last.point.y) / dt;
+      }
+    }
+    this.history.push({ point, vx, vy });
+    while (this.history.length > this.config.historySize) {
+      this.history.shift();
+    }
+  }
+  /**
+   * Predict the position at a given time ahead
+   *
+   * @param lookAheadMs Time in milliseconds to predict ahead
+   * @returns Predicted point, or null if prediction is not possible
+   */
+  predict(lookAheadMs) {
+    if (this.history.length < 2) {
+      return null;
+    }
+    const actualLookAhead = Math.min(lookAheadMs, this.config.maxPredictionMs);
+    const { avgVx, avgVy } = this.calculateAverageVelocity();
+    const speed = Math.sqrt(avgVx * avgVx + avgVy * avgVy);
+    if (speed < this.config.minVelocity) {
+      return null;
+    }
+    const lastPoint = this.history[this.history.length - 1].point;
+    const predictedX = lastPoint.x + avgVx * actualLookAhead;
+    const predictedY = lastPoint.y + avgVy * actualLookAhead;
+    return {
+      x: predictedX,
+      y: predictedY,
+      pressure: lastPoint.pressure,
+      tiltX: lastPoint.tiltX,
+      tiltY: lastPoint.tiltY,
+      timestamp: lastPoint.timestamp + actualLookAhead
+    };
+  }
+  /**
+   * Get predicted points for rendering a preview stroke
+   *
+   * @param count Number of predicted points to generate
+   * @param intervalMs Time interval between predicted points
+   * @returns Array of predicted points
+   */
+  predictMultiple(count, intervalMs = 8) {
+    const points = [];
+    for (let i = 1; i <= count; i++) {
+      const predicted = this.predict(i * intervalMs);
+      if (predicted) {
+        points.push(predicted);
+      }
+    }
+    return points;
+  }
+  /**
+   * Calculate weighted average velocity from history
+   * Recent points are weighted more heavily
+   */
+  calculateAverageVelocity() {
+    if (this.history.length < 2) {
+      return { avgVx: 0, avgVy: 0 };
+    }
+    let totalWeight = 0;
+    let weightedVx = 0;
+    let weightedVy = 0;
+    for (let i = 1; i < this.history.length; i++) {
+      const weight = Math.pow(2, i);
+      weightedVx += this.history[i].vx * weight;
+      weightedVy += this.history[i].vy * weight;
+      totalWeight += weight;
+    }
+    return {
+      avgVx: totalWeight > 0 ? weightedVx / totalWeight : 0,
+      avgVy: totalWeight > 0 ? weightedVy / totalWeight : 0
+    };
+  }
+  /**
+   * Get the current average velocity
+   */
+  getVelocity() {
+    const { avgVx, avgVy } = this.calculateAverageVelocity();
+    return { vx: avgVx, vy: avgVy };
+  }
+  /**
+   * Get the current speed (magnitude of velocity)
+   */
+  getSpeed() {
+    const { avgVx, avgVy } = this.calculateAverageVelocity();
+    return Math.sqrt(avgVx * avgVx + avgVy * avgVy);
+  }
+  /**
+   * Clear prediction history
+   */
+  reset() {
+    this.history = [];
+  }
+  /**
+   * Get number of points in history
+   */
+  get historyLength() {
+    return this.history.length;
+  }
+}
+function createPredictor(config) {
+  return new StrokePredictor(config);
+}
+function interpolateCatmullRom(points, options = {}) {
+  const {
+    tension = 0.5,
+    segmentDivisions = 10,
+    interpolateAttributes = true
+  } = options;
+  if (points.length < 2) {
+    return [...points];
+  }
+  if (points.length === 2) {
+    return interpolateLinear(points[0], points[1], segmentDivisions);
+  }
+  const result = [];
+  for (let i = 0; i < points.length - 1; i++) {
+    const p0 = points[Math.max(0, i - 1)];
+    const p1 = points[i];
+    const p2 = points[i + 1];
+    const p3 = points[Math.min(points.length - 1, i + 2)];
+    if (i === 0) {
+      result.push(p1);
+    }
+    for (let j = 1; j <= segmentDivisions; j++) {
+      const t = j / segmentDivisions;
+      const point = catmullRomPoint(p0, p1, p2, p3, t, tension);
+      if (interpolateAttributes) {
+        point.pressure = lerpOptional(p1.pressure, p2.pressure, t);
+        point.tiltX = lerpOptional(p1.tiltX, p2.tiltX, t);
+        point.tiltY = lerpOptional(p1.tiltY, p2.tiltY, t);
+      }
+      point.timestamp = lerp(p1.timestamp, p2.timestamp, t);
+      result.push(point);
+    }
+  }
+  return result;
+}
+function catmullRomPoint(p0, p1, p2, p3, t, tension) {
+  const alpha = tension;
+  const t0 = 0;
+  const t1 = getKnotValue(t0, p0, p1, alpha);
+  const t2 = getKnotValue(t1, p1, p2, alpha);
+  const t3 = getKnotValue(t2, p2, p3, alpha);
+  const tActual = lerp(t1, t2, t);
+  const A1x = remapPoint(t0, t1, p0.x, p1.x, tActual);
+  const A1y = remapPoint(t0, t1, p0.y, p1.y, tActual);
+  const A2x = remapPoint(t1, t2, p1.x, p2.x, tActual);
+  const A2y = remapPoint(t1, t2, p1.y, p2.y, tActual);
+  const A3x = remapPoint(t2, t3, p2.x, p3.x, tActual);
+  const A3y = remapPoint(t2, t3, p2.y, p3.y, tActual);
+  const B1x = remapPoint(t0, t2, A1x, A2x, tActual);
+  const B1y = remapPoint(t0, t2, A1y, A2y, tActual);
+  const B2x = remapPoint(t1, t3, A2x, A3x, tActual);
+  const B2y = remapPoint(t1, t3, A2y, A3y, tActual);
+  const Cx = remapPoint(t1, t2, B1x, B2x, tActual);
+  const Cy = remapPoint(t1, t2, B1y, B2y, tActual);
+  return {
+    x: Cx,
+    y: Cy,
+    timestamp: 0
+    // Will be set by caller
+  };
+}
+function getKnotValue(ti, p0, p1, alpha) {
+  const dx = p1.x - p0.x;
+  const dy = p1.y - p0.y;
+  const dist = Math.sqrt(dx * dx + dy * dy);
+  return ti + Math.pow(dist, alpha);
+}
+function remapPoint(t0, t1, p0, p1, t) {
+  const denominator = t1 - t0;
+  if (Math.abs(denominator) < 1e-10) {
+    return p0;
+  }
+  return (t1 - t) / denominator * p0 + (t - t0) / denominator * p1;
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpOptional(a, b, t) {
+  if (a === void 0 || b === void 0) {
+    return void 0;
+  }
+  return lerp(a, b, t);
+}
+function interpolateLinear(p1, p2, divisions) {
+  const result = [p1];
+  for (let i = 1; i <= divisions; i++) {
+    const t = i / divisions;
+    result.push({
+      x: lerp(p1.x, p2.x, t),
+      y: lerp(p1.y, p2.y, t),
+      pressure: lerpOptional(p1.pressure, p2.pressure, t),
+      tiltX: lerpOptional(p1.tiltX, p2.tiltX, t),
+      tiltY: lerpOptional(p1.tiltY, p2.tiltY, t),
+      timestamp: lerp(p1.timestamp, p2.timestamp, t)
+    });
+  }
+  return result;
+}
+function calculateArcLength(points) {
+  if (points.length < 2) {
+    return 0;
+  }
+  let length = 0;
+  for (let i = 1; i < points.length; i++) {
+    const dx = points[i].x - points[i - 1].x;
+    const dy = points[i].y - points[i - 1].y;
+    length += Math.sqrt(dx * dx + dy * dy);
+  }
+  return length;
+}
+function resampleByArcLength(points, spacing) {
+  if (points.length < 2) {
+    return [...points];
+  }
+  const result = [points[0]];
+  let accumulated = 0;
+  for (let i = 1; i < points.length; i++) {
+    const prev = points[i - 1];
+    const curr = points[i];
+    const dx = curr.x - prev.x;
+    const dy = curr.y - prev.y;
+    const segmentLength = Math.sqrt(dx * dx + dy * dy);
+    accumulated += segmentLength;
+    while (accumulated >= spacing) {
+      const overshoot = accumulated - spacing;
+      const ratio = (segmentLength - overshoot) / segmentLength;
+      const t = 1 - overshoot / segmentLength;
+      result.push({
+        x: prev.x + dx * ratio,
+        y: prev.y + dy * ratio,
+        pressure: lerpOptional(prev.pressure, curr.pressure, t),
+        tiltX: lerpOptional(prev.tiltX, curr.tiltX, t),
+        tiltY: lerpOptional(prev.tiltY, curr.tiltY, t),
+        timestamp: lerp(prev.timestamp, curr.timestamp, t)
+      });
+      accumulated -= spacing;
+    }
+  }
+  const last = points[points.length - 1];
+  const lastResult = result[result.length - 1];
+  const finalDx = last.x - lastResult.x;
+  const finalDy = last.y - lastResult.y;
+  const finalDist = Math.sqrt(finalDx * finalDx + finalDy * finalDy);
+  if (finalDist > spacing * 0.5) {
+    result.push(last);
+  }
+  return result;
+}
 exports.StabilizedPointer = StabilizedPointer;
+exports.StrokePredictor = StrokePredictor;
 exports.bilateralKernel = bilateralKernel;
 exports.boxKernel = boxKernel;
+exports.calculateArcLength = calculateArcLength;
 exports.createFromPreset = createFromPreset;
+exports.createPredictor = createPredictor;
 exports.createStabilizedPointer = createStabilizedPointer;
+exports.douglasPeuckerFilter = douglasPeuckerFilter;
 exports.emaFilter = emaFilter;
 exports.gaussianKernel = gaussianKernel;
+exports.interpolateCatmullRom = interpolateCatmullRom;
 exports.isAdaptiveKernel = isAdaptiveKernel;
 exports.kalmanFilter = kalmanFilter;
 exports.linearPredictionFilter = linearPredictionFilter;
 exports.movingAverageFilter = movingAverageFilter;
 exports.noiseFilter = noiseFilter;
 exports.oneEuroFilter = oneEuroFilter;
+exports.resampleByArcLength = resampleByArcLength;
+exports.simplify = simplify;
 exports.smooth = smooth;
 exports.stringFilter = stringFilter;
+exports.toSVGPath = toSVGPath;
+exports.toSVGPathCubic = toSVGPathCubic;
+exports.toSVGPathSmooth = toSVGPathSmooth;
 exports.triangleKernel = triangleKernel;
 //# sourceMappingURL=index.cjs.map