README.md

@@ -55,8 +55,6 @@ LGAV BIBE1L SID (Cycle 2507, ID 10654)
 ### Instructions
 
 - From preceding fix, fly along `Course` until reaching `Alt`.
-- If preceding fix was overfly, offset outbound `Course` to end of turn (tangent).
-- Earliest leg terminations is at point of tangent.
 
 ### Units
 
@@ -86,8 +84,6 @@ LGAV BIBE2F SID (Cycle 2507, ID 10657)
 
 - From preceding fix, fly along `Course` until reaching `Distance` from the navaid identified by
   `NavID`.
-- If preceding fix was overfly, offset outbound `Course` to end of turn (tangent).
-- Earliest leg terminations is at point of tangent.
 
 ### Units
 
@@ -120,7 +116,6 @@ LGAV BIBE2F SID (Cycle 2507, ID 10657)
 
 - From preceding fix, fly `Course` to the fix identified by (`WptID`, `WptLat`, `WptLon`) *or* 
   (`NavID`, `NavLat`, `NavLon`, `NavDist`, `NavBear`).
-- If preceding fix was overfly, continue turn until intercept `Course`, then continue on `Course`.
 
 ### Units
 
@@ -206,16 +201,14 @@ LGAV KOR1D SID (Cycle 2507, ID 10679)
 
 ### Instructions
 
-- From present position, fly direct to fix identified by `WptID`.
+- From present position, fly direct to fix identified by `WptID`
-- If preceding fix and fix identified by `WptId` are the same, execute 360° turn
-  (requires `TurnDir`).
 
 ### Units
 
 - `IsFlyOver`: Boolean indicating if fix is a mandatory fly over.
 
 
-## Track from Fix to Altitude (FA)
+## Fix to Altitude (FA)
 
 ### Example
 
@@ -234,8 +227,6 @@ LGAV BIBE2F SID (Cycle 2507, ID 10657)
 
 - From the fix identified by (`WptID`, `WptLat`, `WptLon`) *or*
   (`NavID`, `NavLat`, `NavLon`, `NavDist`, `NavBear`), fly `Course` until reaching `Alt`.
-- If preceding fix was overfly, continue turn until intercept `Course`, then continue on `Course`.
-- Earliest leg terminations is at point of intercept.
 
 ### Units
 
@@ -270,9 +261,6 @@ LIED CAR6F SID (Cycle 2507, ID 11798)
 
 - From the fix identified by (`WptID`, `WptLat`, `WptLon`) *or*
   (`NavID`, `NavLat`, `NavLon`, `NavDist`, `NavBear`), fly `Course` until reaching `Distance`.
-- If preceding fix was overfly, continue turn until intercept `Course`, then continue on `Course`.
-- Earliest leg terminations is at point of intercept.
-
 
 ### Units
 
@@ -304,10 +292,8 @@ LGAV BIBE2T SID (Cycle 2507, ID 10659)
 ### Instructions
 
 - From the fix identified by (`WptID`, `WptLat`, `WptLon`) *or*
-  (`NavID`, `NavLat`, `NavLon`, `NavDist`, `NavBear`), fly `Course` until reaching `Distance` from
+  (`NavID`, `NavLat`, `NavLon`, `NavDist`, `NavBear`), fly `Course` until
-  navaid identified by `NavID`.
+  reaching `Distance` from navaid identified by `NavID`.
-- If preceding fix was overfly, continue turn until intercept `Course`, then continue on `Course`.
-- Earliest leg terminations is at point of intercept.
 
 ### Units
 

browser/src/App.tsx

@@ -8,21 +8,18 @@ import L from "leaflet";
 
 const parser = await Parser.instance();
 
