modern-path2d 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -1,3 +1,970 @@
-const one = 1;
+class Point2D {
+  constructor(x = 0, y = 0) {
+    this.x = x;
+    this.y = y;
+  }
+  set(x, y) {
+    this.x = x;
+    this.y = y;
+    return this;
+  }
+  add(point) {
+    this.x += point.x;
+    this.y += point.y;
+    return this;
+  }
+  sub(point) {
+    this.x -= point.x;
+    this.y -= point.y;
+    return this;
+  }
+  distanceTo(point) {
+    return Math.sqrt(this.distanceToSquared(point));
+  }
+  distanceToSquared(point) {
+    const dx = this.x - point.x;
+    const dy = this.y - point.y;
+    return dx * dx + dy * dy;
+  }
+  length() {
+    return Math.sqrt(this.x * this.x + this.y * this.y);
+  }
+  multiplyScalar(scalar) {
+    this.x *= scalar;
+    this.y *= scalar;
+    return this;
+  }
+  divideScalar(scalar) {
+    return this.multiplyScalar(1 / scalar);
+  }
+  subVectors(a, b) {
+    this.x = a.x - b.x;
+    this.y = a.y - b.y;
+    return this;
+  }
+  normalize() {
+    return this.divideScalar(this.length() || 1);
+  }
+  lerpVectors(v1, v2, alpha) {
+    this.x = v1.x + (v2.x - v1.x) * alpha;
+    this.y = v1.y + (v2.y - v1.y) * alpha;
+    return this;
+  }
+  equals(point) {
+    return this.x === point.x && this.y === point.y;
+  }
+  copy(point) {
+    this.x = point.x;
+    this.y = point.y;
+    return this;
+  }
+  clone() {
+    return new Point2D(this.x, this.y);
+  }
+}
 
