circuit-json-to-tscircuit 0.0.86 → 0.0.87

package/dist/{chunk-UZVNOAO4.js → chunk-DZP2ZWBQ.js}

@@ -570,85 +570,134 @@ import { su as su3 } from "@tscircuit/soup-util";
 import { symbols } from "schematic-symbols";
 
 // lib/generate-board-schematic-tsx/get-symbol-to-schematic-transform.ts
+import { fromTriangles as fromTriangles2 } from "transformation-matrix";
+
+// lib/generate-board-schematic-tsx/get-renderer-compatible-symbol-transform.ts
+import { compose as compose2, scale, translate as translate2 } from "transformation-matrix";
+
+// lib/generate-board-schematic-tsx/match-schematic-ports-to-symbol-ports.ts
+var getAngle = ({
+  center,
+  point
+}) => Math.atan2(point.y - center.y, point.x - center.x);
+var getAngularDifference = (first, second) => {
+  const directDifference = Math.abs(first - second);
+  return Math.min(directDifference, 2 * Math.PI - directDifference);
+};
+var matchSchematicPortsToSymbolPorts = ({
+  schematicComponent,
+  schematicPorts,
+  symbol
+}) => {
+  const schematicPortsByAngle = schematicPorts.map((schematicPort) => ({
+    angle: getAngle({
+      center: schematicComponent.center,
+      point: schematicPort.center
+    }),
+    schematicPort
+  })).sort((first, second) => first.angle - second.angle);
+  const symbolPortsByAngle = symbol.ports.map((symbolPort) => ({
+    angle: getAngle({ center: symbol.center, point: symbolPort }),
+    symbolPort
+  })).sort((first, second) => first.angle - second.angle);
+  const usedSymbolPorts = /* @__PURE__ */ new Set();
+  const matches = [];
+  for (const schematicPortWithAngle of schematicPortsByAngle) {
+    const closestSymbolPort = symbolPortsByAngle.filter(({ symbolPort }) => !usedSymbolPorts.has(symbolPort)).map(({ angle, symbolPort }) => ({
+      angularDifference: getAngularDifference(
+        schematicPortWithAngle.angle,
+        angle
+      ),
+      symbolPort
+    })).sort(
+      (first, second) => first.angularDifference - second.angularDifference
+    )[0];
+    if (!closestSymbolPort || closestSymbolPort.angularDifference >= Math.PI / 4)
+      continue;
+    usedSymbolPorts.add(closestSymbolPort.symbolPort);
+    matches.push({
+      schematicPort: schematicPortWithAngle.schematicPort,
+      symbolPort: closestSymbolPort.symbolPort
+    });
+  }
+  return matches;
+};
+
+// lib/generate-board-schematic-tsx/get-renderer-compatible-symbol-transform.ts
+var getRendererCompatibleSymbolTransform = ({
+  schematicComponent,
+  schematicPorts,
+  symbol
+}) => {
+  const matches = matchSchematicPortsToSymbolPorts({
+    schematicComponent,
+    schematicPorts,
+    symbol
+  });
+  const first = matches[0];
+  if (!first) return void 0;
+  const second = matches[1];
+  const firstSymbolPoint = second?.symbolPort ?? symbol.center;
+  const firstSchematicPoint = second?.schematicPort.center ?? schematicComponent.center;
+  const originalDistance = Math.hypot(
+    first.symbolPort.x - firstSymbolPoint.x,
+    first.symbolPort.y - firstSymbolPoint.y
+  );
+  if (originalDistance === 0) return void 0;
+  const renderedDistance = Math.hypot(
+    first.schematicPort.center.x - firstSchematicPoint.x,
+    first.schematicPort.center.y - firstSchematicPoint.y
+  );
+  const uniformScale = renderedDistance / originalDistance;
+  return compose2(
+    translate2(firstSchematicPoint.x, firstSchematicPoint.y),
+    scale(uniformScale),
+    translate2(-firstSymbolPoint.x, -firstSymbolPoint.y)
+  );
+};
+
+// lib/generate-board-schematic-tsx/get-rigid-pin-identity-transform.ts
 import { applyToPoint as applyToPoint3, fromTriangles } from "transformation-matrix";
 
 // lib/generate-board-schematic-tsx/get-port-pair-triangle.ts
 import {
   applyToPoint as applyToPoint2,
-  compose as compose2,
+  compose as compose3,
   rotateDEG as rotateDEG2,
-  translate as translate2
+  translate as translate3
 } from "transformation-matrix";
 var getPortPairTriangle = ({
   first,
   second
 }) => {
-  const portToPerpendicularTransform = compose2(
-    translate2(first.x, first.y),
+  const portToPerpendicularTransform = compose3(
+    translate3(first.x, first.y),
     rotateDEG2(90),
-    translate2(-first.x, -first.y)
+    translate3(-first.x, -first.y)
   );
   return [first, second, applyToPoint2(portToPerpendicularTransform, second)];
 };
 
-// lib/generate-board-schematic-tsx/get-symbol-to-schematic-transform.ts
-var getSymbolToSchematicTransform = ({
-  symbol,
-  schematicComponent,
-  schematicPorts,
-  sourcePorts
-}) => {
-  const matches = symbol.ports.flatMap((symbolPort) => {
-    const candidates = schematicPorts.filter((schematicPort) => {
-      const sourcePort = sourcePorts.find(
-        (port) => port.source_port_id === schematicPort.source_port_id
-      );
-      const pinNumber = schematicPort.pin_number ?? sourcePort?.pin_number;
-      const labels = [
-        sourcePort?.name,
-        ...sourcePort?.port_hints ?? [],
-        ...pinNumber === void 0 ? [] : [String(pinNumber), `pin${pinNumber}`]
-      ];
-      return labels.some(
-        (label) => label !== void 0 && symbolPort.labels.includes(label)
-      );
-    });
-    return candidates.length === 1 ? [{ symbolPort, schematicPort: candidates[0] }] : [];
-  });
+// lib/generate-board-schematic-tsx/get-rigid-pin-identity-transform.ts
+var TRANSFORM_TOLERANCE = 1e-6;
+var getRigidPinIdentityTransform = (matches) => {
   const first = matches[0];
   const second = matches.find(
     (match) => match !== first && match.schematicPort !== first?.schematicPort
   );
-  if (first && second) {
-    const third = matches.find(
-      (match) => match !== first && match !== second && isNonCollinear({
-        first: first.symbolPort,
-        second: second.symbolPort,
-        third: match.symbolPort
-      }) && isNonCollinear({
-        first: first.schematicPort.center,
-        second: second.schematicPort.center,
-        third: match.schematicPort.center
-      })
-    );
-    if (third) {
-      const transform = fromTriangles(
-        [first.symbolPort, second.symbolPort, third.symbolPort],
-        [
-          first.schematicPort.center,
-          second.schematicPort.center,
-          third.schematicPort.center
-        ]
-      );
-      const fitsAllMatchedPorts = matches.every((match) => {
-        const transformedPort = applyToPoint3(transform, match.symbolPort);
-        return Math.hypot(
-          transformedPort.x - match.schematicPort.center.x,
-          transformedPort.y - match.schematicPort.center.y
-        ) < 1e-6;
-      });
-      if (fitsAllMatchedPorts) return transform;
-    }
+  if (!first || !second) return void 0;
+  const third = matches.find(
+    (match) => match !== first && match !== second && pointsAreNonCollinear({
+      first: first.symbolPort,
+      second: second.symbolPort,
+      third: match.symbolPort
+    }) && pointsAreNonCollinear({
+      first: first.schematicPort.center,
+      second: second.schematicPort.center,
+      third: match.schematicPort.center
+    })
+  );
+  if (!third) {
     return fromTriangles(
       getPortPairTriangle({
         first: first.symbolPort,
@@ -660,7 +709,87 @@ var getSymbolToSchematicTransform = ({
       })
     );
   }
-  return fromTriangles(
+  const transform = fromTriangles(
+    [first.symbolPort, second.symbolPort, third.symbolPort],
+    [
+      first.schematicPort.center,
+      second.schematicPort.center,
+      third.schematicPort.center
+    ]
+  );
+  if (!isRigidUniformTransform(transform)) return void 0;
+  const fitsAllMatchedPorts = matches.every((match) => {
+    const transformedPort = applyToPoint3(transform, match.symbolPort);
+    return Math.hypot(
+      transformedPort.x - match.schematicPort.center.x,
+      transformedPort.y - match.schematicPort.center.y
+    ) < TRANSFORM_TOLERANCE;
+  });
+  return fitsAllMatchedPorts ? transform : void 0;
+};
+var pointsAreNonCollinear = ({
+  first,
+  second,
+  third
+}) => Math.abs(
+  (second.x - first.x) * (third.y - first.y) - (second.y - first.y) * (third.x - first.x)
+) > Number.EPSILON;
+var isRigidUniformTransform = (transform) => {
+  const firstAxisLength = Math.hypot(transform.a, transform.b);
+  const secondAxisLength = Math.hypot(transform.c, transform.d);
+  if (firstAxisLength === 0 || secondAxisLength === 0) return false;
+  const axisDotProduct = transform.a * transform.c + transform.b * transform.d;
+  const relativeScaleDifference = Math.abs(firstAxisLength - secondAxisLength) / Math.max(firstAxisLength, secondAxisLength);
+  const normalizedAxisDotProduct = Math.abs(axisDotProduct) / (firstAxisLength * secondAxisLength);
+  return relativeScaleDifference < TRANSFORM_TOLERANCE && normalizedAxisDotProduct < TRANSFORM_TOLERANCE;
+};
+
+// lib/generate-board-schematic-tsx/match-symbol-ports-by-pin-identity.ts
+var matchSymbolPortsByPinIdentity = ({
+  schematicPorts,
+  sourcePorts,
+  symbol
+}) => symbol.ports.flatMap((symbolPort) => {
+  const candidates = schematicPorts.filter((schematicPort) => {
+    const sourcePort = sourcePorts.find(
+      (port) => port.source_port_id === schematicPort.source_port_id
+    );
+    const pinNumber = schematicPort.pin_number ?? sourcePort?.pin_number;
+    const portIdentities = [
+      sourcePort?.name,
+      ...sourcePort?.port_hints ?? [],
+      ...pinNumber === void 0 ? [] : [String(pinNumber), `pin${pinNumber}`]
+    ];
+    return portIdentities.some(
+      (portIdentity) => portIdentity !== void 0 && symbolPort.labels.includes(portIdentity)
+    );
+  });
+  return candidates.length === 1 ? [{ symbolPort, schematicPort: candidates[0] }] : [];
+});
+
+// lib/generate-board-schematic-tsx/get-symbol-to-schematic-transform.ts
+var getSymbolToSchematicTransform = ({
+  symbol,
+  schematicComponent,
+  schematicPorts,
+  sourcePorts
+}) => {
+  const pinIdentityMatches = matchSymbolPortsByPinIdentity({
+    schematicPorts,
+    sourcePorts,
+    symbol
+  });
+  const rigidPinIdentityTransform = getRigidPinIdentityTransform(pinIdentityMatches);
+  if (rigidPinIdentityTransform) return rigidPinIdentityTransform;
+  if (pinIdentityMatches.length >= 3) {
+    const rendererCompatibleTransform = getRendererCompatibleSymbolTransform({
+      schematicComponent,
+      schematicPorts,
+      symbol
+    });
+    if (rendererCompatibleTransform) return rendererCompatibleTransform;
+  }
+  return fromTriangles2(
     [
       symbol.center,
       { x: symbol.center.x + symbol.size.width, y: symbol.center.y },
@@ -679,13 +808,6 @@ var getSymbolToSchematicTransform = ({
     ]
   );
 };
-var isNonCollinear = ({
-  first,
-  second,
-  third
-}) => Math.abs(
-  (second.x - first.x) * (third.y - first.y) - (second.y - first.y) * (third.x - first.x)
-) > Number.EPSILON;
 
 // lib/generate-board-schematic-tsx/convert-symbol-primitives.ts
 import { schematic_text as schematic_text2 } from "circuit-json";
@@ -1041,7 +1163,7 @@ import { symbols as symbols2 } from "schematic-symbols";
 // lib/generate-board-schematic-tsx/get-net-label-symbol-to-schematic-transform.ts
 import {
   fromOneMovingPoint,
-  translate as translate3
+  translate as translate4
 } from "transformation-matrix";
 var getNetLabelSymbolToSchematicTransform = ({
   symbol,
@@ -1049,7 +1171,7 @@ var getNetLabelSymbolToSchematicTransform = ({
 }) => {
   const symbolPort = symbol.ports[0];
   if (!symbolPort) {
-    return translate3(schematicAnchorPosition.x, schematicAnchorPosition.y);
+    return translate4(schematicAnchorPosition.x, schematicAnchorPosition.y);
   }
   return fromOneMovingPoint(symbolPort, schematicAnchorPosition);
 };

package/dist/cli/main.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-UZVNOAO4.js";
+} from "../chunk-DZP2ZWBQ.js";
 
 // cli/main.ts
 import { Command } from "commander";
@@ -16,7 +16,7 @@ var package_default = {
     "./cli": "./dist/cli/main.js"
   },
   type: "module",
-  version: "0.0.85",
+  version: "0.0.86",
   repository: {
     type: "git",
     url: "https://github.com/tscircuit/circuit-json-to-tscircuit.git"

package/dist/lib/index.js

@@ -1,6 +1,6 @@
 import {
   convertCircuitJsonToTscircuit
-} from "../chunk-UZVNOAO4.js";
+} from "../chunk-DZP2ZWBQ.js";
 export {
   convertCircuitJsonToTscircuit
 };

package/lib/generate-board-schematic-sheet-tsx.ts

@@ -1,6 +1,11 @@
 import { mmStr } from "@tscircuit/mm"
 import type { AnyCircuitElement } from "circuit-json"
 
+const DEFAULT_SHEET_DIMENSIONS_MM = {
+  a4: { width: 297, height: 210 },
+  ansi_b: { width: 431.8, height: 279.4 },
+} as const
+
 export const generateBoardSchematicSheetTsx = ({
   circuitJson,
   schematicElements,
@@ -21,11 +26,11 @@ export const generateBoardSchematicSheetTsx = ({
   if (sheet.sheet_size) {
     attrs.push(`sheetSize="${sheet.sheet_size === "a4" ? "A4" : "ANSI_B"}"`)
   }
-  if (sheet.sheet_width !== undefined) {
-    attrs.push(`sheetWidth="${mmStr(sheet.sheet_width)}"`)
-  }
-  if (sheet.sheet_height !== undefined) {
-    attrs.push(`sheetHeight="${mmStr(sheet.sheet_height)}"`)
-  }
+  const defaultDimensions =
+    DEFAULT_SHEET_DIMENSIONS_MM[sheet.sheet_size ?? "a4"]
+  const sheetWidth = sheet.sheet_width ?? defaultDimensions.width
+  const sheetHeight = sheet.sheet_height ?? defaultDimensions.height
+  attrs.push(`sheetWidth="${mmStr(sheetWidth)}"`)
+  attrs.push(`sheetHeight="${mmStr(sheetHeight)}"`)
   return `<schematicsheet ${attrs.join(" ")}>\n${schematicElements.join("\n")}\n</schematicsheet>`
 }

package/lib/generate-board-schematic-tsx/get-renderer-compatible-symbol-transform.ts

@@ -0,0 +1,43 @@
+import type { SchematicComponent, SchematicPort } from "circuit-json"
+import type { SchSymbol } from "schematic-symbols"
+import { compose, scale, translate, type Matrix } from "transformation-matrix"
+import { matchSchematicPortsToSymbolPorts } from "./match-schematic-ports-to-symbol-ports"
+
+export const getRendererCompatibleSymbolTransform = ({
+  schematicComponent,
+  schematicPorts,
+  symbol,
+}: {
+  schematicComponent: SchematicComponent
+  schematicPorts: SchematicPort[]
+  symbol: SchSymbol
+}): Matrix | undefined => {
+  const matches = matchSchematicPortsToSymbolPorts({
+    schematicComponent,
+    schematicPorts,
+    symbol,
+  })
+  const first = matches[0]
+  if (!first) return undefined
+
+  const second = matches[1]
+  const firstSymbolPoint = second?.symbolPort ?? symbol.center
+  const firstSchematicPoint =
+    second?.schematicPort.center ?? schematicComponent.center
+  const originalDistance = Math.hypot(
+    first.symbolPort.x - firstSymbolPoint.x,
+    first.symbolPort.y - firstSymbolPoint.y,
+  )
+  if (originalDistance === 0) return undefined
+
+  const renderedDistance = Math.hypot(
+    first.schematicPort.center.x - firstSchematicPoint.x,
+    first.schematicPort.center.y - firstSchematicPoint.y,
+  )
+  const uniformScale = renderedDistance / originalDistance
+  return compose(
+    translate(firstSchematicPoint.x, firstSchematicPoint.y),
+    scale(uniformScale),
+    translate(-firstSymbolPoint.x, -firstSymbolPoint.y),
+  )
+}

package/lib/generate-board-schematic-tsx/get-rigid-pin-identity-transform.ts

@@ -0,0 +1,95 @@
+import { applyToPoint, fromTriangles, type Matrix } from "transformation-matrix"
+import { getPortPairTriangle } from "./get-port-pair-triangle"
+import type { SchematicSymbolPortMatch } from "./match-symbol-ports-by-pin-identity"
+
+const TRANSFORM_TOLERANCE = 0.000001
+
+export const getRigidPinIdentityTransform = (
+  matches: SchematicSymbolPortMatch[],
+): Matrix | undefined => {
+  const first = matches[0]
+  const second = matches.find(
+    (match) => match !== first && match.schematicPort !== first?.schematicPort,
+  )
+  if (!first || !second) return undefined
+
+  const third = matches.find(
+    (match) =>
+      match !== first &&
+      match !== second &&
+      pointsAreNonCollinear({
+        first: first.symbolPort,
+        second: second.symbolPort,
+        third: match.symbolPort,
+      }) &&
+      pointsAreNonCollinear({
+        first: first.schematicPort.center,
+        second: second.schematicPort.center,
+        third: match.schematicPort.center,
+      }),
+  )
+  if (!third) {
+    return fromTriangles(
+      getPortPairTriangle({
+        first: first.symbolPort,
+        second: second.symbolPort,
+      }),
+      getPortPairTriangle({
+        first: first.schematicPort.center,
+        second: second.schematicPort.center,
+      }),
+    )
+  }
+
+  const transform = fromTriangles(
+    [first.symbolPort, second.symbolPort, third.symbolPort],
+    [
+      first.schematicPort.center,
+      second.schematicPort.center,
+      third.schematicPort.center,
+    ],
+  )
+  if (!isRigidUniformTransform(transform)) return undefined
+
+  const fitsAllMatchedPorts = matches.every((match) => {
+    const transformedPort = applyToPoint(transform, match.symbolPort)
+    return (
+      Math.hypot(
+        transformedPort.x - match.schematicPort.center.x,
+        transformedPort.y - match.schematicPort.center.y,
+      ) < TRANSFORM_TOLERANCE
+    )
+  })
+  return fitsAllMatchedPorts ? transform : undefined
+}
+
+const pointsAreNonCollinear = ({
+  first,
+  second,
+  third,
+}: {
+  first: { x: number; y: number }
+  second: { x: number; y: number }
+  third: { x: number; y: number }
+}) =>
+  Math.abs(
+    (second.x - first.x) * (third.y - first.y) -
+      (second.y - first.y) * (third.x - first.x),
+  ) > Number.EPSILON
+
+const isRigidUniformTransform = (transform: Matrix) => {
+  const firstAxisLength = Math.hypot(transform.a, transform.b)
+  const secondAxisLength = Math.hypot(transform.c, transform.d)
+  if (firstAxisLength === 0 || secondAxisLength === 0) return false
+
+  const axisDotProduct = transform.a * transform.c + transform.b * transform.d
+  const relativeScaleDifference =
+    Math.abs(firstAxisLength - secondAxisLength) /
+    Math.max(firstAxisLength, secondAxisLength)
+  const normalizedAxisDotProduct =
+    Math.abs(axisDotProduct) / (firstAxisLength * secondAxisLength)
+  return (
+    relativeScaleDifference < TRANSFORM_TOLERANCE &&
+    normalizedAxisDotProduct < TRANSFORM_TOLERANCE
+  )
+}

package/lib/generate-board-schematic-tsx/get-symbol-to-schematic-transform.ts

@@ -4,9 +4,10 @@ import type {
   SourcePort,
 } from "circuit-json"
 import type { SchSymbol } from "schematic-symbols"
-import { applyToPoint, fromTriangles } from "transformation-matrix"
-
-import { getPortPairTriangle } from "./get-port-pair-triangle"
+import { fromTriangles } from "transformation-matrix"
+import { getRendererCompatibleSymbolTransform } from "./get-renderer-compatible-symbol-transform"
+import { getRigidPinIdentityTransform } from "./get-rigid-pin-identity-transform"
+import { matchSymbolPortsByPinIdentity } from "./match-symbol-ports-by-pin-identity"
 
 export const getSymbolToSchematicTransform = ({
   symbol,
@@ -19,81 +20,27 @@ export const getSymbolToSchematicTransform = ({
   schematicPorts: SchematicPort[]
   sourcePorts: SourcePort[]
 }) => {
-  // Match declared pin identities, never inferred angles or array order.
-  const matches = symbol.ports.flatMap((symbolPort) => {
-    const candidates = schematicPorts.filter((schematicPort) => {
-      const sourcePort = sourcePorts.find(
-        (port) => port.source_port_id === schematicPort.source_port_id,
-      )
-      const pinNumber = schematicPort.pin_number ?? sourcePort?.pin_number
-      const labels = [
-        sourcePort?.name,
-        ...(sourcePort?.port_hints ?? []),
-        ...(pinNumber === undefined
-          ? []
-          : [String(pinNumber), `pin${pinNumber}`]),
-      ]
-      return labels.some(
-        (label) => label !== undefined && symbolPort.labels.includes(label),
-      )
-    })
-    return candidates.length === 1
-      ? [{ symbolPort, schematicPort: candidates[0]! }]
-      : []
+  const pinIdentityMatches = matchSymbolPortsByPinIdentity({
+    schematicPorts,
+    sourcePorts,
+    symbol,
   })
-  const first = matches[0]
-  const second = matches.find(
-    (match) => match !== first && match.schematicPort !== first?.schematicPort,
-  )
-  if (first && second) {
-    const third = matches.find(
-      (match) =>
-        match !== first &&
-        match !== second &&
-        isNonCollinear({
-          first: first.symbolPort,
-          second: second.symbolPort,
-          third: match.symbolPort,
-        }) &&
-        isNonCollinear({
-          first: first.schematicPort.center,
-          second: second.schematicPort.center,
-          third: match.schematicPort.center,
-        }),
-    )
-    if (third) {
-      const transform = fromTriangles(
-        [first.symbolPort, second.symbolPort, third.symbolPort],
-        [
-          first.schematicPort.center,
-          second.schematicPort.center,
-          third.schematicPort.center,
-        ],
-      )
-      const fitsAllMatchedPorts = matches.every((match) => {
-        const transformedPort = applyToPoint(transform, match.symbolPort)
-        return (
-          Math.hypot(
-            transformedPort.x - match.schematicPort.center.x,
-            transformedPort.y - match.schematicPort.center.y,
-          ) < 0.000001
-        )
-      })
-      if (fitsAllMatchedPorts) return transform
-    }
-    return fromTriangles(
-      getPortPairTriangle({
-        first: first.symbolPort,
-        second: second.symbolPort,
-      }),
-      getPortPairTriangle({
-        first: first.schematicPort.center,
-        second: second.schematicPort.center,
-      }),
-    )
+  const rigidPinIdentityTransform =
+    getRigidPinIdentityTransform(pinIdentityMatches)
+  if (rigidPinIdentityTransform) return rigidPinIdentityTransform
+
+  if (pinIdentityMatches.length >= 3) {
+    // Inconsistent pin identities must not shear standard symbol artwork.
+    // Match circuit-to-svg's established transform for the visual fallback.
+    const rendererCompatibleTransform = getRendererCompatibleSymbolTransform({
+      schematicComponent,
+      schematicPorts,
+      symbol,
+    })
+    if (rendererCompatibleTransform) return rendererCompatibleTransform
   }
-  // Without matching pin identities, use the explicitly imported component
-  // bounds. The library constructs the transform from those correspondences.
+
+  // Without matching ports, use the explicitly imported component bounds.
   return fromTriangles(
     [
       symbol.center,
@@ -113,17 +60,3 @@ export const getSymbolToSchematicTransform = ({
     ],
   )
 }
-
-const isNonCollinear = ({
-  first,
-  second,
-  third,
-}: {
-  first: { x: number; y: number }
-  second: { x: number; y: number }
-  third: { x: number; y: number }
-}) =>
-  Math.abs(
-    (second.x - first.x) * (third.y - first.y) -
-      (second.y - first.y) * (third.x - first.x),
-  ) > Number.EPSILON