-const terminals = [
+const terminals = [10394, 10395, 10475, 10480, 10482, 10485, 10653];
-  10394, 10395, 10475, 10480, 10482, 10485, 10653, 10654, 10657, 10659, 10679,
-  11798, 11909, 12765,
-];
 
 function App() {
   const [selectedTerminal, setSelectedTerminal] = useState(terminals[0]);
-  const [procedures, setProcedures] = useState<object[]>([]);
+  const [procedure, setProcedure] = useState<object>();
 
   const mapRef = createRef<Leaflet.Map>();
   const layerRef = createRef<Leaflet.GeoJSON>();
 
   useEffect(() => {
     (async () => {
-      setProcedures(await parser.parse(selectedTerminal));
+      setProcedure(await parser.parse(selectedTerminal));
     })();
   }, [selectedTerminal]);
 
@@ -50,102 +47,82 @@ function App() {
           attribution='&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
           url="https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
         />
-        {procedures.map((procedure) => (
+        <GeoJSON
-          <>
+          key={hash(procedure ?? "") + "lines"}
-            <GeoJSON
+          data={procedure}
-              key={hash(procedure ?? "") + "lines"}
+          style={({ properties }) => ({
-              data={procedure}
+            color: "#ff00ff",
-              style={({ properties }) => ({
+            stroke: true,
-                color: "#ff00ff",
+            weight: 5,
-                stroke: true,
+            opacity: 1,
-                weight: 5,
+            dashArray: properties.isManual ? "20, 20" : undefined,
-                opacity: 1,
+          })}
-                dashArray: properties.isManual ? "20, 20" : undefined,
+          filter={(feature) => feature.geometry.type !== "Point"}
-              })}
+          ref={layerRef}
-              filter={(feature) => feature.geometry.type !== "Point"}
+        />
-              ref={layerRef}
+        <GeoJSON
-            />
+          key={hash(procedure ?? "") + "points"}
-            <GeoJSON
+          data={procedure}
-              key={hash(procedure ?? "") + "points"}
+          style={{
-              data={procedure}
+            color: "black",
-              style={{
+            fill: true,
-                color: "black",
+            fillColor: "transparent",
-                fill: true,
+            stroke: true,
-                fillColor: "transparent",
+            weight: 3,
-                stroke: true,
+          }}
-                weight: 3,
+          pointToLayer={({ properties }, latlng) => {
-              }}
+            if (properties.isFlyOver)
-              pointToLayer={({ properties }, latlng) => {
+              return L.shapeMarker(latlng, {
-                if (properties.isFlyOver)
+                shape: "triangle",
-                  return L.shapeMarker(latlng, {
+                radius: 6,
-                    shape: "triangle",
+              });
-                    radius: 6,
+            if (properties.isIntersection)
-                  });
+              return L.circleMarker(latlng, { radius: 6 });
-                if (properties.isIntersection)
-                  return L.circleMarker(latlng, { radius: 6 });
 
-                return L.shapeMarker(latlng, {
+            return L.shapeMarker(latlng, {
-                  shape: "star-4",
+              shape: "star-4",
-                  radius: 10,
+              radius: 10,
-                  rotation: 45,
+              rotation: 45,
-                });
+            });
-              }}
+          }}
-              onEachFeature={({ geometry, properties }, layer) => {
+          onEachFeature={({ geometry, properties }, layer) => {
-                if (geometry.type === "Point") {
+            if (geometry.type === "Point") {
-                  layer.bindPopup(
+              layer.bindPopup(
-                    `${properties.name}<br>
+                `${properties.name}<br>
                 ${properties.altitude} ft<br>
                 ${properties.speed} kts<br>
                 CNSTR: 
                 ${properties.altitudeConstraint ?? ""}
                 ${properties.speedConstraint ?? ""}<br>`
-                  );
+              );
-                }
+            }
-              }}
+          }}
-              filter={(feature) => feature.geometry.type === "Point"}
+          filter={(feature) => feature.geometry.type === "Point"}
-            />
+        />
-          </>
-        ))}
       </MapContainer>
       <div
         style={{
-          overflowY: "scroll",
+          padding: "5px",
-          width: "200px",
+          display: "flex",
+          flexDirection: "column",
+          gap: "10px",
         }}
       >
-        <div
+        {terminals.map((terminal) => (
-          style={{
+          <div
-            padding: "5px",
+            key={terminal}
-            display: "flex",
+            style={{
-            flexDirection: "column",
+              display: "flex",
-            gap: "10px",
+              gap: "10px",
-          }}
+              background: selectedTerminal === terminal ? "#eeeeee" : undefined,
-        >
+            }}
-          {terminals.map((terminal) => (
+          >
-            <div
+            <pre>ID {terminal}</pre>
-              key={terminal}
+            <button onClick={() => setSelectedTerminal(terminal)}>
-              style={{
+              Select
-                display: "flex",
+            </button>
-                flexDirection: "column",
+          </div>
-                background: "#eeeeee",
+        ))}
-                border:
-                  selectedTerminal === terminal
-                    ? "1px solid black"
-                    : "1px solid #eeeeee",
-                padding: "5px",
-              }}
-              onClick={() => setSelectedTerminal(terminal)}
-            >
-              <span style={{ whiteSpace: "nowrap" }}>
-                {(() => {
-                  const t = parser.terminals.find(({ ID }) => ID === terminal);
-                  return `${t?.ICAO} - ${t?.FullName}`;
-                })()}
-              </span>
-              <pre>({terminal})</pre>
-            </div>
-          ))}
-        </div>
       </div>
     </div>
   );

browser/src/parser/node.ts

@@ -14,4 +14,4 @@ fetch = async (path: string) => {
 
 const parser = await Parser.instance();
 
-console.log(JSON.stringify(await parser.parse(12765)));
+console.log(JSON.stringify(await parser.parse(10480)));

browser/src/parser/parser.ts

@@ -12,40 +12,25 @@ import { TerminatorsTF } from "./terminators/TF.ts";
 import { TerminatorsVI } from "./terminators/VI.ts";
 import { TerminatorsVD } from "./terminators/VD.ts";
 import { TerminatorsRF } from "./terminators/RF.ts";
-import { TerminatorsCA } from "./terminators/CA.ts";
-import { TerminatorsDF } from "./terminators/DF.ts";
-import { TerminatorsFD } from "./terminators/FD.ts";
-import { TerminatorsFA } from "./terminators/FA.ts";
-import { TerminatorsCD } from "./terminators/CD.ts";
-import { TerminatorsVR } from "./terminators/VR.ts";
-import { TerminatorsIF } from "./terminators/IF.ts";
-import { TerminatorsFC } from "./terminators/FC.ts";
-
-/*
-Runway IDs for LIED
-26156 - 34L
-26157 - 34R
-*/
 
 class Parser {
   private static _instance: Parser;
 
-  private _waypoints: Waypoint[];
+  private waypoints: Waypoint[];
-  private _runways: Runway[];
+  private runways: Runway[];
-  private _terminals: Terminal[];
+  private terminals: Terminal[];
 
   public static AC_SPEED = 250;
-  public static AC_BANK = 30;
+  public static AC_VS = 1500;
-  public static AC_VS = 1400;
 
   private constructor(
     waypoints: Waypoint[],
     runways: Runway[],
     terminals: Terminal[]
   ) {
-    this._waypoints = waypoints;
+    this.waypoints = waypoints;
-    this._runways = runways;
+    this.runways = runways;
-    this._terminals = terminals;
+    this.terminals = terminals;
   }
 
   public static instance = async () => {
@@ -60,297 +45,233 @@ class Parser {
     return Parser._instance;
   };
 
-  public get terminals() {
-    return this._terminals;
-  }
-  public get waypoints() {
-    return this._waypoints;
-  }
-  public get runways() {
-    return this._runways;
-  }
-
   public parse = async (terminalID: number) => {
+    // Private functions
+    /**
+     * @param line Line segments
+     */
+    const updateLastCourse = (line: LineSegment[]) => {
+      lastCourse = geolib.getGreatCircleBearing(
+        {
+          latitude: line.at(-2)![1],
+          longitude: line.at(-2)![0],
+        },
+        {
+          latitude: line.at(-1)![1],
+          longitude: line.at(-1)![0],
+        }
+      );
+    };
+
     // Get Procedure main
     const terminal = this.terminals.find(({ ID }) => ID === terminalID);
     if (!terminal) throw new Error("Procedure does not exists");
     // Get runway this procedure is for
-    let runway = this.runways.find(({ ID }) => ID === terminal.RwyID);
+    const runway = this.runways.find(({ ID }) => ID === terminal.RwyID);
-    if (!runway) {
+    if (!runway) throw new Error("Procedure links to non existent Runway");
-      let id = 26156;
-      if (typeof prompt !== "undefined")
-        //  throw new Error("Prompt not defined, cannot continue");
-
-        id = Number.parseInt(prompt("Runway ID") ?? "");
-      runway = this.runways.find(({ ID }) => ID === id);
-      if (!runway) throw new Error("Procedure links to non existent Runway");
-    }
     // Load procedure
-    const procedures = (await (
+    const procedure = (await (
       await fetch(`NavData/TermID_${terminalID}.json`)
     ).json()) as TerminalEntry[];
-    // Split into transitions
-    const transitions = new Set(procedures.map((proc) => proc.Transition));
 
-    const output: object[] = [];
+    // Output variables
+    const navFixes: NavFix[] = [];
+    const lineSegments: { line: LineSegment[]; [x: string]: unknown }[] = [];
+
+    // Initials
+    navFixes.push({
+      latitude: runway.Latitude,
+      longitude: runway.Longitude,
+      altitude: runway.Elevation,
+      speed: 0,
+      name: runway.Ident,
+    });
+    let lastCourse = runway.TrueHeading;
 
     // Main
-    transitions.forEach((transition) => {
+    for (let index = 0; index < procedure.length; index++) {
-      // Private functions
+      const leg = procedure[index];
-      /**
+      const previousFix = navFixes.at(-1)!;
-       * @param line Line segments
+      const waypoint = this.waypoints.filter(({ ID }) => ID === leg.WptID)[0];
-       */
-      const updateLastCourse = (line: LineSegment[]) => {
-        lastCourse = geolib.getGreatCircleBearing(
-          {
-            latitude: line.at(-2)![1],
-            longitude: line.at(-2)![0],
-          },
-          {
-            latitude: line.at(-1)![1],
-            longitude: line.at(-1)![0],
-          }
-        );
-      };
 
-      /**
+      switch (leg.TrackCode) {
-       * @param fix New fix
+        case "AF": {
-       * @param line New line
+          const [fixToAdd, lineToAdd] = TerminatorsAF(
-       * @param options Options for line rendering
+            leg as AFTerminalEntry,
-       */
+            previousFix,
-      const update = (
+            waypoint
-        fix?: NavFix,
+          );
-        line?: LineSegment[],
+          if (fixToAdd) navFixes.push(fixToAdd);
-        options?: Record<string, unknown>
+          if (lineToAdd) {
-      ) => {
+            lineSegments.push({ line: lineToAdd });
-        if (fix) navFixes.push(fix);
+            updateLastCourse(lineToAdd);
-        if (line) {
+          }
-          lineSegments.push({ line, ...options });
+          break;
-          updateLastCourse(line);
         }
-      };
+        case "CA":
-
+        case "CD":
-      // Output variables
+          console.error("Unknown TrackCode", leg.TrackCode);
-      const navFixes: NavFix[] = [];
+          break;
-      const lineSegments: { line: LineSegment[]; [x: string]: unknown }[] = [];
+        case "CF": {
-
+          const [fixToAdd, lineToAdd] = TerminatorsCF(
-      // Initials
+            leg as CFTerminalEntry,
-      navFixes.push({
+            previousFix,
-        latitude: runway.Latitude,
+            lastCourse,
-        longitude: runway.Longitude,
+            waypoint
-        altitude: runway.Elevation,
+          );
-        speed: 0,
+          if (fixToAdd) navFixes.push(fixToAdd);
-        name: runway.Ident,
+          if (lineToAdd) {
-      });
+            lineSegments.push({ line: lineToAdd });
-      let lastCourse = runway.TrueHeading;
+            updateLastCourse(lineToAdd);
-
-      const procedure = procedures.filter(
-        (proc) => proc.Transition === transition
-      );
-      for (let index = 0; index < procedure.length; index++) {
-        const leg = procedure[index];
-        const previousFix = navFixes.at(-1)!;
-        const waypoint = this.waypoints.filter(({ ID }) => ID === leg.WptID)[0];
-
-        switch (leg.TrackCode) {
-          case "AF": {
-            const [fixToAdd, lineToAdd] = TerminatorsAF(
-              leg as AFTerminalEntry,
-              previousFix,
-              waypoint
-            );
-            update(fixToAdd, lineToAdd);
-            break;
           }
-          case "CA": {
+          break;
-            const [fixToAdd, lineToAdd] = TerminatorsCA(
-              leg as CATerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "CD": {
-            const [fixToAdd, lineToAdd] = TerminatorsCD(
-              leg as CDTerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "CF": {
-            const [fixToAdd, lineToAdd] = TerminatorsCF(
-              leg as CFTerminalEntry,
-              previousFix,
-              lastCourse,
-              waypoint
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "CI": {
-            const [fixToAdd, lineToAdd] = TerminatorsCI(
-              leg as CITerminalEntry,
-              procedure[index + 1],
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "CR": {
-            const [fixToAdd, lineToAdd] = TerminatorsCR(
-              leg as CRTerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "DF": {
-            const [fixToAdd, lineToAdd] = TerminatorsDF(
-              leg as DFTerminalEntry,
-              previousFix,
-              lastCourse,
-              waypoint
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "FA": {
-            const [fixToAdd, lineToAdd] = TerminatorsFA(
-              leg as FATerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "FC": {
-            const [fixToAdd, lineToAdd] = TerminatorsFC(
-              leg as FCTerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "FD": {
-            const [fixToAdd, lineToAdd] = TerminatorsFD(
-              leg as FDTerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "FM": {
-            const [fixToAdd, lineToAdd] = TerminatorsFM(
-              leg as FMTerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd, { isManual: true });
-            break;
-          }
-          case "HA":
-          case "HF":
-          case "HM":
-            console.error("Unknown TrackCode", leg.TrackCode);
-            break;
-          case "IF": {
-            const fixToAdd = TerminatorsIF(leg as RFTerminalEntry, waypoint);
-            navFixes.length = 0;
-            navFixes.push(fixToAdd);
-            break;
-          }
-          case "PI":
-            console.error("Unknown TrackCode", leg.TrackCode);
-            break;
-          case "RF": {
-            const [fixToAdd, lineToAdd] = TerminatorsRF(
-              leg as RFTerminalEntry,
-              procedure[index + 1],
-              previousFix,
-              lastCourse,
-              waypoint
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "TF": {
-            const [fixToAdd, lineToAdd] = TerminatorsTF(
-              leg as TFTerminalEntry,
-              previousFix,
-              lastCourse,
-              waypoint
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "VA": {
-            const [fixToAdd, lineToAdd] = TerminatorsVA(
-              leg as VATerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "VD": {
-            const [fixToAdd, lineToAdd] = TerminatorsVD(
-              leg as VDTerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "VI": {
-            const [fixToAdd, lineToAdd] = TerminatorsVI(
-              leg as VITerminalEntry,
-              procedure[index + 1],
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          case "VM": {
-            const [fixToAdd, lineToAdd] = TerminatorsVM(
-              leg as VMTerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd, { isManual: true });
-            break;
-          }
-          case "VR": {
-            const [fixToAdd, lineToAdd] = TerminatorsVR(
-              leg as VRTerminalEntry,
-              previousFix,
-              lastCourse
-            );
-            update(fixToAdd, lineToAdd);
-            break;
-          }
-          default:
-            console.error("Unknown TrackCode", leg.TrackCode);
-            break;
         }
+        case "CI": {
+          const [fixToAdd, lineToAdd] = TerminatorsCI(
+            leg as CITerminalEntry,
+            procedure[index + 1],
+            previousFix,
+            lastCourse
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "CR": {
+          const [fixToAdd, lineToAdd] = TerminatorsCR(
+            leg as CRTerminalEntry,
+            previousFix,
+            lastCourse
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "DF":
+        case "FA":
+        case "FC":
+        case "FD":
+          console.error("Unknown TrackCode", leg.TrackCode);
+          break;
+        case "FM": {
+          const [fixToAdd, lineToAdd] = TerminatorsFM(
+            leg as FMTerminalEntry,
+            previousFix,
+            lastCourse
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd, isManual: true });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "HA":
+        case "HF":
+        case "HM":
+        case "IF":
+        case "PI":
+          console.error("Unknown TrackCode", leg.TrackCode);
+          break;
+        case "RF": {
+          const [fixToAdd, lineToAdd] = TerminatorsRF(
+            leg as RFTerminalEntry,
+            procedure[index + 1],
+            previousFix,
+            lastCourse,
+            waypoint
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "TF": {
+          const [fixToAdd, lineToAdd] = TerminatorsTF(
+            leg as TFTerminalEntry,
+            previousFix,
+            lastCourse,
+            waypoint
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "VA": {
+          const [fixToAdd, lineToAdd] = TerminatorsVA(
+            leg as VATerminalEntry,
+            previousFix,
+            lastCourse
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "VD": {
+          const [fixToAdd, lineToAdd] = TerminatorsVD(
+            leg as VDTerminalEntry,
+            previousFix,
+            lastCourse
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "VI": {
+          const [fixToAdd, lineToAdd] = TerminatorsVI(
+            leg as VITerminalEntry,
+            procedure[index + 1],
+            previousFix,
+            lastCourse
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "VM": {
+          const [fixToAdd, lineToAdd] = TerminatorsVM(
+            leg as VMTerminalEntry,
+            previousFix,
+            lastCourse
+          );
+          if (fixToAdd) navFixes.push(fixToAdd);
+          if (lineToAdd) {
+            lineSegments.push({ line: lineToAdd, isManual: true });
+            updateLastCourse(lineToAdd);
+          }
+          break;
+        }
+        case "VR":
+        default:
+          console.error("Unknown TrackCode", leg.TrackCode);
+          break;
       }
+    }
 
-      output.push(
+    return geojson.parse([...navFixes, ...lineSegments], {
-        geojson.parse([...navFixes, ...lineSegments], {
+      LineString: "line",
-          LineString: "line",
+      Point: ["latitude", "longitude"],
-          Point: ["latitude", "longitude"],
-        })
-      );
     });
-
-    return output;
   };
 }
 

browser/src/parser/pathGenerators/generatePerformanceArc.ts

@@ -1,31 +1,23 @@
 import * as geolib from "geolib";
 import Parser from "../parser.ts";
-import { computeTurnRate } from "../utils/computeTurnRate.ts";
 
 /**
  * @param crsIntoEndpoint Course into arc endpoint
  * @param crsFromOrigin Course from arc origin point
  * @param start Arc origin point
- * @param speed Speed within arc
  * @param turnDir Turn direction
- * @param force360 If true, force a 360° turn
  * @returns Line segments
  */
 export const generatePerformanceArc = (
   crsIntoEndpoint: number,
   crsFromOrigin: number,
   start: NavFix,
-  speed: number,
+  turnDir?: TurnDirection
-  turnDir?: TurnDirection,
-  force360?: boolean
 ) => {
-  const turnRate = computeTurnRate(speed, Parser.AC_BANK);
-  const originalCrsFromOrigin = crsFromOrigin;
-
   const line: LineSegment[] = [[start.longitude, start.latitude]];
 
   // Check if there even is an arc
-  if (force360 || !crsFromOrigin.equal(crsIntoEndpoint)) {
+  if (crsIntoEndpoint !== crsFromOrigin) {
     // Turn Dir
     if (!turnDir || turnDir === "E") {
       let prov = crsFromOrigin - crsIntoEndpoint;
@@ -34,18 +26,15 @@ export const generatePerformanceArc = (
     }
 
     // Generate arc
-    while (!crsFromOrigin.equal(crsIntoEndpoint)) {
+    while (crsFromOrigin !== crsIntoEndpoint) {
-      let time = 0;
       if (turnDir === "R") {
         const delta = (crsIntoEndpoint - crsFromOrigin).normaliseDegrees();
-        const increment = delta < 1 ? delta : 1;
+        crsFromOrigin += delta < 1 ? delta : 1;
-        crsFromOrigin = (crsFromOrigin + increment).normaliseDegrees();
+        crsFromOrigin = crsFromOrigin.normaliseDegrees();
-        time = increment / turnRate;
       } else {
         const delta = (crsFromOrigin - crsIntoEndpoint).normaliseDegrees();
-        const increment = delta < 1 ? delta : 1;
+        crsFromOrigin -= delta < 1 ? delta : 1;
-        crsFromOrigin = (crsFromOrigin - increment).normaliseDegrees();
+        crsFromOrigin = crsFromOrigin.normaliseDegrees();
-        time = increment / turnRate;
       }
 
       const arcFix = geolib.computeDestinationPoint(
@@ -53,45 +42,12 @@ export const generatePerformanceArc = (
           latitude: line.at(-1)![1],
           longitude: line.at(-1)![0],
         },
-        ((speed / 3600) * time).toMetre(),
+        (Parser.AC_SPEED / 3600).toMetre(),
         crsFromOrigin
       );
 
       line.push([arcFix.longitude, arcFix.latitude]);
     }
-
-    // Second half
-    if (force360) {
-      const temp = crsIntoEndpoint;
-      crsIntoEndpoint = originalCrsFromOrigin;
-      crsFromOrigin = temp;
-
-      while (!crsFromOrigin.equal(crsIntoEndpoint)) {
-        let time = 0;
-        if (turnDir === "R") {
-          const delta = (crsIntoEndpoint - crsFromOrigin).normaliseDegrees();
-          const increment = delta < 1 ? delta : 1;
-          crsFromOrigin = (crsFromOrigin + increment).normaliseDegrees();
-          time = increment / turnRate;
-        } else {
-          const delta = (crsFromOrigin - crsIntoEndpoint).normaliseDegrees();
-          const increment = delta < 1 ? delta : 1;
-          crsFromOrigin = (crsFromOrigin - increment).normaliseDegrees();
-          time = increment / turnRate;
-        }
-
-        const arcFix = geolib.computeDestinationPoint(
-          {
-            latitude: line.at(-1)![1],
-            longitude: line.at(-1)![0],
-          },
-          ((speed / 3600) * time).toMetre(),
-          crsFromOrigin
-        );
-
-        line.push([arcFix.longitude, arcFix.latitude]);
-      }
-    }
   }
 
   return line;

browser/src/parser/pathGenerators/generateTangentArc.ts

@@ -19,7 +19,7 @@ export const generateTangentArc = (
   const line: LineSegment[] = [[start.longitude, start.latitude]];
 
   // Check if there even is an arc
-  if (!crsFromOrigin.equal(crsIntoEndpoint)) {
+  if (crsFromOrigin !== crsIntoEndpoint) {
     // Course to the end of the arc
     let crsFromStartToEnd;
     if (!turnDir || turnDir === "E") {
@@ -75,7 +75,7 @@ export const generateTangentArc = (
         crsOrthogonalOnOrigin < 1 ? crsOrthogonalOnOrigin : 1;
     }
 
-    while (!crsOrthogonalOnOrigin.equal(crsOrthogonalOnEndpoint)) {
+    while (crsOrthogonalOnOrigin !== crsOrthogonalOnEndpoint) {
       if (turnDir === "R") {
         const delta = (
           crsOrthogonalOnEndpoint - crsOrthogonalOnOrigin
@@ -89,6 +89,7 @@ export const generateTangentArc = (
         crsOrthogonalOnOrigin -= delta < 1 ? delta : 1;
         crsOrthogonalOnOrigin = crsOrthogonalOnOrigin.normaliseDegrees();
       }
+      if (crsOrthogonalOnOrigin === crsOrthogonalOnEndpoint) break;
 
       const arcFix = geolib.computeDestinationPoint(
         arcCenter,

browser/src/parser/pathGenerators/handleTurnAtFix.ts

@@ -8,7 +8,6 @@ import { generatePerformanceArc } from "./generatePerformanceArc.ts";
  * @param crsFromOrigin Course from arc origin point
  * @param start Waypoint where leg starts
  * @param end Waypoint where leg ends
- * @param speed Speed for performance arc
  * @param turnDir Turn direction
  * @returns Line segments from `start` to `end`
  */
@@ -18,7 +17,6 @@ export const handleTurnAtFix = (
   crsFromOrigin: number,
   start: NavFix,
   end: NavFix,
-  speed: number,
   turnDir?: TurnDirection
 ) => {
   const line: LineSegment[] = [];
@@ -37,7 +35,6 @@ export const handleTurnAtFix = (
       crsIntoIntercept,
       crsFromOrigin,
       start,
-      speed,
       turnDir
     );
 

browser/src/parser/terminators/AF.ts

@@ -1,6 +1,6 @@
 import * as geolib from "geolib";
 import { generateAFArc } from "../pathGenerators/generateAFArc.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
+import Parser from "../parser.ts";
 
 export const TerminatorsAF = (
   leg: AFTerminalEntry,
@@ -13,7 +13,13 @@ export const TerminatorsAF = (
     name: waypoint?.Ident ?? undefined,
     isFlyOver: leg.IsFlyOver,
     altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: computeSpeed(leg, previousFix),
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
@@ -28,7 +34,6 @@ export const TerminatorsAF = (
       longitude: leg.WptLon,
     }
   );
-
   const line = generateAFArc(
     arcEndCrs,
     leg.Course.toTrue({ latitude: leg.NavLat, longitude: leg.NavLon }),

browser/src/parser/terminators/CA.ts

@@ -1,60 +0,0 @@
-import * as geolib from "geolib";
-import Parser from "../parser.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
-
-export const TerminatorsCA = (
-  leg: CATerminalEntry,
-  previousFix: NavFix,
-  lastCourse: number
-): [NavFix?, LineSegment[]?] => {
-  const speed = computeSpeed(leg, previousFix);
-  const crsIntoEndpoint = leg.Course.toTrue(previousFix);
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    line = generatePerformanceArc(
-      crsIntoEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
-
-  const targetFix: NavFix = {
-    ...geolib.computeDestinationPoint(
-      arcEnd,
-      (
-        ((leg.Alt.parseAltitude() - (previousFix.altitude ?? 0)) /
-          Parser.AC_VS) *
-        ((previousFix.speed ? previousFix.speed : Parser.AC_SPEED) / 60)
-      ).toMetre(),
-      crsIntoEndpoint
-    ),
-    name: leg.Alt,
-    isFlyOver: true,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
-    speedConstraint: leg.SpeedLimit,
-    altitudeConstraint: leg.Alt,
-  };
-
-  line.push([targetFix.longitude, targetFix.latitude]);
-
-  return [targetFix, line];
-};

browser/src/parser/terminators/CD.ts

@@ -1,70 +0,0 @@
-import * as geolib from "geolib";
-import { computeSpeed } from "../utils/computeSpeed.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
-
-// NOTE: Distance not adjusted for altitude in this demo
-export const TerminatorsCD = (
-  leg: CDTerminalEntry,
-  previousFix: NavFix,
-  lastCourse: number
-): [NavFix?, LineSegment[]?] => {
-  const navaid = {
-    latitude: leg.NavLat,
-    longitude: leg.NavLon,
-  };
-  const speed = computeSpeed(leg, previousFix);
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    const crsIntoEndpoint = leg.Course.toTrue(previousFix);
-
-    line = generatePerformanceArc(
-      crsIntoEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
-
-  const crsToNavaid = geolib.getGreatCircleBearing(arcEnd, navaid);
-  const distToNavaid = geolib.getDistance(arcEnd, navaid);
-  let remainingDistance = leg.Distance.toMetre();
-  // Navaid behind us
-  if (Math.abs(crsToNavaid - lastCourse) > 90) {
-    remainingDistance -= distToNavaid;
-  }
-  // Navaid in front of us
-  else {
-    // Navaid will not be passed before distance is hit
-    if (distToNavaid > remainingDistance)
-      remainingDistance = distToNavaid - remainingDistance;
-  }
-  const targetFix: NavFix = {
-    ...geolib.computeDestinationPoint(arcEnd, remainingDistance, lastCourse),
-    name: leg.Distance.toString(),
-    isFlyOver: true,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
-    speedConstraint: leg.SpeedLimit,
-    altitudeConstraint: leg.Alt,
-  };
-
-  line.push([targetFix.longitude, targetFix.latitude]);
-
-  return [targetFix, line];
-};

browser/src/parser/terminators/CF.ts

@@ -1,5 +1,5 @@
+import Parser from "../parser.ts";
 import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
 
 export const TerminatorsCF = (
   leg: CFTerminalEntry,
@@ -7,15 +7,19 @@ export const TerminatorsCF = (
   lastCourse: number,
   waypoint?: Waypoint
 ): [NavFix?, LineSegment[]?] => {
-  const speed = computeSpeed(leg, previousFix);
-
   const targetFix: NavFix = {
     latitude: leg.WptLat,
     longitude: leg.WptLon,
     name: waypoint?.Ident ?? undefined,
     isFlyOver: leg.IsFlyOver,
     altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
@@ -26,7 +30,6 @@ export const TerminatorsCF = (
     lastCourse,
     previousFix,
     targetFix,
-    speed,
     leg.TurnDir
   );
 

browser/src/parser/terminators/CI.ts

@@ -1,6 +1,6 @@
+import Parser from "../parser.ts";
 import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
 import { computeIntersection } from "../utils/computeIntersection.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
 import { getCourseAndFixForIntercepts } from "../utils/getCourseAndFixForIntercepts.ts";
 
 export const TerminatorsCI = (
@@ -10,7 +10,6 @@ export const TerminatorsCI = (
   lastCourse: number
 ): [NavFix?, LineSegment[]?] => {
   const [crs, nextFix] = getCourseAndFixForIntercepts(nextLeg, previousFix);
-  const speed = computeSpeed(leg, previousFix);
 
   // Compute INTC
   const interceptFix: NavFix = {
@@ -22,7 +21,13 @@ export const TerminatorsCI = (
     )!,
     isFlyOver: leg.IsFlyOver,
     altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
@@ -33,7 +38,6 @@ export const TerminatorsCI = (
     lastCourse,
     previousFix,
     interceptFix,
-    speed,
     leg.TurnDir
   );
 

browser/src/parser/terminators/CR.ts

@@ -1,56 +1,42 @@
-import * as geolib from "geolib";
 import { computeIntersection } from "../utils/computeIntersection.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
+import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
+import Parser from "../parser.ts";
 
 export const TerminatorsCR = (
   leg: CRTerminalEntry,
   previousFix: NavFix,
   lastCourse: number
 ): [NavFix?, LineSegment[]?] => {
-  const navaid = {
+  const crsIntoEndpoint = leg.Course.toTrue(previousFix);
-    latitude: leg.NavLat,
-    longitude: leg.NavLon,
-  };
-  const crsFromEndpoint = leg.Course.toTrue(previousFix);
-  const crsIntoEndpoint = leg.NavBear.toTrue(navaid);
-  const speed = computeSpeed(leg, previousFix);
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    line = generatePerformanceArc(
-      crsFromEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
 
   const interceptFix: NavFix = {
-    ...computeIntersection(arcEnd, crsFromEndpoint, navaid, crsIntoEndpoint)!,
+    ...computeIntersection(
+      previousFix,
+      crsIntoEndpoint,
+      { latitude: leg.NavLat, longitude: leg.NavLon },
+      leg.NavBear.toTrue({ latitude: leg.NavLat, longitude: leg.NavLon })
+    )!,
     isFlyOver: leg.IsFlyOver,
     altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
 
-  line.push([interceptFix.longitude, interceptFix.latitude]);
+  const line = handleTurnAtFix(
+    crsIntoEndpoint,
+    leg.Course.toTrue(previousFix),
+    lastCourse,
+    previousFix,
+    interceptFix,
+    leg.TurnDir
+  );
 
   return [interceptFix, line];
 };

browser/src/parser/terminators/DF.ts

@@ -1,48 +0,0 @@
-import * as geolib from "geolib";
-import { computeSpeed } from "../utils/computeSpeed.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
-
-export const TerminatorsDF = (
-  leg: DFTerminalEntry,
-  previousFix: NavFix,
-  lastCourse: number,
-  waypoint?: Waypoint
-): [NavFix?, LineSegment[]?] => {
-  const speed = computeSpeed(leg, previousFix);
-
-  const targetFix: NavFix = {
-    latitude: leg.WptLat,
-    longitude: leg.WptLon,
-    name: waypoint?.Ident ?? undefined,
-    isFlyOver: leg.IsFlyOver,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
-    speedConstraint: leg.SpeedLimit,
-    altitudeConstraint: leg.Alt,
-  };
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    const crsIntoEndpoint = geolib.getGreatCircleBearing(
-      previousFix,
-      targetFix
-    );
-
-    line = generatePerformanceArc(
-      crsIntoEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir,
-      previousFix.latitude.equal(targetFix.latitude) &&
-        previousFix.longitude.equal(targetFix.longitude)
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  line.push([targetFix.longitude, targetFix.latitude]);
-
-  return [targetFix, line];
-};

browser/src/parser/terminators/FA.ts

@@ -1,64 +0,0 @@
-import * as geolib from "geolib";
-import { computeSpeed } from "../utils/computeSpeed.ts";
-import Parser from "../parser.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
-
-export const TerminatorsFA = (
-  leg: FATerminalEntry,
-  previousFix: NavFix,
-  lastCourse: number
-): [NavFix?, LineSegment[]?] => {
-  const refFix = {
-    latitude: leg.WptLat,
-    longitude: leg.WptLon,
-  };
-  const speed = computeSpeed(leg, previousFix);
-  const crsIntoEndpoint = leg.Course.toTrue(refFix);
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    line = generatePerformanceArc(
-      crsIntoEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
-
-  const targetFix: NavFix = {
-    ...geolib.computeDestinationPoint(
-      arcEnd,
-      (
-        ((leg.Alt.parseAltitude() - (previousFix.altitude ?? 0)) /
-          Parser.AC_VS) *
-        ((previousFix.speed ? previousFix.speed : Parser.AC_SPEED) / 60)
-      ).toMetre(),
-      crsIntoEndpoint
-    ),
-    name: leg.Alt,
-    isFlyOver: true,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
-    speedConstraint: leg.SpeedLimit,
-    altitudeConstraint: leg.Alt,
-  };
-
-  line.push([targetFix.longitude, targetFix.latitude]);
-
-  return [targetFix, line];
-};

browser/src/parser/terminators/FC.ts

@@ -1,98 +0,0 @@
-import * as geolib from "geolib";
-import { computeSpeed } from "../utils/computeSpeed.ts";
-import Parser from "../parser.ts";
-import { computeTurnRate } from "../utils/computeTurnRate.ts";
-
-// NOTE: Distance not adjusted for altitude in this demo
-export const TerminatorsFC = (
-  leg: FCTerminalEntry,
-  previousFix: NavFix,
-  lastCourse: number
-): [NavFix?, LineSegment[]?] => {
-  const refFix = {
-    latitude: leg.WptLat,
-    longitude: leg.WptLon,
-  };
-  const speed = computeSpeed(leg, previousFix);
-  const turnRate = computeTurnRate(speed, Parser.AC_BANK);
-  const trackIntoEndpoint = leg.Course.toTrue(refFix);
-
-  const line: LineSegment[] = [[previousFix.longitude, previousFix.latitude]];
-
-  if (previousFix.isFlyOver) {
-    let crsIntoEndpoint = trackIntoEndpoint;
-
-    // Check if there even is an arc
-    if (!crsIntoEndpoint.equal(lastCourse)) {
-      // Turn Dir
-      if (!leg.TurnDir || leg.TurnDir === "E") {
-        let prov = lastCourse - crsIntoEndpoint;
-        prov = prov > 180 ? prov - 360 : prov <= -180 ? prov + 360 : prov;
-        leg.TurnDir = prov > 0 ? "L" : "R";
-      }
-
-      // Generate arc
-      let condition = false;
-      do {
-        let time = 0;
-        if (leg.TurnDir === "R") {
-          const delta = (crsIntoEndpoint - lastCourse).normaliseDegrees();
-          const increment = delta < 1 ? delta : 1;
-          lastCourse = (lastCourse + increment).normaliseDegrees();
-          time = increment / turnRate;
-        } else {
-          const delta = (lastCourse - crsIntoEndpoint).normaliseDegrees();
-          const increment = delta < 1 ? delta : 1;
-          lastCourse = (lastCourse - increment).normaliseDegrees();
-          time = increment / turnRate;
-        }
-
-        const arcFix = geolib.computeDestinationPoint(
-          {
-            latitude: line.at(-1)![1],
-            longitude: line.at(-1)![0],
-          },
-          ((speed * time) / 3600).toMetre(),
-          lastCourse
-        );
-
-        line.push([arcFix.longitude, arcFix.latitude]);
-
-        if (leg.TurnDir === "R") {
-          condition = lastCourse > trackIntoEndpoint;
-        } else {
-          condition = lastCourse < trackIntoEndpoint;
-        }
-      } while (condition);
-    }
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
-
-  const targetFix: NavFix = {
-    ...geolib.computeDestinationPoint(
-      arcEnd,
-      leg.Distance.toMetre(),
-      lastCourse
-    ),
-    name: leg.Distance.toString(),
-    isFlyOver: true,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
-    speedConstraint: leg.SpeedLimit,
-    altitudeConstraint: leg.Alt,
-  };
-
-  line.push([targetFix.longitude, targetFix.latitude]);
-
-  return [targetFix, line];
-};

browser/src/parser/terminators/FD.ts

@@ -1,74 +0,0 @@
-import * as geolib from "geolib";
-import { computeSpeed } from "../utils/computeSpeed.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
-
-// NOTE: Distance not adjusted for altitude in this demo
-export const TerminatorsFD = (
-  leg: FDTerminalEntry,
-  previousFix: NavFix,
-  lastCourse: number
-): [NavFix?, LineSegment[]?] => {
-  const refFix = {
-    latitude: leg.WptLat,
-    longitude: leg.WptLon,
-  };
-  const navaid = {
-    latitude: leg.NavLat,
-    longitude: leg.NavLon,
-  };
-  const speed = computeSpeed(leg, previousFix);
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    const crsIntoEndpoint = leg.Course.toTrue(refFix);
-
-    line = generatePerformanceArc(
-      crsIntoEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
-
-  const crsToNavaid = geolib.getGreatCircleBearing(arcEnd, navaid);
-  const distToNavaid = geolib.getDistance(arcEnd, navaid);
-  let remainingDistance = leg.Distance.toMetre();
-  // Navaid behind us
-  if (Math.abs(crsToNavaid - lastCourse) > 90) {
-    remainingDistance -= distToNavaid;
-  }
-  // Navaid in front of us
-  else {
-    // Navaid will not be passed before distance is hit
-    if (distToNavaid > remainingDistance)
-      remainingDistance = distToNavaid - remainingDistance;
-  }
-  const targetFix: NavFix = {
-    ...geolib.computeDestinationPoint(arcEnd, remainingDistance, lastCourse),
-    name: leg.Distance.toString(),
-    isFlyOver: true,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
-    speedConstraint: leg.SpeedLimit,
-    altitudeConstraint: leg.Alt,
-  };
-
-  line.push([targetFix.longitude, targetFix.latitude]);
-
-  return [targetFix, line];
-};

browser/src/parser/terminators/FM.ts

@@ -1,14 +1,11 @@
 import * as geolib from "geolib";
 import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
 
 export const TerminatorsFM = (
   leg: FMTerminalEntry,
   previousFix: NavFix,
   lastCourse: number
 ): [NavFix?, LineSegment[]?] => {
-  const speed = computeSpeed(leg, previousFix);
-
   const endpoint = geolib.computeDestinationPoint(
     previousFix,
     (10).toMetre(),
@@ -21,7 +18,6 @@ export const TerminatorsFM = (
     lastCourse,
     previousFix,
     endpoint,
-    speed,
     leg.TurnDir
   );
 

browser/src/parser/terminators/IF.ts

@@ -1,19 +0,0 @@
-import Parser from "../parser.ts";
-
-export const TerminatorsIF = (
-  leg: IFTerminalEntry,
-  waypoint?: Waypoint
-): NavFix => {
-  const targetFix: NavFix = {
-    latitude: leg.WptLat,
-    longitude: leg.WptLon,
-    name: waypoint?.Ident ?? undefined,
-    isFlyOver: leg.IsFlyOver,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : 0,
-    speed: leg.SpeedLimit ? leg.SpeedLimit : Parser.AC_SPEED,
-    speedConstraint: leg.SpeedLimit,
-    altitudeConstraint: leg.Alt,
-  };
-
-  return targetFix;
-};

browser/src/parser/terminators/RF.ts

@@ -1,6 +1,6 @@
+import Parser from "../parser.ts";
 import { getCourseAndFixForIntercepts } from "../utils/getCourseAndFixForIntercepts.ts";
 import { generateRFArc } from "../pathGenerators/generateRFArc.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
 
 export const TerminatorsRF = (
   leg: RFTerminalEntry,
@@ -15,7 +15,13 @@ export const TerminatorsRF = (
     name: waypoint?.Ident ?? undefined,
     isFlyOver: leg.IsFlyOver,
     altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: computeSpeed(leg, previousFix),
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
@@ -29,7 +35,6 @@ export const TerminatorsRF = (
     { latitude: leg.CenterLat, longitude: leg.CenterLon },
     leg.TurnDir
   );
-
   line.push([targetFix.longitude, targetFix.latitude]);
 
   return [targetFix, line];

browser/src/parser/terminators/TF.ts

@@ -1,5 +1,5 @@
 import * as geolib from "geolib";
-import { computeSpeed } from "../utils/computeSpeed.ts";
+import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
 import Parser from "../parser.ts";
 
 export const TerminatorsTF = (
@@ -14,68 +14,26 @@ export const TerminatorsTF = (
     name: waypoint?.Ident ?? undefined,
     isFlyOver: leg.IsFlyOver,
     altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: computeSpeed(leg, previousFix),
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
 
-  const line: LineSegment[] = [[previousFix.longitude, previousFix.latitude]];
+  const crs = geolib.getGreatCircleBearing(previousFix, targetFix);
-
+  const line = handleTurnAtFix(
-  const trackIntoEndpoint = geolib.getGreatCircleBearing(
+    crs,
+    crs,
+    lastCourse,
     previousFix,
-    targetFix
+    targetFix,
+    leg.TurnDir
   );
 
-  if (previousFix.isFlyOver) {
-    let crsIntoEndpoint = trackIntoEndpoint;
-
-    // Check if there even is an arc
-    if (crsIntoEndpoint !== lastCourse) {
-      // Turn Dir
-      if (!leg.TurnDir || leg.TurnDir === "E") {
-        let prov = lastCourse - crsIntoEndpoint;
-        prov = prov > 180 ? prov - 360 : prov <= -180 ? prov + 360 : prov;
-        leg.TurnDir = prov > 0 ? "L" : "R";
-      }
-
-      // Generate arc
-      let condition = false;
-      do {
-        if (leg.TurnDir === "R") {
-          const delta = (crsIntoEndpoint - lastCourse).normaliseDegrees();
-          lastCourse += delta < 1 ? delta : 1;
-          lastCourse = lastCourse.normaliseDegrees();
-        } else {
-          const delta = (lastCourse - crsIntoEndpoint).normaliseDegrees();
-          lastCourse -= delta < 1 ? delta : 1;
-          lastCourse = lastCourse.normaliseDegrees();
-        }
-
-        const arcFix = geolib.computeDestinationPoint(
-          {
-            latitude: line.at(-1)![1],
-            longitude: line.at(-1)![0],
-          },
-          (
-            (previousFix.speed ? previousFix.speed : Parser.AC_SPEED) / 3600
-          ).toMetre(),
-          lastCourse
-        );
-
-        line.push([arcFix.longitude, arcFix.latitude]);
-
-        crsIntoEndpoint = geolib.getGreatCircleBearing(arcFix, targetFix);
-
-        if (leg.TurnDir === "R") {
-          condition = crsIntoEndpoint > trackIntoEndpoint;
-        } else {
-          condition = crsIntoEndpoint < trackIntoEndpoint;
-        }
-      } while (condition);
-    }
-  }
-
-  line.push([targetFix.longitude, targetFix.latitude]);
-
   return [targetFix, line];
 };

browser/src/parser/terminators/VA.ts

@@ -1,7 +1,6 @@
 import * as geolib from "geolib";
+import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
 import Parser from "../parser.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
 
 // NOTE: No wind adjustments to be made, no clue how *that* would draw
 export const TerminatorsVA = (
@@ -9,53 +8,38 @@ export const TerminatorsVA = (
   previousFix: NavFix,
   lastCourse: number
 ): [NavFix?, LineSegment[]?] => {
-  const speed = computeSpeed(leg, previousFix);
-  const crsIntoEndpoint = leg.Course.toTrue(previousFix);
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    line = generatePerformanceArc(
-      crsIntoEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
-
   const targetFix: NavFix = {
     ...geolib.computeDestinationPoint(
-      arcEnd,
+      previousFix,
       (
         ((leg.Alt.parseAltitude() - (previousFix.altitude ?? 0)) /
           Parser.AC_VS) *
-        ((previousFix.speed ? previousFix.speed : Parser.AC_SPEED) / 60)
+        (Parser.AC_SPEED / 60)
       ).toMetre(),
-      crsIntoEndpoint
+      leg.Course.toTrue(previousFix)
     ),
     name: leg.Alt,
     isFlyOver: true,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
+    altitude: leg.Alt.parseAltitude(),
-    speed: speed,
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
 
-  line.push([targetFix.longitude, targetFix.latitude]);
+  const line = handleTurnAtFix(
+    leg.Course.toTrue(previousFix),
+    leg.Course.toTrue(previousFix),
+    lastCourse,
+    previousFix,
+    targetFix,
+    leg.TurnDir
+  );
 
   return [targetFix, line];
 };

browser/src/parser/terminators/VD.ts

@@ -1,71 +1,41 @@
 import * as geolib from "geolib";
-import { computeSpeed } from "../utils/computeSpeed.ts";
+import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
+import Parser from "../parser.ts";
 
 // NOTE: No wind adjustments to be made, no clue how *that* would draw
-// NOTE: Distance not adjusted for altitude in this demo
 export const TerminatorsVD = (
   leg: VDTerminalEntry,
   previousFix: NavFix,
   lastCourse: number
 ): [NavFix?, LineSegment[]?] => {
-  const navaid = {
-    latitude: leg.NavLat,
-    longitude: leg.NavLon,
-  };
-  const speed = computeSpeed(leg, previousFix);
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    const crsIntoEndpoint = leg.Course.toTrue(previousFix);
-
-    line = generatePerformanceArc(
-      crsIntoEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
-
-  const crsToNavaid = geolib.getGreatCircleBearing(arcEnd, navaid);
-  const distToNavaid = geolib.getDistance(arcEnd, navaid);
-  let remainingDistance = leg.Distance.toMetre();
-  // Navaid behind us
-  if (Math.abs(crsToNavaid - lastCourse) > 90) {
-    remainingDistance -= distToNavaid;
-  }
-  // Navaid in front of us
-  else {
-    // Navaid will not be passed before distance is hit
-    if (distToNavaid > remainingDistance)
-      remainingDistance = distToNavaid - remainingDistance;
-  }
   const targetFix: NavFix = {
-    ...geolib.computeDestinationPoint(arcEnd, remainingDistance, lastCourse),
+    ...geolib.computeDestinationPoint(
+      previousFix,
+      leg.Distance.toMetre(),
+      leg.Course.toTrue(previousFix)
+    ),
     name: leg.Distance.toString(),
     isFlyOver: true,
     altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
 
-  line.push([targetFix.longitude, targetFix.latitude]);
+  const line = handleTurnAtFix(
+    leg.Course.toTrue(previousFix),
+    leg.Course.toTrue(previousFix),
+    lastCourse,
+    previousFix,
+    targetFix,
+    leg.TurnDir
+  );
 
   return [targetFix, line];
 };

browser/src/parser/terminators/VI.ts

@@ -1,6 +1,6 @@
+import Parser from "../parser.ts";
 import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
 import { computeIntersection } from "../utils/computeIntersection.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
 import { getCourseAndFixForIntercepts } from "../utils/getCourseAndFixForIntercepts.ts";
 
 // NOTE: No wind adjustments to be made, no clue how *that* would draw
@@ -11,7 +11,6 @@ export const TerminatorsVI = (
   lastCourse: number
 ): [NavFix?, LineSegment[]?] => {
   const [crs, nextFix] = getCourseAndFixForIntercepts(nextLeg, previousFix);
-  const speed = computeSpeed(leg, previousFix);
 
   // Compute INTC
   const interceptFix: NavFix = {
@@ -23,7 +22,13 @@ export const TerminatorsVI = (
     )!,
     isFlyOver: leg.IsFlyOver,
     altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
+    speed: leg.SpeedLimit
+      ? leg.SpeedLimit > Parser.AC_SPEED
+        ? Parser.AC_SPEED
+        : leg.SpeedLimit
+      : previousFix.speed
+      ? previousFix.speed
+      : Parser.AC_SPEED,
     speedConstraint: leg.SpeedLimit,
     altitudeConstraint: leg.Alt,
   };
@@ -34,7 +39,6 @@ export const TerminatorsVI = (
     lastCourse,
     previousFix,
     interceptFix,
-    speed,
     leg.TurnDir
   );
 

browser/src/parser/terminators/VM.ts

@@ -1,6 +1,5 @@
 import * as geolib from "geolib";
 import { handleTurnAtFix } from "../pathGenerators/handleTurnAtFix.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
 
 // NOTE: No wind adjustments to be made, no clue how *that* would draw
 export const TerminatorsVM = (
@@ -8,8 +7,6 @@ export const TerminatorsVM = (
   previousFix: NavFix,
   lastCourse: number
 ): [NavFix?, LineSegment[]?] => {
-  const speed = computeSpeed(leg, previousFix);
-
   const endpoint = geolib.computeDestinationPoint(
     previousFix,
     (10).toMetre(),
@@ -22,7 +19,6 @@ export const TerminatorsVM = (
     lastCourse,
     previousFix,
     endpoint,
-    speed,
     leg.TurnDir
   );
 

browser/src/parser/terminators/VR.ts

@@ -1,57 +0,0 @@
-import * as geolib from "geolib";
-import { computeIntersection } from "../utils/computeIntersection.ts";
-import { computeSpeed } from "../utils/computeSpeed.ts";
-import { generatePerformanceArc } from "../pathGenerators/generatePerformanceArc.ts";
-
-// NOTE: No wind adjustments to be made, no clue how *that* would draw
-export const TerminatorsVR = (
-  leg: VRTerminalEntry,
-  previousFix: NavFix,
-  lastCourse: number
-): [NavFix?, LineSegment[]?] => {
-  const navaid = {
-    latitude: leg.NavLat,
-    longitude: leg.NavLon,
-  };
-  const crsFromEndpoint = leg.Course.toTrue(previousFix);
-  const crsIntoEndpoint = leg.NavBear.toTrue(navaid);
-  const speed = computeSpeed(leg, previousFix);
-
-  let line: LineSegment[] = [];
-
-  if (previousFix.isFlyOver) {
-    line = generatePerformanceArc(
-      crsFromEndpoint,
-      lastCourse,
-      previousFix,
-      speed,
-      leg.TurnDir
-    );
-  } else {
-    line.push([previousFix.longitude, previousFix.latitude]);
-  }
-
-  const arcEnd = { latitude: line.at(-1)![1], longitude: line.at(-1)![0] };
-  if (line.length > 1) {
-    lastCourse = geolib.getGreatCircleBearing(
-      {
-        latitude: line.at(-2)![1],
-        longitude: line.at(-2)![0],
-      },
-      arcEnd
-    );
-  }
-
-  const interceptFix: NavFix = {
-    ...computeIntersection(arcEnd, crsFromEndpoint, navaid, crsIntoEndpoint)!,
-    isFlyOver: leg.IsFlyOver,
-    altitude: leg.Alt ? leg.Alt.parseAltitude() : previousFix.altitude,
-    speed: speed,
-    speedConstraint: leg.SpeedLimit,
-    altitudeConstraint: leg.Alt,
-  };
-
-  line.push([interceptFix.longitude, interceptFix.latitude]);
-
-  return [interceptFix, line];
-};

browser/src/parser/utils/computeSpeed.ts

@@ -1,12 +0,0 @@
-import Parser from "../parser.ts";
-
-export const computeSpeed = (leg: TerminalEntry, previousFix: NavFix) => {
-  if (leg.SpeedLimit) return leg.SpeedLimit;
-  if (previousFix.speed) {
-    if (previousFix.speed < Parser.AC_SPEED) return Parser.AC_SPEED;
-
-    return previousFix.speed;
-  }
-
-  return Parser.AC_SPEED;
-};

browser/src/parser/utils/computeTurnRate.ts

@@ -1,3 +0,0 @@
-export const computeTurnRate = (speed: number, bank: number) => {
-  return (1091 * Math.tan(bank.toRadians())) / speed;
-};

browser/src/parser/utils/extensions.ts

@@ -25,22 +25,7 @@ Number.prototype.toTrue = function (fix) {
 Number.prototype.toMetre = function () {
   return (this as number) * 1852.0;
 };
-Number.prototype.equal = function (other: number) {
-  return Math.abs((this as number) - other) < 0.1;
-};
 
 String.prototype.parseAltitude = function () {
-  switch (this.length) {
+  return Number.parseInt(this.substring(0, 5));
-    case 5:
-      return Number.parseInt(this as string);
-    case 6:
-      return Number.parseInt(this.substring(0, 5));
-    case 12: {
-      const upper = Number.parseInt(this.substring(0, 5));
-      const lower = Number.parseInt(this.substring(6, 12));
-      return lower + (upper - lower) / 2;
-    }
-    default:
-      return -1;
-  }
 };

browser/src/types/extensions.d.ts

@@ -25,10 +25,6 @@ export declare global {
      * @returns Value converted from nmi to metres
      */
     toMetre: () => number;
-    /**
-     * @returns True if delta is less than 0.1
-     */
-    equal: (other: number) => boolean;
   }
 
   interface String {

browser/src/types/terminators/CA.d.ts

@@ -1,4 +0,0 @@
-export declare global {
-  type CATerminalEntry = Required<Pick<TerminalEntry, "Course" | "Alt">> &
-    TerminalEntry;
-}

browser/src/types/terminators/CD.d.ts

@@ -1,6 +0,0 @@
-export declare global {
-  type CDTerminalEntry = Required<
-    Pick<TerminalEntry, "NavID" | "NavLat" | "NavLon" | "Course" | "Distance">
-  > &
-    TerminalEntry;
-}

browser/src/types/terminators/DF.d.ts

@@ -1,6 +0,0 @@
-export declare global {
-  type DFTerminalEntry = Required<
-    Pick<TerminalEntry, "WptID" | "WptLat" | "WptLon" | "IsFlyOver">
-  > &
-    TerminalEntry;
-}

browser/src/types/terminators/FA.d.ts

@@ -1,18 +0,0 @@
-export declare global {
-  type FATerminalEntry = Required<
-    Pick<
-      TerminalEntry,
-      | "WptID"
-      | "WptLat"
-      | "WptLon"
-      | "NavID"
-      | "NavLat"
-      | "NavLon"
-      | "NavBear"
-      | "NavDist"
-      | "Course"
-      | "Alt"
-    >
-  > &
-    TerminalEntry;
-}

browser/src/types/terminators/FC.d.ts

@@ -1,19 +0,0 @@
-export declare global {
-  type FCTerminalEntry = Required<
-    Pick<
-      TerminalEntry,
-      | "WptID"
-      | "WptLat"
-      | "WptLon"
-      | "IsFlyOver"
-      | "NavID"
-      | "NavLat"
-      | "NavLon"
-      | "NavBear"
-      | "NavDist"
-      | "Course"
-      | "Distance"
-    >
-  > &
-    TerminalEntry;
-}

browser/src/types/terminators/FD.d.ts

@@ -1,18 +0,0 @@
-export declare global {
-  type FDTerminalEntry = Required<
-    Pick<
-      TerminalEntry,
-      | "WptID"
-      | "WptLat"
-      | "WptLon"
-      | "NavID"
-      | "NavLat"
-      | "NavLon"
-      | "NavBear"
-      | "NavDist"
-      | "Course"
-      | "Distance"
-    >
-  > &
-    TerminalEntry;
-}

browser/src/types/terminators/IF.d.ts

@@ -1,6 +0,0 @@
-export declare global {
-  type IFTerminalEntry = Required<
-    Pick<TerminalEntry, "WptID" | "WptLat" | "WptLon">
-  > &
-    TerminalEntry;
-}

browser/src/types/terminators/VR.d.ts

@@ -1,6 +0,0 @@
-export declare global {
-  type VRTerminalEntry = Required<
-    Pick<TerminalEntry, "NavID" | "NavLat" | "NavLon" | "NavBear" | "Course">
-  > &
-    TerminalEntry;
-}