@escapace/minimum-perimeter-triangle 0.2.5 → 0.2.6

package/lib/types/inscribe.d.ts

@@ -1,6 +1,6 @@
 import { Line } from './line';
 import { Vec2 } from './vec2';
-export interface Circle {
+interface Circle {
     centre: Vec2;
     r: number;
 }
@@ -10,26 +10,27 @@ export interface Circle {
  * in this case they must point in the same direction
  */
 export declare class Wedge {
+    readonly isDegenerate: boolean;
     readonly leftArm: Line;
     readonly rightArm: Line;
-    readonly isDegenerate: boolean;
     private constructor();
-    static new(leftArm: Line, rightArm: Line, err: number): Wedge | null;
-    formTriangle(line: Line, err: number): boolean;
-    looselyContains(p: Vec2, err: number): boolean;
-    strictlyContains(p: Vec2, err: number): boolean;
-    private fit_Dp;
+    static new(leftArm: Line, rightArm: Line, error: number): Wedge | null;
     private fit_Dl;
-    private fit_NDp;
+    private fit_Dp;
     private fit_NDl;
-    fitCircles(element: Vec2, err: number): Array<{
+    private fit_NDp;
+    fitCircles(element: Vec2, error: number): Array<{
         circle: Circle;
         tangent: Line;
     }> | null;
-    fitCircles(element: Line, err: number): Array<{
+    fitCircles(element: Line, error: number): Array<{
         circle: Circle;
         tangentParameter: number;
     }> | null;
+    formTriangle(line: Line, error: number): boolean;
+    looselyContains(p: Vec2, error: number): boolean;
+    strictlyContains(p: Vec2, error: number): boolean;
     toString(): string;
 }
+export {};
 //# sourceMappingURL=inscribe.d.ts.map

package/lib/types/inscribe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inscribe.d.ts","sourceRoot":"","sources":["../../src/inscribe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAQ,MAAM,QAAQ,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE,IAAI,CAAA;IACZ,CAAC,EAAE,MAAM,CAAA;CACV;AAED;;;;GAIG;AACH,qBAAa,KAAK;IAChB,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAA;IACvB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAE9B,OAAO;IAMP,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI;IA2DpE,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAyB9C,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAuB9C,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IA+B/C,OAAO,CAAC,MAAM;IAgEd,OAAO,CAAC,MAAM;IAoDd,OAAO,CAAC,OAAO;IA2Ef,OAAO,CAAC,OAAO;IAwGf,UAAU,CACR,OAAO,EAAE,IAAI,EACb,GAAG,EAAE,MAAM,GACV,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,IAAI,CAAA;KAAE,CAAC,GAAG,IAAI;IAClD,UAAU,CACR,OAAO,EAAE,IAAI,EACb,GAAG,EAAE,MAAM,GACV,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI;IAe7D,QAAQ,IAAI,MAAM;CAMnB"}
+{"version":3,"file":"inscribe.d.ts","sourceRoot":"","sources":["../../src/inscribe.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAQ,MAAM,QAAQ,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B,UAAU,MAAM;IACd,MAAM,EAAE,IAAI,CAAA;IACZ,CAAC,EAAE,MAAM,CAAA;CACV;AAED;;;;GAIG;AACH,qBAAa,KAAK;IAChB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAA;IAC9B,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,IAAI,CAAA;IAEvB,OAAO;IAMP,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI;IA4DtE,OAAO,CAAC,MAAM;IAkDd,OAAO,CAAC,MAAM;IA6Dd,OAAO,CAAC,OAAO;IAgHf,OAAO,CAAC,OAAO;IAqEf,UAAU,CAAC,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,IAAI,CAAA;KAAE,CAAC,GAAG,IAAI;IAEzF,UAAU,CACR,OAAO,EAAE,IAAI,EACb,KAAK,EAAE,MAAM,GACZ,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG,IAAI;IAc7D,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAwBhD,eAAe,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAqBhD,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAsBjD,QAAQ,IAAI,MAAM;CAMnB"}

package/lib/types/line.d.ts

@@ -1,23 +1,21 @@
-import { Vec2 } from './vec2';
+import type { Vec2 } from './vec2';
 export declare enum Side {
+    Left = 1,
     Right = -1,
-    Top = 0,
-    Left = 1
+    Top = 0
 }
 export declare class Line {
-    readonly start: Vec2;
-    readonly end: Vec2;
     readonly delta: Vec2;
+    readonly end: Vec2;
+    readonly start: Vec2;
     constructor(start: Vec2, end: Vec2);
-    /**
-     * Length of a line is the length between its two defining points
-     */
-    get length(): number;
-    evaluate(t: number): Vec2;
+    closestPoint(p: Vec2): Vec2;
+    closestPointParam(p: Vec2): number;
     distanceToPoint(p: Vec2): number;
-    pointOnSide(p: Vec2, err?: number): number;
-    pointOnTop(p: Vec2, err: number): boolean;
-    overlaps(that: Line, err: number): boolean;
+    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.
@@ -28,9 +26,11 @@ export declare class Line {
      *                            /
      */
     parallel(that: Line, deviationFromZeroAngle: number): boolean;
-    intersectionParameter(that: Line, err: number): number | null;
-    closestPointParam(p: Vec2): number;
-    closestPoint(p: Vec2): Vec2;
-    intersectionPoint(that: Line, err: number): Vec2 | null;
+    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;
 }
 //# sourceMappingURL=line.d.ts.map

package/lib/types/line.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/line.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B,oBAAY,IAAI;IACd,KAAK,KAAK;IACV,GAAG,IAAI;IACP,IAAI,IAAI;CACT;AAED,qBAAa,IAAI;IACf,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;IACpB,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAA;IAClB,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;gBAER,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;IAMlC;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAIzB,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM;IAOhC,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,SAAI,GAAG,MAAM;IAQrC,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAI1C;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,sBAAsB,EAAE,MAAM,GAAG,OAAO;IAS7D,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAS7D,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM;IAIlC,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI3B,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;CAIxD"}
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/line.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAElC,oBAAY,IAAI;IACd,IAAI,IAAI;IACR,KAAK,KAAK;IACV,GAAG,IAAI;CACR;AAED,qBAAa,IAAI;IACf,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;IACpB,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAA;IAClB,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAA;gBAER,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;IAMlC,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI3B,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM;IAIlC,eAAe,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM;IAIhC,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAIzB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAS/D,iBAAiB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAKzD,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAI5C;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,sBAAsB,EAAE,MAAM,GAAG,OAAO;IAM7D,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,SAAI,GAAG,MAAM;IAQvC,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAI3C;;OAEG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}

package/lib/types/vec2.d.ts

@@ -1,23 +1,23 @@
 export declare class Vec2 {
-    private readonly _x;
-    private readonly _y;
-    private _normSquared;
     private _norm;
     private _normalized;
+    private _normSquared;
+    private readonly _x;
+    private readonly _y;
     constructor(x: number, y: number);
-    times(s: number): Vec2;
+    cross(that: Vec2): number;
+    dot(that: Vec2): number;
+    equals(that: Vec2, error: number): boolean;
+    minus(that: Vec2): Vec2;
+    normal(): Vec2;
     over(s: number): Vec2;
-    get x(): number;
-    get y(): number;
     plus(that: Vec2): Vec2;
-    minus(that: Vec2): Vec2;
-    get normSquared(): number;
+    times(s: number): Vec2;
+    toString(): string;
     get norm(): number;
     get normalized(): Vec2;
-    dot(that: Vec2): number;
-    cross(that: Vec2): number;
-    equals(that: Vec2, err: number): boolean;
-    normal(): Vec2;
-    toString(): string;
+    get normSquared(): number;
+    get x(): number;
+    get y(): number;
 }
 //# sourceMappingURL=vec2.d.ts.map

package/lib/types/vec2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vec2.d.ts","sourceRoot":"","sources":["../../src/vec2.ts"],"names":[],"mappings":"AACA,qBAAa,IAAI;IACf,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;IAC3B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;IAE3B,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,WAAW,CAAkB;gBAEzB,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAKhC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAItB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAIrB,IAAI,CAAC,IAAI,MAAM,CAEd;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAED,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAItB,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAIvB,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED,IAAI,IAAI,IAAI,MAAM,CAIjB;IAED,IAAI,UAAU,IAAI,IAAI,CAIrB;IAED,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAIvB,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAIzB,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IAOxC,MAAM,IAAI,IAAI;IAId,QAAQ,IAAI,MAAM;CAGnB"}
+{"version":3,"file":"vec2.d.ts","sourceRoot":"","sources":["../../src/vec2.ts"],"names":[],"mappings":"AACA,qBAAa,IAAI;IACf,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,WAAW,CAAkB;IAErC,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;IAC3B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAQ;gBAEf,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAKhC,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAIzB,GAAG,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAIvB,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO;IAO1C,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAIvB,MAAM,IAAI,IAAI;IAId,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAIrB,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAItB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAItB,QAAQ,IAAI,MAAM;IAIlB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,UAAU,IAAI,IAAI,CAIrB;IAED,IAAI,WAAW,IAAI,MAAM,CAIxB;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;CACF"}

package/package.json

@@ -1,69 +1,63 @@
 {
   "name": "@escapace/minimum-perimeter-triangle",
   "description": "",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "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": "19.6.0",
+    "@commitlint/config-conventional": "19.6.0",
+    "@escapace/pnpm-pack": "0.5.3",
+    "@ls-lint/ls-lint": "2.2.3",
+    "@vitest/coverage-v8": "2.1.8",
+    "eslint": "9.17.0",
+    "eslint-config-escapace": "5.4.0",
+    "esroll": "0.3.0",
+    "knip": "5.40.0",
+    "lefthook": "1.9.2",
+    "prettier": "3.4.2",
+    "prettier-config-escapace": "1.2.1",
+    "syncpack": "13.0.0",
+    "tsx": "4.19.2",
+    "typescript": "5.7.2",
+    "vitest": "2.1.8"
   },
   "engines": {
-    "node": ">=18.18.0",
-    "pnpm": ">=8.7.6"
+    "pnpm": ">=9.14.4"
   },
   "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'",
+    "build": "tsx scripts/build.ts",
+    "format": "syncpack format && eslint --no-warn-ignored --fix && prettier -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-mismatches && syncpack set-semver-ranges && syncpack format",
+    "test": "vitest --no-watch --coverage",
     "typecheck": "tsc --noEmit"
   }
 }

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