-export { one };
+var __defProp$5 = Object.defineProperty;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$5 = (obj, key, value) => {
+  __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Curve {
+  constructor() {
+    __publicField$5(this, "arcLengthDivisions", 200);
+    __publicField$5(this, "_cacheArcLengths");
+    __publicField$5(this, "_needsUpdate", false);
+  }
+  getDivisions(divisions) {
+    return divisions;
+  }
+  getPointAt(u, output = new Point2D()) {
+    return this.getPoint(this.getUtoTmapping(u), output);
+  }
+  getPoints(divisions = 5) {
+    const points = [];
+    for (let i = 0; i <= divisions; i++) {
+      points.push(this.getPoint(i / divisions));
+    }
+    return points;
+  }
+  getSpacedPoints(divisions = 5) {
+    const points = [];
+    for (let i = 0; i <= divisions; i++) {
+      points.push(this.getPointAt(i / divisions));
+    }
+    return points;
+  }
+  getLength() {
+    const lengths = this.getLengths();
+    return lengths[lengths.length - 1];
+  }
+  getLengths(divisions = this.arcLengthDivisions) {
+    if (this._cacheArcLengths && this._cacheArcLengths.length === divisions + 1 && !this._needsUpdate) {
+      return this._cacheArcLengths;
+    }
+    this._needsUpdate = false;
+    const cache = [];
+    let current;
+    let last = this.getPoint(0);
+    let sum = 0;
+    cache.push(0);
+    for (let i = 1; i <= divisions; i++) {
+      current = this.getPoint(i / divisions);
+      sum += current.distanceTo(last);
+      cache.push(sum);
+      last = current;
+    }
+    this._cacheArcLengths = cache;
+    return cache;
+  }
+  updateArcLengths() {
+    this._needsUpdate = true;
+    this.getLengths();
+  }
+  getUtoTmapping(u, distance) {
+    const arcLengths = this.getLengths();
+    let i = 0;
+    const il = arcLengths.length;
+    let targetArcLength;
+    if (distance) {
+      targetArcLength = distance;
+    } else {
+      targetArcLength = u * arcLengths[il - 1];
+    }
+    let low = 0;
+    let high = il - 1;
+    let comparison;
+    while (low <= high) {
+      i = Math.floor(low + (high - low) / 2);
+      comparison = arcLengths[i] - targetArcLength;
+      if (comparison < 0) {
+        low = i + 1;
+      } else if (comparison > 0) {
+        high = i - 1;
+      } else {
+        high = i;
+        break;
+      }
+    }
+    i = high;
+    if (arcLengths[i] === targetArcLength) {
+      return i / (il - 1);
+    }
+    const lengthBefore = arcLengths[i];
+    const lengthAfter = arcLengths[i + 1];
+    const segmentLength = lengthAfter - lengthBefore;
+    const segmentFraction = (targetArcLength - lengthBefore) / segmentLength;
+    return (i + segmentFraction) / (il - 1);
+  }
+  getTangent(t, output = new Point2D()) {
+    const delta = 1e-4;
+    let t1 = t - delta;
+    let t2 = t + delta;
+    if (t1 < 0)
+      t1 = 0;
+    if (t2 > 1)
+      t2 = 1;
+    return output.copy(this.getPoint(t2)).sub(this.getPoint(t1)).normalize();
+  }
+  getTangentAt(u, output = new Point2D()) {
+    return this.getTangent(this.getUtoTmapping(u), output);
+  }
+  clone() {
+    return new this.constructor().copy(this);
+  }
+  copy(source) {
+    this.arcLengthDivisions = source.arcLengthDivisions;
+    return this;
+  }
+}
+
+class CircleCurve extends Curve {
+  constructor(center, radius, start = 0, end = Math.PI * 2) {
+    super();
+    this.center = center;
+    this.radius = radius;
+    this.start = start;
+    this.end = end;
+  }
+  getPole(min, max) {
+    min.x = Math.min(min.x, this.center.x - this.radius);
+    min.y = Math.min(min.y, this.center.y - this.radius);
+    max.x = Math.max(max.x, this.center.x + this.radius);
+    max.y = Math.max(max.y, this.center.y + this.radius);
+  }
+  getPoint(index) {
+    const { radius, center } = this;
+    return center.clone().add(this.getNormal(index).clone().multiplyScalar(radius));
+  }
+  getTangent(index) {
+    const { x, y } = this.getNormal(index);
+    return new Point2D(-y, x);
+  }
+  getNormal(index) {
+    const { start, end } = this;
+    const t = index * (end - start) + start - 0.5 * Math.PI;
+    return new Point2D(Math.cos(t), Math.sin(t));
+  }
+  toPathCommands() {
+    return [];
+  }
+  drawTo(_ctx) {
+  }
+}
+
+function catmullRom(t, p0, p1, p2, p3) {
+  const v0 = (p2 - p0) * 0.5;
+  const v1 = (p3 - p1) * 0.5;
+  const t2 = t * t;
+  const t3 = t * t2;
+  return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+}
+function quadraticBezierP0(t, p) {
+  const k = 1 - t;
+  return k * k * p;
+}
+function quadraticBezierP1(t, p) {
+  return 2 * (1 - t) * t * p;
+}
+function quadraticBezierP2(t, p) {
+  return t * t * p;
+}
+function quadraticBezier(t, p0, p1, p2) {
+  return quadraticBezierP0(t, p0) + quadraticBezierP1(t, p1) + quadraticBezierP2(t, p2);
+}
+function cubicBezierP0(t, p) {
+  const k = 1 - t;
+  return k * k * k * p;
+}
+function cubicBezierP1(t, p) {
+  const k = 1 - t;
+  return 3 * k * k * t * p;
+}
+function cubicBezierP2(t, p) {
+  return 3 * (1 - t) * t * t * p;
+}
+function cubicBezierP3(t, p) {
+  return t * t * t * p;
+}
+function cubicBezier(t, p0, p1, p2, p3) {
+  return cubicBezierP0(t, p0) + cubicBezierP1(t, p1) + cubicBezierP2(t, p2) + cubicBezierP3(t, p3);
+}
+
+class CubicBezierCurve extends Curve {
+  constructor(v0 = new Point2D(), v1 = new Point2D(), v2 = new Point2D(), v3 = new Point2D()) {
+    super();
+    this.v0 = v0;
+    this.v1 = v1;
+    this.v2 = v2;
+    this.v3 = v3;
+  }
+  getPoint(t, output = new Point2D()) {
+    const { v0, v1, v2, v3 } = this;
+    output.set(
+      cubicBezier(t, v0.x, v1.x, v2.x, v3.x),
+      cubicBezier(t, v0.y, v1.y, v2.y, v3.y)
+    );
+    return output;
+  }
+  toPathCommands() {
+    return [];
+  }
+  drawTo(ctx) {
+    const { v0, v1, v2, v3 } = this;
+    ctx.moveTo(v0.x, v0.y);
+    ctx.bezierCurveTo(v1.x, v1.y, v2.x, v2.y, v3.x, v3.y);
+  }
+  copy(source) {
+    super.copy(source);
+    this.v0.copy(source.v0);
+    this.v1.copy(source.v1);
+    this.v2.copy(source.v2);
+    this.v3.copy(source.v3);
+    return this;
+  }
+}
+
+class EllipseCurve extends Curve {
+  constructor(x = 0, y = 0, rx = 1, ry = 1, startAngle = 0, endAngle = Math.PI * 2, clockwise = false, rotation = 0) {
+    super();
+    this.x = x;
+    this.y = y;
+    this.rx = rx;
+    this.ry = ry;
+    this.startAngle = startAngle;
+    this.endAngle = endAngle;
+    this.clockwise = clockwise;
+    this.rotation = rotation;
+  }
+  getDivisions(divisions = 12) {
+    return divisions * 2;
+  }
+  getPoint(t, output = new Point2D()) {
+    const twoPi = Math.PI * 2;
+    let deltaAngle = this.endAngle - this.startAngle;
+    const samePoints = Math.abs(deltaAngle) < Number.EPSILON;
+    while (deltaAngle < 0)
+      deltaAngle += twoPi;
+    while (deltaAngle > twoPi)
+      deltaAngle -= twoPi;
+    if (deltaAngle < Number.EPSILON) {
+      if (samePoints) {
+        deltaAngle = 0;
+      } else {
+        deltaAngle = twoPi;
+      }
+    }
+    if (this.clockwise && !samePoints) {
+      if (deltaAngle === twoPi) {
+        deltaAngle = -twoPi;
+      } else {
+        deltaAngle = deltaAngle - twoPi;
+      }
+    }
+    const angle = this.startAngle + t * deltaAngle;
+    let _x = this.x + this.rx * Math.cos(angle);
+    let _y = this.y + this.ry * Math.sin(angle);
+    if (this.rotation !== 0) {
+      const cos = Math.cos(this.rotation);
+      const sin = Math.sin(this.rotation);
+      const tx = _x - this.x;
+      const ty = _y - this.y;
+      _x = tx * cos - ty * sin + this.x;
+      _y = tx * sin + ty * cos + this.y;
+    }
+    return output.set(_x, _y);
+  }
+  toPathCommands() {
+    const { x, y, rx, ry, startAngle, endAngle, clockwise } = this;
+    const startX = x + rx * Math.cos(startAngle);
+    const startY = y + ry * Math.sin(startAngle);
+    const endX = x + rx * Math.cos(endAngle);
+    const endY = y + ry * Math.sin(endAngle);
+    const largeArcFlag = (endAngle - startAngle) % (2 * Math.PI) > Math.PI ? 1 : 0;
+    const sweepFlag = clockwise ? 0 : 1;
+    return [
+      { type: "M", x: startX, y: startY },
+      { type: "A", rx, ry, xAxisRotation: 0, largeArcFlag, sweepFlag, x: endX, y: endY }
+    ];
+  }
+  drawTo(ctx) {
+    const { x, y, rx, ry, startAngle } = this;
+    const startX = x + rx * Math.cos(startAngle);
+    const startY = y + ry * Math.sin(startAngle);
+    ctx.moveTo(startX, startY);
+    ctx.arc(
+      this.x,
+      this.y,
+      this.rx,
+      this.startAngle,
+      this.endAngle,
+      !this.clockwise
+    );
+  }
+  copy(source) {
+    super.copy(source);
+    this.x = source.x;
+    this.y = source.y;
+    this.rx = source.rx;
+    this.ry = source.ry;
+    this.startAngle = source.startAngle;
+    this.endAngle = source.endAngle;
+    this.clockwise = source.clockwise;
+    this.rotation = source.rotation;
+    return this;
+  }
+}
+
+class LineCurve extends Curve {
+  constructor(v1 = new Point2D(), v2 = new Point2D()) {
+    super();
+    this.v1 = v1;
+    this.v2 = v2;
+  }
+  getDivisions() {
+    return 1;
+  }
+  getPoint(t, output = new Point2D()) {
+    if (t === 1) {
+      output.copy(this.v2);
+    } else {
+      output.copy(this.v2).sub(this.v1);
+      output.multiplyScalar(t).add(this.v1);
+    }
+    return output;
+  }
+  getPointAt(u, output = new Point2D()) {
+    return this.getPoint(u, output);
+  }
+  getTangent(t, output = new Point2D()) {
+    return output.subVectors(this.v2, this.v1).normalize();
+  }
+  getTangentAt(u, output = new Point2D()) {
+    return this.getTangent(u, output);
+  }
+  toPathCommands() {
+    return [
+      { type: "M", x: this.v1.x, y: this.v1.y },
+      { type: "L", x: this.v2.x, y: this.v2.y }
+    ];
+  }
+  drawTo(ctx) {
+    const { v1, v2 } = this;
+    ctx.moveTo(v1.x, v1.y);
+    ctx.lineTo(v2.x, v2.y);
+  }
+  copy(source) {
+    super.copy(source);
+    this.v1.copy(source.v1);
+    this.v2.copy(source.v2);
+    return this;
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => {
+  __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class HeartCurve extends Curve {
+  constructor(center, size, start = 0, end = 1) {
+    super();
+    this.center = center;
+    this.size = size;
+    this.start = start;
+    this.end = end;
+    __publicField$4(this, "curves");
+    __publicField$4(this, "pointT", 0);
+    const { x, y } = this.center;
+    const A = new Point2D(x + 0.5 * this.size, y - 0.5 * this.size);
+    const t = new Point2D(x - 0.5 * this.size, y - 0.5 * this.size);
+    const i = new Point2D(x, y + 0.5 * this.size);
+    const curve1 = new CircleCurve(A, Math.SQRT1_2 * this.size, -0.25 * Math.PI, 0.75 * Math.PI);
+    const curve5 = new CircleCurve(t, Math.SQRT1_2 * this.size, -0.75 * Math.PI, 0.25 * Math.PI);
+    const curve3 = new CircleCurve(i, 0.5 * Math.SQRT1_2 * this.size, 0.75 * Math.PI, 1.25 * Math.PI);
+    const e = new Point2D(x, y + this.size);
+    const l = new Point2D(x + this.size, y);
+    const c = new Point2D().lerpVectors(l, e, 0.75);
+    const h = new Point2D(x - this.size, y);
+    const a = new Point2D().lerpVectors(h, e, 0.75);
+    const curve2 = new LineCurve(l, c);
+    const curve4 = new LineCurve(a, h);
+    this.curves = [curve1, curve2, curve3, curve4, curve5];
+  }
+  getPoint(value) {
+    return this.getCurrentLine(value).getPoint(this.pointT);
+  }
+  getPointAt(value) {
+    return this.getPoint(value);
+  }
+  getCurrentLine(value) {
+    let val = (value * (this.end - this.start) + this.start) % 1;
+    val < 0 && (val += 1);
+    val *= 9 * Math.PI / 8 + 1.5;
+    let index;
+    const t = 0.5 * Math.PI;
+    if (val < t) {
+      index = 0;
+      this.pointT = val / t;
+    } else if (val < t + 0.75) {
+      index = 1;
+      this.pointT = (val - t) / 0.75;
+    } else if (val < 5 * Math.PI / 8 + 0.75) {
+      index = 2;
+      this.pointT = (val - t - 0.75) / (Math.PI / 8);
+    } else if (val < 5 * Math.PI / 8 + 1.5) {
+      index = 3;
+      this.pointT = (val - 5 * Math.PI / 8 - 0.75) / 0.75;
+    } else {
+      index = 4;
+      this.pointT = (val - 5 * Math.PI / 8 - 1.5) / t;
+    }
+    return this.curves[index];
+  }
+  getTangent(value) {
+    return this.getCurrentLine(value).getTangent(this.pointT).normalize();
+  }
+  getNormal(value) {
+    const line = this.getCurrentLine(value);
+    return new Point2D(line.v2.y - line.v1.y, -(line.v2.x - line.v1.x)).normalize();
+  }
+  toPathCommands() {
+    return this.curves.flatMap((curve) => curve.toPathCommands());
+  }
+  drawTo(ctx) {
+    this.curves.forEach((curve) => curve.drawTo(ctx));
+  }
+}
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => {
+  __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class PloygonCurve extends Curve {
+  constructor(center, radius = 0, num = 0, start = 0, end = 1) {
+    super();
+    this.center = center;
+    this.radius = radius;
+    this.num = num;
+    this.start = start;
+    this.end = end;
+    __publicField$3(this, "curves", []);
+    __publicField$3(this, "points", []);
+    for (let i = 0; i < this.num; i++) {
+      let radian = i * 2 * Math.PI / this.num;
+      radian -= 0.5 * Math.PI;
+      const point = new Point2D(this.radius * Math.cos(radian), this.radius * Math.sin(radian));
+      point.add(this.center);
+      this.points.push(point);
+    }
+    for (let i = 0; i < this.num; i++) {
+      this.curves.push(new LineCurve(this.points[i], this.points[(i + 1) % this.num]));
+    }
+  }
+  getPoint(value) {
+    this.getCurrentLine(value);
+    return this.currentLine.getPoint(this.pointK);
+  }
+  getPointAt(value) {
+    return this.getPoint(value);
+  }
+  getCurrentLine(value) {
+    let pos = (value * (this.end - this.start) + this.start) % 1;
+    pos < 0 && (pos += 1);
+    const v = pos * this.num;
+    const index = Math.floor(v);
+    this.pointK = v - index;
+    this.currentLine = this.curves[index];
+    return this.currentLine;
+  }
+  getTangent(value) {
+    return this.getCurrentLine(value).getTangent(0).normalize();
+  }
+  getNormal(value) {
+    const line = this.getCurrentLine(value);
+    return new Point2D(line.v2.y - line.v1.y, -(line.v2.x - line.v1.x)).normalize();
+  }
+  toPathCommands() {
+    return this.curves.flatMap((curve) => curve.toPathCommands());
+  }
+  drawTo(ctx) {
+    this.curves.forEach((curve) => curve.drawTo(ctx));
+  }
+}
+
+class QuadraticBezierCurve extends Curve {
+  constructor(v0 = new Point2D(), v1 = new Point2D(), v2 = new Point2D()) {
+    super();
+    this.v0 = v0;
+    this.v1 = v1;
+    this.v2 = v2;
+  }
+  getPoint(t, output = new Point2D()) {
+    const { v0, v1, v2 } = this;
+    output.set(
+      quadraticBezier(t, v0.x, v1.x, v2.x),
+      quadraticBezier(t, v0.y, v1.y, v2.y)
+    );
+    return output;
+  }
+  toPathCommands() {
+    return [];
+  }
+  drawTo(ctx) {
+    const { v0, v1, v2 } = this;
+    ctx.moveTo(v0.x, v0.y);
+    ctx.quadraticCurveTo(v1.x, v1.y, v2.x, v2.y);
+  }
+  copy(source) {
+    super.copy(source);
+    this.v0.copy(source.v0);
+    this.v1.copy(source.v1);
+    this.v2.copy(source.v2);
+    return this;
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class RectangularCurve extends Curve {
+  constructor(center, rx, aspectRatio = 1, start = 0, end = 1) {
+    super();
+    this.center = center;
+    this.rx = rx;
+    this.aspectRatio = aspectRatio;
+    this.start = start;
+    this.end = end;
+    __publicField$2(this, "curves", []);
+    __publicField$2(this, "pointT", 0);
+    const { x, y } = this.center;
+    const offsetX = this.rx;
+    const offsetY = this.rx / this.aspectRatio;
+    const points = [
+      new Point2D(x - offsetX, y - offsetY),
+      new Point2D(x + offsetX, y - offsetY),
+      new Point2D(x + offsetX, y + offsetY),
+      new Point2D(x - offsetX, y + offsetY)
+    ];
+    for (let i = 0; i < 4; i++) {
+      this.curves.push(new LineCurve(points[i], points[(i + 1) % 4]));
+    }
+  }
+  get x() {
+    return this.center.x - this.rx;
+  }
+  get y() {
+    return this.center.y - this.rx / this.aspectRatio;
+  }
+  get width() {
+    return this.rx * 2;
+  }
+  get height() {
+    return this.rx / this.aspectRatio * 2;
+  }
+  getPoint(t) {
+    return this.getCurrentLine(t).getPoint(this.pointT);
+  }
+  getPointAt(u) {
+    return this.getPoint(u);
+  }
+  getCurrentLine(t) {
+    let flag = (t * (this.end - this.start) + this.start) % 1;
+    flag < 0 && (flag += 1);
+    flag *= (1 + this.aspectRatio) * 2;
+    let i;
+    if (flag < this.aspectRatio) {
+      i = 0;
+      this.pointT = flag / this.aspectRatio;
+    } else if (flag < this.aspectRatio + 1) {
+      i = 1;
+      this.pointT = (flag - this.aspectRatio) / 1;
+    } else if (flag < 2 * this.aspectRatio + 1) {
+      i = 2;
+      this.pointT = (flag - this.aspectRatio - 1) / this.aspectRatio;
+    } else {
+      i = 3;
+      this.pointT = (flag - 2 * this.aspectRatio - 1) / 1;
+    }
+    return this.curves[i];
+  }
+  getTangent(t) {
+    return this.getCurrentLine(t).getTangent(0).normalize();
+  }
+  getNormal(value) {
+    const { v1, v2 } = this.getCurrentLine(value);
+    return new Point2D(v2.y - v1.y, -(v2.x - v1.x)).normalize();
+  }
+  toPathCommands() {
+    return this.curves.flatMap((curve) => curve.toPathCommands());
+  }
+  drawTo(ctx) {
+    this.curves.forEach((curve) => curve.drawTo(ctx));
+  }
+}
+
+class SplineCurve extends Curve {
+  constructor(points = []) {
+    super();
+    this.points = points;
+  }
+  getDivisions(divisions = 12) {
+    return divisions * this.points.length;
+  }
+  getPoint(t, output = new Point2D()) {
+    const { points } = this;
+    const p = (points.length - 1) * t;
+    const _p = Math.floor(p);
+    const weight = p - _p;
+    const p0 = points[_p === 0 ? _p : _p - 1];
+    const p1 = points[_p];
+    const p2 = points[_p > points.length - 2 ? points.length - 1 : _p + 1];
+    const p3 = points[_p > points.length - 3 ? points.length - 1 : _p + 2];
+    output.set(
+      catmullRom(weight, p0.x, p1.x, p2.x, p3.x),
+      catmullRom(weight, p0.y, p1.y, p2.y, p3.y)
+    );
+    return output;
+  }
+  toPathCommands() {
+    return [];
+  }
+  drawTo(_ctx) {
+  }
+  copy(source) {
+    super.copy(source);
+    this.points = [];
+    for (let i = 0, l = source.points.length; i < l; i++) {
+      const point = source.points[i];
+      this.points.push(point.clone());
+    }
+    return this;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class CurvePath extends Curve {
+  constructor(points) {
+    super();
+    __publicField$1(this, "curves", []);
+    __publicField$1(this, "currentPoint", new Point2D());
+    __publicField$1(this, "autoClose", false);
+    __publicField$1(this, "_cacheLengths", []);
+    if (points) {
+      this.setFromPoints(points);
+    }
+  }
+  addCurve(curve) {
+    this.curves.push(curve);
+    return this;
+  }
+  closePath() {
+    const start = this.curves[0].getPoint(0);
+    const end = this.curves[this.curves.length - 1].getPoint(1);
+    if (!start.equals(end)) {
+      this.curves.push(new LineCurve(end, start));
+    }
+    return this;
+  }
+  getPoint(position, output = new Point2D()) {
+    const d = position * this.getLength();
+    const curveLengths = this.getCurveLengths();
+    let i = 0;
+    while (i < curveLengths.length) {
+      if (curveLengths[i] >= d) {
+        const diff = curveLengths[i] - d;
+        const curve = this.curves[i];
+        const segmentLength = curve.getLength();
+        return curve.getPointAt(segmentLength === 0 ? 0 : 1 - diff / segmentLength, output);
+      }
+      i++;
+    }
+    return output;
+  }
+  getLength() {
+    const lengths = this.getCurveLengths();
+    return lengths[lengths.length - 1];
+  }
+  updateArcLengths() {
+    super.updateArcLengths();
+    this._cacheLengths = [];
+    this.getCurveLengths();
+  }
+  getCurveLengths() {
+    if (this._cacheLengths.length === this.curves.length) {
+      return this._cacheLengths;
+    }
+    const lengths = [];
+    let sums = 0;
+    for (let i = 0, l = this.curves.length; i < l; i++) {
+      sums += this.curves[i].getLength();
+      lengths.push(sums);
+    }
+    this._cacheLengths = lengths;
+    return lengths;
+  }
+  getSpacedPoints(divisions = 40) {
+    const points = [];
+    for (let i = 0; i <= divisions; i++) {
+      points.push(this.getPoint(i / divisions));
+    }
+    if (this.autoClose) {
+      points.push(points[0]);
+    }
+    return points;
+  }
+  getPoints(divisions = 12) {
+    const points = [];
+    let last;
+    for (let i = 0, curves = this.curves; i < curves.length; i++) {
+      const curve = curves[i];
+      const pts = curve.getPoints(curve.getDivisions(divisions));
+      for (let i2 = 0; i2 < pts.length; i2++) {
+        const point = pts[i2];
+        if (last && last.equals(point))
+          continue;
+        points.push(point);
+        last = point;
+      }
+    }
+    if (this.autoClose && points.length > 1 && !points[points.length - 1].equals(points[0])) {
+      points.push(points[0]);
+    }
+    return points;
+  }
+  setFromPoints(points) {
+    this.moveTo(points[0].x, points[0].y);
+    for (let i = 1, l = points.length; i < l; i++) {
+      this.lineTo(points[i].x, points[i].y);
+    }
+    return this;
+  }
+  bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
+    this.curves.push(
+      new CubicBezierCurve(
+        this.currentPoint.clone(),
+        new Point2D(cp1x, cp1y),
+        new Point2D(cp2x, cp2y),
+        new Point2D(x, y)
+      )
+    );
+    this.currentPoint.set(x, y);
+    return this;
+  }
+  lineTo(x, y) {
+    const curve = new LineCurve(this.currentPoint.clone(), new Point2D(x, y));
+    this.curves.push(curve);
+    this.currentPoint.set(x, y);
+    return this;
+  }
+  moveTo(x, y) {
+    this.currentPoint.set(x, y);
+    return this;
+  }
+  quadraticCurveTo(cpx, cpy, x, y) {
+    this.curves.push(
+      new QuadraticBezierCurve(
+        this.currentPoint.clone(),
+        new Point2D(cpx, cpy),
+        new Point2D(x, y)
+      )
+    );
+    this.currentPoint.set(x, y);
+    return this;
+  }
+  rect(x, y, w, h) {
+    this.curves.push(
+      new RectangularCurve(
+        new Point2D(x + w / 2, y + h / 2),
+        w / 2,
+        w / h
+      )
+    );
+    this.currentPoint.set(x, y);
+    return this;
+  }
+  splineThru(points) {
+    const npts = [this.currentPoint.clone()].concat(points);
+    this.curves.push(new SplineCurve(npts));
+    this.currentPoint.copy(points[points.length - 1]);
+    return this;
+  }
+  arc(x, y, radius, startAngle, endAngle, clockwise = false) {
+    const point = this.currentPoint;
+    this.absarc(x + point.x, y + point.y, radius, startAngle, endAngle, clockwise);
+    return this;
+  }
+  absarc(x, y, radius, startAngle, endAngle, clockwise = false) {
+    this.absellipse(x, y, radius, radius, startAngle, endAngle, clockwise);
+    return this;
+  }
+  ellipse(x, y, xRadius, yRadius, startAngle, endAngle, clockwise = false, rotation = 0) {
+    const point = this.currentPoint;
+    this.absellipse(x + point.x, y + point.y, xRadius, yRadius, startAngle, endAngle, clockwise, rotation);
+    return this;
+  }
+  absellipse(x, y, xRadius, yRadius, startAngle, endAngle, clockwise = false, rotation = 0) {
+    const curve = new EllipseCurve(x, y, xRadius, yRadius, startAngle, endAngle, clockwise, rotation);
+    if (this.curves.length > 0) {
+      const firstPoint = curve.getPoint(0);
+      if (!firstPoint.equals(this.currentPoint)) {
+        this.lineTo(firstPoint.x, firstPoint.y);
+      }
+    }
+    this.curves.push(curve);
+    this.currentPoint.copy(curve.getPoint(1));
+    return this;
+  }
+  toPathCommands() {
+    return this.curves.flatMap((curve) => curve.toPathCommands());
+  }
+  drawTo(ctx) {
+    this.curves.forEach((curve) => curve.drawTo(ctx));
+  }
+  copy(source) {
+    super.copy(source);
+    this.curves = [];
+    for (let i = 0, l = source.curves.length; i < l; i++) {
+      const curve = source.curves[i];
+      this.curves.push(curve.clone());
+    }
+    this.autoClose = source.autoClose;
+    this.currentPoint.copy(source.currentPoint);
+    return this;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Path2D {
+  constructor() {
+    __publicField(this, "currentPath", new CurvePath());
+    __publicField(this, "paths", [this.currentPath]);
+  }
+  arc(x, y, radius, startAngle, endAngle, counterclockwise) {
+    this.currentPath.absarc(x, y, radius, startAngle, endAngle, !counterclockwise);
+    return this;
+  }
+  bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
+    this.currentPath.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
+    return this;
+  }
+  lineTo(x, y) {
+    this.currentPath.lineTo(x, y);
+    return this;
+  }
+  moveTo(x, y) {
+    this.currentPath = new CurvePath();
+    this.paths.push(this.currentPath);
+    this.currentPath.moveTo(x, y);
+    return this;
+  }
+  quadraticCurveTo(cpx, cpy, x, y) {
+    this.currentPath.quadraticCurveTo(cpx, cpy, x, y);
+    return this;
+  }
+  rect(x, y, w, h) {
+    this.currentPath.rect(x, y, w, h);
+    return this;
+  }
+  splineThru(points) {
+    this.currentPath.splineThru(points);
+    return this;
+  }
+  toPathCommands() {
+    return this.paths.flatMap((path) => path.curves.flatMap((curve) => curve.toPathCommands()));
+  }
+  drawTo(ctx) {
+    this.paths.forEach((path) => {
+      path.curves.forEach((curve) => {
+        curve.drawTo(ctx);
+      });
+    });
+  }
+  strokeTo(ctx) {
+    this.drawTo(ctx);
+    ctx.stroke();
+  }
+  fillTo(ctx) {
+    this.drawTo(ctx);
+    ctx.fill();
+  }
+}
+
+export { CircleCurve, CubicBezierCurve, Curve, CurvePath, EllipseCurve, HeartCurve, LineCurve, Path2D, PloygonCurve, Point2D, QuadraticBezierCurve, RectangularCurve, SplineCurve, catmullRom, cubicBezier, quadraticBezier };