@escapace/minimum-perimeter-triangle 0.2.5 → 0.3.0

package/lib/types/index.d.ts

@@ -1,25 +1,42 @@
-import { Line } from './line';
-import { Vec2 } from './vec2';
+declare class Line {
+    readonly delta: Vec2;
+    readonly end: Vec2;
+    readonly start: Vec2;
+    constructor(start: Vec2, end: Vec2);
+    closestPoint(p: Vec2): Vec2;
+    closestPointParam(p: Vec2): number;
+    distanceToPoint(p: Vec2): number;
+    evaluate(t: number): Vec2;
+    intersectionParameter(that: Line, error: number): number | null;
+    intersectionPoint(that: Line, error: number): Vec2 | null;
+    overlaps(that: Line, error: number): boolean;
+    /**
+     *  If alpha is less than deviationFromZeroAngle, the 2 lines are
+     *  considered parallel.
+     *  _______________________________
+     *                        alpha (/
+     *                              /
+     *                             /
+     *                            /
+     */
+    parallel(that: Line, deviationFromZeroAngle: number): boolean;
+    pointOnSide(p: Vec2, error?: number): number;
+    pointOnTop(p: Vec2, error: number): boolean;
+    /**
+     * Length of a line is the length between its two defining points
+     */
+    get length(): number;
+}
+
 export declare function lineTangentToHull(line: Line, points: Vec2[], halo: number): {
     holds: boolean;
     side: number;
 };
-/**
- * Finds a minimal perimeter triangle enclosing a convex hull of an _arc_ trace
- * The longest side of the hull is considered to be a bottom of the triangle and
- * _is fixed_. This procedure is tailored from the generic algorithm given in
- * http://scholar.uwindsor.ca/cgi/viewcontent.cgi?article=2527&context=etd
- * starting from p. 22; In the notation of the generic algorithm BC is fixed
- */
-export declare function minTriangleWithBase(convexHull: Vec2[], err: number, tol: number): {
-    A: Vec2;
-    B: Vec2;
-    C: Vec2;
-} | null;
+
 export declare function minTriangle(convexHull: Array<{
     x: number;
     y: number;
-}>, err: number, tol: number): {
+}>, error: number, tol: number): {
     A: {
         x: number;
         y: number;
@@ -33,4 +50,41 @@ export declare function minTriangle(convexHull: Array<{
         y: number;
     };
 } | null;
-//# sourceMappingURL=index.d.ts.map
+
+/**
+ * Finds a minimal perimeter triangle enclosing a convex hull of an _arc_ trace
+ * The longest side of the hull is considered to be a bottom of the triangle and
+ * _is fixed_. This procedure is tailored from the generic algorithm given in
+ * http://scholar.uwindsor.ca/cgi/viewcontent.cgi?article=2527&context=etd
+ * starting from p. 22; In the notation of the generic algorithm BC is fixed
+ */
+export declare function minTriangleWithBase(convexHull: Vec2[], error: number, tol: number): {
+    A: Vec2;
+    B: Vec2;
+    C: Vec2;
+} | null;
+
+declare class Vec2 {
+    private _norm;
+    private _normalized;
+    private _normSquared;
+    private readonly _x;
+    private readonly _y;
+    constructor(x: number, y: number);
+    cross(that: Vec2): number;
+    dot(that: Vec2): number;
+    equals(that: Vec2, error: number): boolean;
+    minus(that: Vec2): Vec2;
+    normal(): Vec2;
+    over(s: number): Vec2;
+    plus(that: Vec2): Vec2;
+    times(s: number): Vec2;
+    toString(): string;
+    get norm(): number;
+    get normalized(): Vec2;
+    get normSquared(): number;
+    get x(): number;
+    get y(): number;
+}
+
+export { }

package/package.json

@@ -1,69 +1,65 @@
 {
   "name": "@escapace/minimum-perimeter-triangle",
   "description": "",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "author": {
     "name": "escapace",
     "email": "opensource@escapace.com"
   },
   "bugs": "https://github.com/escapace/minimum-perimeter-triangle/issues",
   "devDependencies": {
-    "@commitlint/cli": "17.7.1",
-    "@commitlint/config-conventional": "17.7.0",
-    "@ls-lint/ls-lint": "2.1.0",
-    "@types/chai": "4.3.6",
-    "@types/mocha": "10.0.1",
-    "@types/node": "20.6.4",
-    "@typescript-eslint/eslint-plugin": "6.7.2",
-    "@typescript-eslint/parser": "6.7.2",
-    "c8": "8.0.1",
-    "chai": "4.3.8",
-    "esbuild": "0.19.3",
-    "eslint": "8.50.0",
-    "eslint-config-escapace": "3.18.1",
-    "eslint-config-prettier": "9.0.0",
-    "eslint-plugin-editorconfig": "4.0.3",
-    "eslint-plugin-no-null": "1.0.2",
-    "execa": "8.0.1",
-    "fast-glob": "3.3.1",
-    "fs-extra": "11.1.1",
-    "husky": "8.0.3",
-    "is-ci": "3.0.1",
-    "lint-staged": "14.0.1",
-    "mocha": "10.2.0",
-    "prettier": "3.0.3",
-    "prettier-config-escapace": "1.0.6",
-    "semver": "7.5.4",
-    "syncpack": "11.2.1",
-    "ts-node": "10.9.1",
-    "typescript": "5.2.2"
+    "@commitlint/cli": "20.4.2",
+    "@commitlint/config-conventional": "20.4.2",
+    "@escapace/pnpm-pack": "0.7.0",
+    "@escapace/syncpack-configuration": "0.1.0",
+    "@ls-lint/ls-lint": "2.3.1",
+    "@vitest/coverage-v8": "4.0.18",
+    "eslint": "9.39.3",
+    "eslint-config-escapace": "5.13.0",
+    "esroll": "1.1.5",
+    "knip": "5.85.0",
+    "lefthook": "2.1.1",
+    "prettier": "3.8.1",
+    "prettier-config-escapace": "1.2.2",
+    "syncpack": "14.0.1",
+    "tsx": "4.21.0",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18"
   },
   "engines": {
-    "node": ">=18.18.0",
-    "pnpm": ">=8.7.6"
+    "pnpm": ">=10.29.2"
   },
   "exports": {
     ".": {
-      "import": "./lib/esm/index.mjs",
-      "types": "./lib/types/index.d.ts"
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/neutral/index.js"
     }
   },
   "files": [
-    "lib/esm",
+    "lib/neutral",
     "lib/types"
   ],
-  "homepage": "https://github.com/escapace/minimum-perimeter-triangle",
+  "homepage": "https://github.com/escapace/minimum-perimeter-triangle#readme",
   "license": "MPL-2.0",
-  "module": "lib/esm/index.mjs",
+  "module": "lib/neutral/index.js",
   "private": false,
-  "repository": "escapace/minimum-perimeter-triangle.git",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": "escapace/minimum-perimeter-triangle",
   "sideEffects": false,
   "type": "module",
   "types": "lib/types/index.d.ts",
   "scripts": {
-    "build": "node ./scripts/build.mjs",
-    "lint": "ls-lint && eslint 'src/**/*.{js,mjs,cjs,ts,mts,cts}'",
-    "test": "node ./scripts/test.mjs && c8 mocha --enable-source-maps 'lib/tests/**/*.spec.js'",
-    "typecheck": "tsc --noEmit"
+    "build": "tsx scripts/build.ts",
+    "format": "syncpack format && eslint --no-warn-ignored --fix && prettier --no-error-on-unmatched-pattern -uw .",
+    "lint": "ls-lint --config .ls-lint.yaml && knip --no-config-hints && eslint",
+    "ls-lint": "ls-lint --config .ls-lint.yaml",
+    "pack": "pnpm-pack package --pack-destination lib",
+    "syncpack": "syncpack fix && syncpack format",
+    "test": "vitest --no-watch --coverage",
+    "typecheck": "tsc --noEmit",
+    "update": "ncu --cooldown 7 -p pnpm -u --peer --dep dev,peer,prod,optional && pnpm run syncpack"
   }
 }

package/lib/esm/index.mjs

@@ -1,399 +0,0 @@
-// src/line.ts
-var Line = class {
-  start;
-  end;
-  delta;
-  constructor(start, end) {
-    this.start = start, this.end = end, this.delta = end.minus(start);
-  }
-  /**
-   * Length of a line is the length between its two defining points
-   */
-  get length() {
-    return this.delta.norm;
-  }
-  evaluate(t) {
-    return this.start.plus(this.delta.times(t));
-  }
-  distanceToPoint(p) {
-    return Math.abs(p.cross(this.delta) - this.start.cross(this.end)) / this.delta.norm;
-  }
-  pointOnSide(p, err = 0) {
-    let num = this.start.cross(this.end) - p.cross(this.delta);
-    return num === 0 || Math.abs(num) / this.delta.norm < err ? 0 /* Top */ : num > 0 ? 1 /* Left */ : -1 /* Right */;
-  }
-  pointOnTop(p, err) {
-    return this.pointOnSide(p, err) === 0 /* Top */;
-  }
-  overlaps(that, err) {
-    return this.pointOnTop(that.start, err) && this.pointOnTop(that.end, err);
-  }
-  /**
-   *  If alpha is less than deviationFromZeroAngle, the 2 lines are
-   *  considered parallel.
-   *  _______________________________
-   *                        alpha (/
-   *                              /
-   *                             /
-   *                            /
-   */
-  parallel(that, deviationFromZeroAngle) {
-    let d = Math.abs(this.delta.cross(that.delta));
-    return d === 0 || d < this.length * this.length * Math.sin(deviationFromZeroAngle);
-  }
-  intersectionParameter(that, err) {
-    let d = this.delta.cross(that.delta);
-    if (d === 0 || Math.abs(d) < err)
-      return null;
-    let dStart = this.start.minus(that.start);
-    return that.delta.cross(dStart) / d;
-  }
-  closestPointParam(p) {
-    return this.delta.dot(p.minus(this.start)) / this.delta.normSquared;
-  }
-  closestPoint(p) {
-    return this.evaluate(this.closestPointParam(p));
-  }
-  intersectionPoint(that, err) {
-    let t = this.intersectionParameter(that, err);
-    return t === null ? null : this.evaluate(t);
-  }
-};
-
-// src/vec2.ts
-var Vec2 = class _Vec2 {
-  _x;
-  _y;
-  _normSquared;
-  _norm;
-  _normalized;
-  constructor(x, y) {
-    this._x = x, this._y = y;
-  }
-  times(s) {
-    return new _Vec2(this._x * s, this._y * s);
-  }
-  over(s) {
-    return new _Vec2(this._x / s, this._y / s);
-  }
-  get x() {
-    return this._x;
-  }
-  get y() {
-    return this._y;
-  }
-  plus(that) {
-    return new _Vec2(this._x + that._x, this._y + that._y);
-  }
-  minus(that) {
-    return new _Vec2(this._x - that._x, this._y - that._y);
-  }
-  get normSquared() {
-    return this._normSquared === void 0 ? this._normSquared = this.dot(this) : this._normSquared;
-  }
-  get norm() {
-    return this._norm === void 0 ? this._norm = Math.sqrt(this.normSquared) : this._norm;
-  }
-  get normalized() {
-    return this._normalized === void 0 ? this._normalized = this.over(this.norm) : this._normalized;
-  }
-  dot(that) {
-    return this._x * that._x + this._y * that._y;
-  }
-  cross(that) {
-    return this._x * that._y - this._y * that._x;
-  }
-  equals(that, err) {
-    return err === 0 ? this.x === that.x && this.y === that.y : this.minus(that).normSquared < err * err;
-  }
-  normal() {
-    return new _Vec2(this._y, -this._x);
-  }
-  toString() {
-    return `(${this.x}, ${this.y})`;
-  }
-};
-
-// src/inscribe.ts
-var Wedge = class _Wedge {
-  leftArm;
-  rightArm;
-  isDegenerate;
-  constructor(leftArm, rightArm, isDegenerate = !1) {
-    this.leftArm = leftArm, this.rightArm = rightArm, this.isDegenerate = isDegenerate;
-  }
-  static new(leftArm, rightArm, err) {
-    if (leftArm === null || rightArm === null || err !== 0 && leftArm.overlaps(rightArm, err))
-      return null;
-    let deviationFromZeroAngle = 0.1 / (leftArm.length * rightArm.length);
-    if (leftArm.parallel(rightArm, deviationFromZeroAngle)) {
-      let p = new Line(leftArm.evaluate(0.5), rightArm.evaluate(0.5)).evaluate(0.5), sideLeft = leftArm.pointOnSide(p, err), sideRight = rightArm.pointOnSide(p, err);
-      if (sideLeft === 0 /* Top */ || sideRight === 0 /* Top */)
-        throw new Error();
-      return sideLeft !== sideRight ? new _Wedge(leftArm, rightArm, !0) : new _Wedge(leftArm, new Line(rightArm.end, rightArm.start));
-    }
-    let tLA = leftArm.intersectionParameter(rightArm, 0), tRA = rightArm.intersectionParameter(leftArm, 0);
-    if (tLA === 0.5 || tRA === 0.5)
-      return null;
-    let W = leftArm.evaluate(tLA), eLA = tLA < 1 - tLA ? leftArm.end : leftArm.start, eRA = tRA < 1 - tRA ? rightArm.end : rightArm.start;
-    return new _Wedge(new Line(W, eLA), new Line(W, eRA));
-  }
-  formTriangle(line, err) {
-    if (this.leftArm.parallel(line, 0.1 / (this.leftArm.length * line.length)) || this.rightArm.parallel(line, 0.1 / (this.rightArm.length * line.length)))
-      return !1;
-    let A = line.intersectionPoint(this.leftArm, 0), B = line.intersectionPoint(this.rightArm, 0);
-    if (this.isDegenerate)
-      return !A.equals(B, err);
-    let C = this.leftArm.intersectionPoint(this.rightArm, 0);
-    return !C.equals(A, err) && !C.equals(B, err) && !A.equals(B, err) && !new Line(A, B).pointOnTop(C, err);
-  }
-  looselyContains(p, err) {
-    let pLeft = this.leftArm.pointOnSide(p, err), pRight = this.rightArm.pointOnSide(p, err);
-    return pLeft === 0 /* Top */ || pRight === 0 /* Top */ ? !0 : pLeft === pRight ? !1 : this.isDegenerate ? (
-      // degenerate + different sides => true
-      !0
-    ) : (
-      // 2. (Because the arms intersect)
-      // Projection params of the point onto the arms must be larger than 0
-      this.leftArm.closestPointParam(p) >= 0 && this.rightArm.closestPointParam(p) >= 0
-    );
-  }
-  strictlyContains(p, err) {
-    let pLeft = this.leftArm.pointOnSide(p, err), pRight = this.rightArm.pointOnSide(p, err);
-    return pLeft === 0 /* Top */ || pRight === 0 /* Top */ || pLeft === pRight ? !1 : this.isDegenerate ? (
-      // degenerate + different sides => true
-      !0
-    ) : (
-      // 2. (Because the arms intersect)
-      // Projection params of the point onto the arms must be larger than 0
-      this.leftArm.closestPointParam(p) >= 0 && this.rightArm.closestPointParam(p) >= 0
-    );
-  }
-  // While fitting circles into a wedge
-  // There are four distinct cases:
-  // 1. Wedge is degenerate and additional element is a point
-  // 2. Wedge is degenerate and additional element is a line
-  // 3. Wedge is non-degenerate and additional element is a point
-  // 4. Wedge is non-degenerate and additional element is a line
-  // according to these assumptions, the following methods are named
-  fit_Dp(p, err) {
-    if (!this.strictlyContains(p, err))
-      return null;
-    let A = this.rightArm.closestPoint(p), Ap = this.leftArm.closestPoint(A), I = A.plus(Ap).over(2), r = A.minus(Ap).norm / 2, a = this.rightArm.delta.normSquared, b = I.minus(p).dot(this.rightArm.delta) * 2, c = I.minus(p).normSquared - r * r, discriminant = b * b - 4 * a * c;
-    if (discriminant < (-10) ** -5)
-      return null;
-    let t = [];
-    Math.abs(discriminant) < 10 ** -5 ? t.push(-b / (2 * a)) : (t.push((-b + Math.sqrt(discriminant)) / (2 * a)), t.push((-b - Math.sqrt(discriminant)) / (2 * a)));
-    let result = [];
-    return t.forEach((t0) => {
-      let O = this.rightArm.delta.times(t0).plus(I);
-      result.push({
-        circle: { centre: O, r },
-        tangent: new Line(p, p.plus(O.minus(p).normal()))
-      });
-    }), result;
-  }
-  fit_Dl(l, err) {
-    if (!this.formTriangle(l, err))
-      return null;
-    let A = l.intersectionPoint(this.rightArm, 0), B = l.intersectionPoint(this.leftArm, 0), AB = new Line(A, B), Ap = this.leftArm.closestPoint(A), I = A.plus(Ap).over(2), r = A.minus(Ap).norm / 2, t1 = (AB.delta.cross(A.minus(I)) + r * AB.delta.norm) / AB.delta.cross(this.rightArm.delta), t2 = (AB.delta.cross(A.minus(I)) - r * AB.delta.norm) / AB.delta.cross(this.rightArm.delta), o1 = this.rightArm.delta.times(t1).plus(I), o2 = this.rightArm.delta.times(t2).plus(I);
-    return [
-      {
-        circle: { centre: o1, r },
-        tangentParameter: l.closestPointParam(o1)
-      },
-      {
-        circle: { centre: o2, r },
-        tangentParameter: l.closestPointParam(o2)
-      }
-    ];
-  }
-  fit_NDp(p, err) {
-    if (!this.strictlyContains(p, err))
-      return null;
-    let C = this.leftArm.start, A = this.leftArm.end, B = this.rightArm.end, a = C.minus(B).norm, b = C.minus(A).norm, D = A.minus(B).times(a / (a + b)).plus(B), bisector = new Line(C, D), eA = D.minus(C).normSquared - (A.minus(C).cross(D.minus(C)) / b) ** 2, eB = D.minus(C).dot(C.minus(p)) * 2, eC = C.minus(p).normSquared, discriminant = eB * eB - 4 * eA * eC;
-    if (discriminant < (-10) ** -5)
-      return null;
-    let O, r;
-    if (Math.abs(discriminant) < 10 ** -5) {
-      let t = -eB / (2 * eA);
-      O = bisector.evaluate(t), r = O.minus(p).norm;
-    } else {
-      let t1 = (-eB + Math.sqrt(discriminant)) / (2 * eA), t2 = (-eB - Math.sqrt(discriminant)) / (2 * eA);
-      bisector.evaluate(t1).minus(p).normSquared > bisector.evaluate(t2).minus(p).normSquared ? (O = bisector.evaluate(t1), r = bisector.evaluate(t1).minus(p).norm) : (O = bisector.evaluate(t2), r = bisector.evaluate(t2).minus(p).norm);
-    }
-    return [
-      {
-        circle: { centre: O, r },
-        tangent: new Line(p, p.plus(O.minus(p).normal()))
-      }
-    ];
-  }
-  fit_NDl(l, err) {
-    if (!this.formTriangle(l, err))
-      return null;
-    let C = this.leftArm.start, A = l.intersectionPoint(this.leftArm, 0), B = l.intersectionPoint(this.rightArm, 0), AC = new Line(A, C), BC = new Line(B, C), AB = new Line(A, B), a = AC.length, b = BC.length, c = AB.length, s = (a + b + c) / 2;
-    if (s * (s - a) * (s - b) / (s - c) < 0)
-      return null;
-    let r = Math.sqrt(s * (s - a) * (s - b) / (s - c)), det = AB.delta.cross(AC.delta), lhsAll = [
-      new Vec2(B.cross(A) + r * c, C.cross(A) + r * a),
-      new Vec2(B.cross(A) + r * c, C.cross(A) - r * a),
-      new Vec2(B.cross(A) - r * c, C.cross(A) + r * a),
-      new Vec2(B.cross(A) - r * c, C.cross(A) - r * a)
-    ], OAll = [];
-    lhsAll.forEach((lhs) => {
-      OAll.push(
-        new Vec2(
-          new Vec2(AB.delta.x, AC.delta.x).cross(lhs),
-          new Vec2(AB.delta.y, AC.delta.y).cross(lhs)
-        ).over(-det)
-      );
-    });
-    let o = null, dists = [];
-    for (let O of OAll) {
-      dists.push({
-        raw: Math.abs(BC.distanceToPoint(O) - r),
-        norm: Math.abs(BC.distanceToPoint(O) / r - 1)
-      });
-      let absoluteError = Math.abs(BC.distanceToPoint(O) - r), relativeError = Math.abs(BC.distanceToPoint(O) / r - 1);
-      if ((absoluteError < 10 ** -5 || relativeError < 10 ** -5) && AC.pointOnSide(O) !== BC.pointOnSide(O)) {
-        o = O;
-        break;
-      }
-    }
-    let msg = "";
-    if (o === null) {
-      msg = "fit_NDl, centre is undefined";
-      for (let i = 0; i < OAll.length; i++)
-        msg += `centre: (${OAll[i].x}, ${OAll[i].y}), r: ${r}, dist raw: ${dists[i].raw},  dist norm: ${dists[i].norm}
-`;
-    }
-    if (o === null)
-      throw new Error(msg);
-    return [
-      {
-        circle: { centre: o, r },
-        tangentParameter: l.closestPointParam(o)
-      }
-    ];
-  }
-  fitCircles(element, err) {
-    return element instanceof Vec2 ? this.isDegenerate ? this.fit_Dp(element, err) : this.fit_NDp(element, err) : element instanceof Line ? this.isDegenerate ? this.fit_Dl((element instanceof Line, element), err) : this.fit_NDl((element instanceof Line, element), err) : null;
-  }
-  toString() {
-    return `LA: ${this.leftArm.start.toString()} --> ${this.leftArm.end.toString()}
-RA: ${this.rightArm.start.toString()} --> ${this.rightArm.end.toString()}`;
-  }
-};
-
-// src/index.ts
-function lineTangentToHull(line, points, halo) {
-  let holds = !0, side = 0 /* Top */, k = 0;
-  for (; side === 0 /* Top */ && k < points.length; )
-    side = line.pointOnSide(points[k], halo), k++;
-  for (let i = k; i < points.length; i++) {
-    let testSide = line.pointOnSide(points[i], halo);
-    if (testSide !== 0 /* Top */ && testSide !== side) {
-      holds = !1;
-      break;
-    }
-  }
-  return { holds, side };
-}
-function findEnclosingSide(wedge, startVertex, endVertex, points, halo) {
-  let side = null, stopVertex = startVertex, vertex = startVertex;
-  for (; side === null && vertex > endVertex; ) {
-    let p1 = points[vertex], p2 = points[vertex - 1], edge = new Line(p1, p2), circlesEdge = wedge.fitCircles(edge, halo);
-    if (circlesEdge !== null) {
-      let tangentParameter = 100;
-      if (wedge.isDegenerate) {
-        let sidedness = 0 /* Top */, k = 0;
-        for (; sidedness === 0 /* Top */ && k < points.length; )
-          sidedness = edge.pointOnSide(points[k], halo), k++;
-        tangentParameter = edge.pointOnSide(circlesEdge[0].circle.centre) !== sidedness ? circlesEdge[0].tangentParameter : circlesEdge[1].tangentParameter;
-      } else
-        tangentParameter = circlesEdge[0].tangentParameter;
-      if (tangentParameter > 0 && tangentParameter < 1) {
-        let Y = edge.evaluate(tangentParameter), joint = wedge.leftArm.intersectionPoint(edge, halo);
-        side = new Line(joint, Y);
-      }
-    }
-    if (side === null) {
-      let circlesPoint = wedge.fitCircles(p2, halo);
-      if (circlesPoint !== null) {
-        let tangent;
-        if (wedge.isDegenerate) {
-          let sidedness = 0 /* Top */, k = 0;
-          for (; sidedness === 0 /* Top */ && k < points.length; )
-            sidedness = circlesPoint[0].tangent.pointOnSide(points[k], halo), k++;
-          tangent = circlesPoint[0].tangent.pointOnSide(
-            circlesPoint[0].circle.centre,
-            halo
-          ) !== sidedness ? circlesPoint[0].tangent : circlesPoint[1].tangent;
-        } else
-          tangent = circlesPoint[0].tangent;
-        if (lineTangentToHull(tangent, points, halo).holds) {
-          let joint = wedge.leftArm.intersectionPoint(tangent, halo);
-          side = new Line(joint, p2);
-        }
-      }
-    }
-    stopVertex = vertex, vertex--;
-  }
-  return side === null ? null : { side, stopVertex };
-}
-function findAntipode(points) {
-  let farthestIndex = 0, farthestDist = 0;
-  for (let i = 0, n = points.length; i < n; i++) {
-    let testDist = new Line(points[0], points[n - 1]).distanceToPoint(
-      points[i]
-    );
-    testDist > farthestDist && (farthestDist = testDist, farthestIndex = i);
-  }
-  return farthestIndex;
-}
-function minTriangleWithBase(convexHull, err, tol) {
-  let AB, AC, n = convexHull.length, BC = new Line(convexHull[0], convexHull[n - 1]), antipodIndex = findAntipode(convexHull), baseParallel = new Line(
-    convexHull[antipodIndex],
-    convexHull[antipodIndex].plus(BC.delta)
-  ), wedge = Wedge.new(BC, baseParallel, err), Pn = n - 1, Qn = antipodIndex;
-  do {
-    let CQinfo = findEnclosingSide(wedge, Pn, antipodIndex, convexHull, err);
-    if (CQinfo === null)
-      return null;
-    ({ side: AC, stopVertex: Pn } = CQinfo), wedge = Wedge.new(wedge.leftArm, AC, err);
-    let BPinfo = findEnclosingSide(wedge, Qn, 0, convexHull, err);
-    if (BPinfo === null)
-      return null;
-    ({ side: AB, stopVertex: Qn } = BPinfo), wedge = Wedge.new(wedge.leftArm, AB, err);
-  } while (AB.length - AC.length > tol);
-  let A = AC.intersectionPoint(AB, 0), B = AB.start, C = AC.start;
-  return { A, B, C };
-}
-function minTriangle(convexHull, err, tol) {
-  if (convexHull.length < 3)
-    return null;
-  if (convexHull.length === 3)
-    return { A: convexHull[0], B: convexHull[1], C: convexHull[2] };
-  let points = convexHull.map((p) => new Vec2(p.x, p.y)), A = null, B = null, C = null, perimeter = -1, rotations = 0;
-  for (; rotations < points.length; ) {
-    rotations > 0 && points.push(points.shift());
-    let triangle = minTriangleWithBase(points, err, tol);
-    if (triangle !== null) {
-      let { A: A1, B: B1, C: C1 } = triangle, perimeter1 = A1.minus(B1).norm + B1.minus(C1).norm + C1.minus(A1).norm;
-      (perimeter1 < perimeter || perimeter === -1) && ([A, B, C] = [A1, B1, C1], perimeter = perimeter1);
-    }
-    rotations++;
-  }
-  return perimeter === -1 ? null : {
-    A: { x: A.x, y: A.y },
-    B: { x: B.x, y: B.y },
-    C: { x: C.x, y: C.y }
-  };
-}
-export {
-  lineTangentToHull,
-  minTriangle,
-  minTriangleWithBase
-};
-//# sourceMappingURL=index.mjs.map