@airframes/acars-decoder 1.6.9 → 1.6.11

package/dist/index.mjs

@@ -60,6 +60,271 @@ var DecoderPlugin = class {
   }
 };
 
+// lib/utils/coordinate_utils.ts
+var CoordinateUtils = class {
+  /**
+   * Decode a string of coordinates into an object with latitude and longitude in millidegrees
+   * @param stringCoords - The string of coordinates to decode
+   * 
+   * @returns An object with latitude and longitude properties
+   */
+  static decodeStringCoordinates(stringCoords) {
+    var results = {};
+    const firstChar = stringCoords.substring(0, 1);
+    let middleChar = stringCoords.substring(6, 7);
+    let longitudeChars = stringCoords.substring(7, 13);
+    if (middleChar == " ") {
+      middleChar = stringCoords.substring(7, 8);
+      longitudeChars = stringCoords.substring(8, 14);
+    }
+    if ((firstChar === "N" || firstChar === "S") && (middleChar === "W" || middleChar === "E")) {
+      results.latitude = Number(stringCoords.substring(1, 6)) / 1e3 * (firstChar === "S" ? -1 : 1);
+      results.longitude = Number(longitudeChars) / 1e3 * (middleChar === "W" ? -1 : 1);
+    } else {
+      return;
+    }
+    return results;
+  }
+  /**
+  * Decode a string of coordinates into an object with latitude and longitude in degrees and decimal minutes
+  * @param stringCoords - The string of coordinates to decode
+  * 
+  * @returns An object with latitude and longitude properties
+  */
+  static decodeStringCoordinatesDecimalMinutes(stringCoords) {
+    var results = {};
+    const firstChar = stringCoords.substring(0, 1);
+    let middleChar = stringCoords.substring(6, 7);
+    let longitudeChars = stringCoords.substring(7, 13);
+    if (middleChar == " ") {
+      middleChar = stringCoords.substring(7, 8);
+      longitudeChars = stringCoords.substring(8, 14);
+    }
+    const latDeg = Math.trunc(Number(stringCoords.substring(1, 6)) / 1e3);
+    const latMin = Number(stringCoords.substring(1, 6)) % 1e3 / 10;
+    const lonDeg = Math.trunc(Number(longitudeChars) / 1e3);
+    const lonMin = Number(longitudeChars) % 1e3 / 10;
+    if ((firstChar === "N" || firstChar === "S") && (middleChar === "W" || middleChar === "E")) {
+      results.latitude = (latDeg + latMin / 60) * (firstChar === "S" ? -1 : 1);
+      results.longitude = (lonDeg + lonMin / 60) * (middleChar === "W" ? -1 : 1);
+    } else {
+      return;
+    }
+    return results;
+  }
+  static coordinateString(coords) {
+    const latDir = coords.latitude > 0 ? "N" : "S";
+    const lonDir = coords.longitude > 0 ? "E" : "W";
+    return `${Math.abs(coords.latitude).toFixed(3)} ${latDir}, ${Math.abs(coords.longitude).toFixed(3)} ${lonDir}`;
+  }
+  static getDirection(coord) {
+    if (coord.startsWith("N") || coord.startsWith("E")) {
+      return 1;
+    } else if (coord.startsWith("S") || coord.startsWith("W")) {
+      return -1;
+    }
+    return NaN;
+  }
+  static dmsToDecimalDegrees(degrees, minutes, seconds) {
+    return degrees + minutes / 60 + seconds / 3600;
+  }
+};
+
+// lib/utils/result_formatter.ts
+var ResultFormatter = class {
+  static position(decodeResult, value) {
+    decodeResult.raw.position = value;
+    decodeResult.formatted.items.push({
+      type: "aircraft_position",
+      code: "POS",
+      label: "Aircraft Position",
+      value: CoordinateUtils.coordinateString(value)
+    });
+  }
+  static altitude(decodeResult, value) {
+    decodeResult.raw.altitude = value;
+    decodeResult.formatted.items.push({
+      type: "altitude",
+      code: "ALT",
+      label: "Altitude",
+      value: `${decodeResult.raw.altitude} feet`
+    });
+  }
+  static flightNumber(decodeResult, value) {
+    decodeResult.raw.flight_number = value;
+  }
+  static departureAirport(decodeResult, value) {
+    decodeResult.raw.departure_icao = value;
+    decodeResult.formatted.items.push({
+      type: "origin",
+      code: "ORG",
+      label: "Origin",
+      value: decodeResult.raw.departure_icao
+    });
+  }
+  static departureRunway(decodeResult, value) {
+    decodeResult.raw.departure_runway = value;
+    decodeResult.formatted.items.push({
+      type: "runway",
+      code: "DEPRWY",
+      label: "Departure Runway",
+      value: decodeResult.raw.departure_runway
+    });
+  }
+  static arrivalAirport(decodeResult, value) {
+    decodeResult.raw.arrival_icao = value;
+    decodeResult.formatted.items.push({
+      type: "destination",
+      code: "DST",
+      label: "Destination",
+      value: decodeResult.raw.arrival_icao
+    });
+  }
+  static alternateAirport(decodeResult, value) {
+    decodeResult.raw.alternate_icao = value;
+    decodeResult.formatted.items.push({
+      type: "destination",
+      code: "ALT_DST",
+      label: "Alternate Destination",
+      value: decodeResult.raw.alternate_icao
+    });
+  }
+  // FIXME - make seconds since midnight for time of day
+  static eta(decodeResult, value) {
+    decodeResult.raw.eta_time = value;
+    decodeResult.formatted.items.push({
+      type: "eta",
+      code: "ETA",
+      label: "Estimated Time of Arrival",
+      value: value.substring(0, 2) + ":" + value.substring(2, 4) + ":" + value.substring(4, 6)
+    });
+  }
+  static arrivalRunway(decodeResult, value) {
+    decodeResult.raw.arrival_runway = value;
+    decodeResult.formatted.items.push({
+      type: "runway",
+      code: "ARWY",
+      label: "Arrival Runway",
+      value: decodeResult.raw.arrival_runway
+    });
+  }
+  static alternateRunway(decodeResult, value) {
+    decodeResult.raw.alternate_runway = value;
+    decodeResult.formatted.items.push({
+      type: "runway",
+      code: "ALT_ARWY",
+      label: "Alternate Runway",
+      value: decodeResult.raw.alternate_runway
+    });
+  }
+  static currentFuel(decodeResult, value) {
+    decodeResult.raw.fuel_on_board = value;
+    decodeResult.formatted.items.push({
+      type: "fuel_on_board",
+      code: "FOB",
+      label: "Fuel On Board",
+      value: decodeResult.raw.fuel_on_board.toString()
+    });
+  }
+  static remainingFuel(decodeResult, value) {
+    decodeResult.raw.fuel_remaining = value;
+    decodeResult.formatted.items.push({
+      type: "fuel_remaining",
+      code: "FUEL",
+      label: "Fuel Remaining",
+      value: decodeResult.raw.fuel_remaining.toString()
+    });
+  }
+  static checksum(decodeResult, value) {
+    decodeResult.raw.checksum = Number("0x" + value);
+    decodeResult.formatted.items.push({
+      type: "message_checksum",
+      code: "CHECKSUM",
+      label: "Message Checksum",
+      value: "0x" + ("0000" + decodeResult.raw.checksum.toString(16)).slice(-4)
+    });
+  }
+  static groundspeed(decodeResult, value) {
+    decodeResult.raw.groundspeed = value;
+    decodeResult.formatted.items.push({
+      type: "aircraft_groundspeed",
+      code: "GSPD",
+      label: "Aircraft Groundspeed",
+      value: `${decodeResult.raw.groundspeed} knots`
+    });
+  }
+  static temperature(decodeResult, value) {
+    decodeResult.raw.outside_air_temperature = Number(value.substring(1)) * (value.charAt(0) === "M" ? -1 : 1);
+    decodeResult.formatted.items.push({
+      type: "outside_air_temperature",
+      code: "OATEMP",
+      label: "Outside Air Temperature (C)",
+      value: `${decodeResult.raw.outside_air_temperature}`
+    });
+  }
+  static heading(decodeResult, value) {
+    decodeResult.raw.heading = value;
+    decodeResult.formatted.items.push({
+      type: "heading",
+      code: "HDG",
+      label: "Heading",
+      value: `${decodeResult.raw.heading}`
+    });
+  }
+  static tail(decodeResult, value) {
+    decodeResult.raw.tail = value;
+    decodeResult.formatted.items.push({
+      type: "tail",
+      code: "TAIL",
+      label: "Tail",
+      value: decodeResult.raw.tail
+    });
+  }
+  static out(decodeResult, time) {
+    decodeResult.raw.out_time = time;
+    const date = new Date(time * 1e3);
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "OUT",
+      label: "Out of Gate Time",
+      value: date.toISOString().slice(11, 19)
+    });
+  }
+  static off(decodeResult, time) {
+    decodeResult.raw.off_time = time;
+    const date = new Date(time * 1e3);
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "OFF",
+      label: "Takeoff Time",
+      value: date.toISOString().slice(11, 19)
+    });
+  }
+  static on(decodeResult, time) {
+    decodeResult.raw.on_time = time;
+    const date = new Date(time * 1e3);
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "ON",
+      label: "Landing Time",
+      value: date.toISOString().slice(11, 19)
+    });
+  }
+  static in(decodeResult, time) {
+    decodeResult.raw.in_time = time;
+    const date = new Date(time * 1e3);
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "IN",
+      label: "In Gate Time",
+      value: date.toISOString().slice(11, 19)
+    });
+  }
+  static unknown(decodeResult, value) {
+    decodeResult.remaining.text += "," + value;
+  }
+};
+
 // lib/plugins/Label_5Z.ts
 var Label_5Z = class extends DecoderPlugin {
   name = "label-5z";
@@ -119,34 +384,9 @@ var Label_5Z = class extends DecoderPlugin {
         const rdcRegex = /^(?<from>\w\w\w)(?<to>\w\w\w) (?<unknown1>\d\d) R(?<runway>.+) G(?<unknown2>.+)$/;
         results = remainder.match(rdcRegex);
         if (results) {
-          decodeResult.raw.origin = results.groups.from;
-          decodeResult.formatted.items.push({
-            type: "origin",
-            label: "Origin",
-            value: `${results.groups.from}`
-          });
-          decodeResult.raw.destination = results.groups.to;
-          decodeResult.formatted.items.push({
-            type: "destination",
-            label: "Destination",
-            value: `${results.groups.to}`
-          });
-          decodeResult.formatted.items.push({
-            type: "unknown1",
-            label: "Unknown Field 1",
-            value: `${results.groups.unknown1}`
-          });
-          decodeResult.raw.runway = results.groups.runway;
-          decodeResult.formatted.items.push({
-            type: "runway",
-            label: "Runway",
-            value: `${results.groups.runway}`
-          });
-          decodeResult.formatted.items.push({
-            type: "unknown2",
-            label: "Unknown Field 2",
-            value: `${results.groups.unknown2}`
-          });
+          ResultFormatter.departureAirport(decodeResult, results.groups.from);
+          ResultFormatter.arrivalAirport(decodeResult, results.groups.to);
+          ResultFormatter.arrivalRunway(decodeResult, results.groups.runway);
         } else {
           if (options.debug) {
             console.log(`Decoder: Unkown 5Z RDC format: ${remainder}`);
@@ -169,62 +409,278 @@ var Label_5Z = class extends DecoderPlugin {
   }
 };
 
-// lib/utils/coordinate_utils.ts
-var CoordinateUtils = class {
+// lib/plugins/Label_10_LDR.ts
+var Label_10_LDR = class extends DecoderPlugin {
+  // eslint-disable-line camelcase
+  name = "label-10-ldr";
+  qualifiers() {
+    return {
+      labels: ["10"],
+      preambles: ["LDR"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "Position Report";
+    decodeResult.message = message;
+    const parts = message.text.split(",");
+    if (parts.length < 17) {
+      if (options.debug) {
+        console.log(`Decoder: Unknown 10 message: ${message.text}`);
+      }
+      decodeResult.remaining.text = message.text;
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+      return decodeResult;
+    }
+    const lat = parts[5];
+    const lon = parts[6];
+    const position = {
+      latitude: (lat[0] === "N" ? 1 : -1) * Number(lat.substring(1).trim()),
+      longitude: (lon[0] === "E" ? 1 : -1) * Number(lon.substring(1).trim())
+    };
+    ResultFormatter.position(decodeResult, position);
+    ResultFormatter.altitude(decodeResult, Number(parts[7]));
+    ResultFormatter.departureAirport(decodeResult, parts[9]);
+    ResultFormatter.arrivalAirport(decodeResult, parts[10]);
+    ResultFormatter.alternateAirport(decodeResult, parts[11]);
+    ResultFormatter.arrivalRunway(decodeResult, parts[12].split("/")[0]);
+    const altRwy = [parts[13].split("/")[0], parts[14].split("/")[0]].filter((r) => r != "").join(",");
+    if (altRwy != "") {
+      ResultFormatter.alternateRunway(decodeResult, altRwy);
+    }
+    decodeResult.remaining.text = [...parts.slice(0, 5), ...parts.slice(15)].join(",");
+    decodeResult.decoded = true;
+    decodeResult.decoder.decodeLevel = "partial";
+    return decodeResult;
+  }
+};
+
+// lib/plugins/Label_10_POS.ts
+var Label_10_POS = class extends DecoderPlugin {
+  // eslint-disable-line camelcase
+  name = "label-10-pos";
+  qualifiers() {
+    return {
+      labels: ["10"],
+      preambles: ["POS"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "Position Report";
+    decodeResult.message = message;
+    const parts = message.text.split(",");
+    if (parts.length !== 12) {
+      if (options.debug) {
+        console.log(`Decoder: Unknown 10 message: ${message.text}`);
+      }
+      decodeResult.remaining.text = message.text;
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+      return decodeResult;
+    }
+    const lat = parts[1].trim();
+    const lon = parts[2].trim();
+    const position = {
+      latitude: (lat[0] === "N" ? 1 : -1) * Number(lat.substring(1).trim()) / 100,
+      longitude: (lon[0] === "E" ? 1 : -1) * Number(lon.substring(1).trim()) / 100
+    };
+    ResultFormatter.position(decodeResult, position);
+    ResultFormatter.altitude(decodeResult, Number(parts[7]));
+    decodeResult.remaining.text = [parts[0], ...parts.slice(3, 7), ...parts.slice(8)].join(",");
+    decodeResult.decoded = true;
+    decodeResult.decoder.decodeLevel = "partial";
+    return decodeResult;
+  }
+};
+
+// lib/DateTimeUtils.ts
+var DateTimeUtils = class {
+  // Expects a four digit UTC time string (HHMM)
+  static UTCToString(UTCString) {
+    let utcDate = /* @__PURE__ */ new Date();
+    utcDate.setUTCHours(+UTCString.substr(0, 2), +UTCString.substr(2, 2), 0);
+    return utcDate.toTimeString();
+  }
+  // Expects a six digit date string and a four digit UTC time string
+  // (DDMMYY) (HHMM)
+  static UTCDateTimeToString(dateString, timeString) {
+    let utcDate = /* @__PURE__ */ new Date();
+    utcDate.setUTCDate(+dateString.substr(0, 2));
+    utcDate.setUTCMonth(+dateString.substr(2, 2));
+    if (dateString.length === 6) {
+      utcDate.setUTCFullYear(2e3 + +dateString.substr(4, 2));
+    }
+    if (timeString.length === 6) {
+      utcDate.setUTCHours(+timeString.substr(0, 2), +timeString.substr(2, 2), +timeString.substr(4, 2));
+    } else {
+      utcDate.setUTCHours(+timeString.substr(0, 2), +timeString.substr(2, 2), 0);
+    }
+    return utcDate.toUTCString();
+  }
   /**
-   * Decode a string of coordinates into an object with latitude and longitude in millidegrees
-   * @param stringCoords - The string of coordinates to decode
    * 
-   * @returns An object with latitude and longitude properties
+   * @param time HHMMSS
+   * @returns seconds since midnight
    */
-  static decodeStringCoordinates(stringCoords) {
-    var results = {};
-    const firstChar = stringCoords.substring(0, 1);
-    let middleChar = stringCoords.substring(6, 7);
-    let longitudeChars = stringCoords.substring(7, 13);
-    if (middleChar == " ") {
-      middleChar = stringCoords.substring(7, 8);
-      longitudeChars = stringCoords.substring(8, 14);
+  static convertHHMMSSToTod(time) {
+    const h = Number(time.substring(0, 2));
+    const m = Number(time.substring(2, 4));
+    const s = Number(time.substring(4, 6));
+    const tod = h * 3600 + m * 60 + s;
+    return tod;
+  }
+  /**
+   * 
+   * @param time HHMMSS
+   * @param date MMDDYY or MMDDYYYY
+   * @returns seconds since epoch
+   */
+  static convertDateTimeToEpoch(time, date) {
+    if (date.length === 6) {
+      date = date.substring(0, 4) + `20${date.substring(4, 6)}`;
     }
-    if ((firstChar === "N" || firstChar === "S") && (middleChar === "W" || middleChar === "E")) {
-      results.latitude = Number(stringCoords.substring(1, 6)) / 1e3 * (firstChar === "S" ? -1 : 1);
-      results.longitude = Number(longitudeChars) / 1e3 * (middleChar === "W" ? -1 : 1);
-    } else {
-      return;
+    const timestamp = `${date.substring(4, 8)}-${date.substring(0, 2)}-${date.substring(2, 4)}T${time.substring(0, 2)}:${time.substring(2, 4)}:${time.substring(4, 6)}.000Z`;
+    const millis = Date.parse(timestamp);
+    return millis / 1e3;
+  }
+};
+
+// lib/utils/route_utils.ts
+var RouteUtils = class _RouteUtils {
+  static routeToString(route) {
+    let str = "";
+    if (route.name) {
+      str += route.name;
+    }
+    if (route.runway) {
+      str += `(${route.runway})`;
+    }
+    if (str.length !== 0 && route.waypoints && route.waypoints.length === 1) {
+      str += " starting at ";
+    } else if (str.length !== 0 && route.waypoints) {
+      str += ": ";
+    }
+    if (route.waypoints) {
+      str += _RouteUtils.waypointsToString(route.waypoints);
+    }
+    return str;
+  }
+  static waypointToString(waypoint) {
+    let s = waypoint.name;
+    if (waypoint.latitude && waypoint.longitude) {
+      s += `(${CoordinateUtils.coordinateString({ latitude: waypoint.latitude, longitude: waypoint.longitude })})`;
+    }
+    if (waypoint.offset) {
+      s += `[${waypoint.offset.bearing}\xB0 ${waypoint.offset.distance}nm]`;
+    }
+    if (waypoint.time && waypoint.timeFormat) {
+      s += `@${_RouteUtils.timestampToString(waypoint.time, waypoint.timeFormat)}`;
+    }
+    return s;
+  }
+  static getWaypoint(leg) {
+    const regex = leg.match(/^([A-Z]+)(\d{3})-(\d{4})$/);
+    if (regex?.length == 4) {
+      return { name: regex[1], offset: { bearing: parseInt(regex[2]), distance: parseInt(regex[3]) / 10 } };
+    }
+    const waypoint = leg.split(",");
+    if (waypoint.length == 2) {
+      const position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(waypoint[1]);
+      if (position) {
+        return { name: waypoint[0], latitude: position.latitude, longitude: position.longitude };
+      }
+    }
+    if (leg.length == 13 || leg.length == 14) {
+      const position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(leg);
+      const name = waypoint.length == 2 ? waypoint[0] : "";
+      if (position) {
+        return { name, latitude: position.latitude, longitude: position.longitude };
+      }
+    }
+    return { name: leg };
+  }
+  // move out if we want public
+  static timestampToString(time, format) {
+    const date = new Date(time * 1e3);
+    if (format == "tod") {
+      return date.toISOString().slice(11, 19);
+    }
+    return date.toISOString().slice(0, -5) + "Z";
+  }
+  static waypointsToString(waypoints) {
+    let str = waypoints.map((x) => _RouteUtils.waypointToString(x)).join(" > ").replaceAll(">  >", ">>");
+    if (str.startsWith(" > ")) {
+      str = ">>" + str.slice(2);
     }
-    return results;
+    return str;
   }
-  /**
-  * Decode a string of coordinates into an object with latitude and longitude in degrees and decimal minutes
-  * @param stringCoords - The string of coordinates to decode
-  * 
-  * @returns An object with latitude and longitude properties
-  */
-  static decodeStringCoordinatesDecimalMinutes(stringCoords) {
-    var results = {};
-    const firstChar = stringCoords.substring(0, 1);
-    let middleChar = stringCoords.substring(6, 7);
-    let longitudeChars = stringCoords.substring(7, 13);
-    if (middleChar == " ") {
-      middleChar = stringCoords.substring(7, 8);
-      longitudeChars = stringCoords.substring(8, 14);
+};
+
+// lib/plugins/Label_10_Slash.ts
+var Label_10_Slash = class extends DecoderPlugin {
+  // eslint-disable-line camelcase
+  name = "label-10-slash";
+  qualifiers() {
+    return {
+      labels: ["10"],
+      preambles: ["/"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "Position Report";
+    decodeResult.message = message;
+    const parts = message.text.split("/");
+    if (parts.length < 17) {
+      if (options.debug) {
+        console.log(`Decoder: Unknown 10 message: ${message.text}`);
+      }
+      decodeResult.remaining.text = message.text;
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+      return decodeResult;
     }
-    const latDeg = Math.trunc(Number(stringCoords.substring(1, 6)) / 1e3);
-    const latMin = Number(stringCoords.substring(1, 6)) % 1e3 / 10;
-    const lonDeg = Math.trunc(Number(longitudeChars) / 1e3);
-    const lonMin = Number(longitudeChars) % 1e3 / 10;
-    if ((firstChar === "N" || firstChar === "S") && (middleChar === "W" || middleChar === "E")) {
-      results.latitude = (latDeg + latMin / 60) * (firstChar === "S" ? -1 : 1);
-      results.longitude = (lonDeg + lonMin / 60) * (middleChar === "W" ? -1 : 1);
-    } else {
-      return;
+    const lat = parts[1];
+    const lon = parts[2];
+    const position = {
+      latitude: (lat[0] === "N" ? 1 : -1) * Number(lat.substring(1)),
+      longitude: (lon[0] === "E" ? 1 : -1) * Number(lon.substring(1))
+    };
+    ResultFormatter.position(decodeResult, position);
+    ResultFormatter.heading(decodeResult, Number(parts[5]));
+    ResultFormatter.altitude(decodeResult, 100 * Number(parts[6]));
+    ResultFormatter.arrivalAirport(decodeResult, parts[7]);
+    ResultFormatter.eta(decodeResult, parts[8] + "00");
+    const waypoints = [{
+      name: parts[11]
+    }, {
+      name: parts[12],
+      time: DateTimeUtils.convertHHMMSSToTod(parts[13] + "00"),
+      timeFormat: "tod"
+    }, {
+      name: parts[14],
+      time: DateTimeUtils.convertHHMMSSToTod(parts[15] + "00"),
+      timeFormat: "tod"
+    }];
+    decodeResult.raw.route = { waypoints };
+    decodeResult.formatted.items.push({
+      type: "aircraft_route",
+      code: "ROUTE",
+      label: "Aircraft Route",
+      value: RouteUtils.routeToString(decodeResult.raw.route)
+    });
+    if (parts[16]) {
+      ResultFormatter.departureAirport(decodeResult, parts[16]);
     }
-    return results;
-  }
-  static coordinateString(coords) {
-    const latDir = coords.latitude > 0 ? "N" : "S";
-    const lonDir = coords.longitude > 0 ? "E" : "W";
-    return `${Math.abs(coords.latitude).toFixed(3)} ${latDir}, ${Math.abs(coords.longitude).toFixed(3)} ${lonDir}`;
+    decodeResult.remaining.text = [parts[3], parts[4], ...parts.slice(9, 11), ...parts.slice(17)].join("/");
+    decodeResult.decoded = true;
+    decodeResult.decoder.decodeLevel = "partial";
+    return decodeResult;
   }
 };
 
@@ -253,19 +709,14 @@ var Label_12_N_Space = class extends DecoderPlugin {
         latitude: Number(results.groups.lat_coord) * (results.groups.lat == "N" ? 1 : -1),
         longitude: Number(results.groups.long_coord) * (results.groups.long == "E" ? 1 : -1)
       };
-      decodeResult.raw.flight_level = results.groups.alt == "GRD" || results.groups.alt == "***" ? "0" : Number(results.groups.alt);
+      const altitude = results.groups.alt == "GRD" || results.groups.alt == "***" ? 0 : Number(results.groups.alt);
       decodeResult.formatted.items.push({
         type: "aircraft_position",
         code: "POS",
         label: "Aircraft Position",
         value: CoordinateUtils.coordinateString(decodeResult.raw.position)
       });
-      decodeResult.formatted.items.push({
-        type: "flight_level",
-        code: "FL",
-        label: "Flight Level",
-        value: decodeResult.raw.flight_level
-      });
+      ResultFormatter.altitude(decodeResult, altitude);
       decodeResult.remaining.text = `,${results.groups.unkwn1} ,${results.groups.unkwn2}, ${results.groups.unkwn3}`;
       decodeResult.decoded = true;
       decodeResult.decoder.decodeLevel = "partial";
@@ -281,6 +732,97 @@ var Label_12_N_Space = class extends DecoderPlugin {
   }
 };
 
+// lib/plugins/Label_13Through18_Slash.ts
+var Label_13Through18_Slash = class extends DecoderPlugin {
+  // eslint-disable-line camelcase
+  name = "label-13-18-slash";
+  qualifiers() {
+    return {
+      labels: ["13", "14", "15", "16", "17", "18"],
+      preambles: ["/"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    const lines = message.text.split("\r\n");
+    const parts = lines[0].split("/");
+    const labelNumber = Number(parts[1].substring(0, 2));
+    decodeResult.formatted.description = getMsgType(labelNumber);
+    if (labelNumber !== 18 && parts.length !== 4 || labelNumber === 18 && parts.length !== 7) {
+      if (options?.debug) {
+        console.log(`Decoder: Unknown OOOI message: ${message.text}`);
+      }
+      decodeResult.remaining.text = message.text;
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+      return decodeResult;
+    }
+    decodeResult.remaining.text = "";
+    const data = parts[2].split(" ");
+    ResultFormatter.departureAirport(decodeResult, data[1]);
+    ResultFormatter.arrivalAirport(decodeResult, data[2]);
+    decodeResult.raw.day_of_month = Number(data[3]);
+    const time = DateTimeUtils.convertHHMMSSToTod(data[4]);
+    if (labelNumber === 13) {
+      ResultFormatter.out(decodeResult, time);
+    } else if (labelNumber === 14) {
+      ResultFormatter.off(decodeResult, time);
+    } else if (labelNumber === 15) {
+      ResultFormatter.on(decodeResult, time);
+    } else if (labelNumber === 16) {
+      ResultFormatter.in(decodeResult, time);
+    }
+    if (parts.length === 7) {
+      decodeResult.remaining.text += parts.slice(4).join("/");
+    }
+    for (let i = 1; i < lines.length; i++) {
+      if (lines[i].startsWith("/LOC")) {
+        const location = lines[i].substring(5).split(",");
+        let position;
+        if (location[0].startsWith("+") || location[0].startsWith("-")) {
+          position = { latitude: Number(location[0]), longitude: Number(location[1]) };
+        } else {
+          position = {
+            latitude: CoordinateUtils.getDirection(location[0][0]) * CoordinateUtils.dmsToDecimalDegrees(Number(location[0].substring(1, 3)), Number(location[0].substring(3, 5)), Number(location[0].substring(5, 7))),
+            longitude: CoordinateUtils.getDirection(location[1][0]) * CoordinateUtils.dmsToDecimalDegrees(Number(location[1].substring(1, 4)), Number(location[1].substring(4, 6)), Number(location[1].substring(6, 8)))
+          };
+        }
+        if (!isNaN(position.latitude) && !isNaN(position.longitude)) {
+          ResultFormatter.position(decodeResult, position);
+        }
+      } else {
+        decodeResult.remaining.text += "\r\n" + lines[i];
+      }
+    }
+    decodeResult.decoded = true;
+    decodeResult.decoder.decodeLevel = decodeResult.remaining.text ? "partial" : "full";
+    return decodeResult;
+  }
+};
+function getMsgType(labelNumber) {
+  if (labelNumber === 13) {
+    return "Out of Gate Report";
+  }
+  if (labelNumber === 14) {
+    return "Takeoff Report";
+  }
+  if (labelNumber === 15) {
+    return "On Ground Report";
+  }
+  if (labelNumber === 16) {
+    return "In Gate Report";
+  }
+  if (labelNumber === 17) {
+    return "Post Report";
+  }
+  if (labelNumber === 18) {
+    return "Post Times Report";
+  }
+  return "Unknown";
+}
+
 // lib/plugins/Label_15.ts
 var Label_15 = class extends DecoderPlugin {
   name = "label-5z";
@@ -327,39 +869,35 @@ var Label_15_FST = class extends DecoderPlugin {
     decodeResult.decoder.name = this.name;
     decodeResult.formatted.description = "Position Report";
     decodeResult.message = message;
-    decodeResult.raw.departure_icao = message.text.substring(5, 9);
-    decodeResult.raw.arrival_icao = message.text.substring(9, 13);
-    const stringCoords = message.text.substring(13);
+    const parts = message.text.split(" ");
+    const header = parts[0];
+    decodeResult.raw.departure_icao = header.substring(5, 9);
+    decodeResult.raw.arrival_icao = header.substring(9, 13);
+    const stringCoords = header.substring(13);
     const firstChar = stringCoords.substring(0, 1);
     const middleChar = stringCoords.substring(7, 8);
     decodeResult.raw.position = {};
     if ((firstChar === "N" || firstChar === "S") && (middleChar === "W" || middleChar === "E")) {
       decodeResult.raw.position.latitude = Number(stringCoords.substring(1, 7)) / 1e4 * (firstChar === "S" ? -1 : 1);
-      decodeResult.raw.position.longitude = Number(stringCoords.substring(8, 26)) / 1e5 * (middleChar === "W" ? -1 : 1);
+      decodeResult.raw.position.longitude = Number(stringCoords.substring(8, 15)) / 1e4 * (middleChar === "W" ? -1 : 1);
+      decodeResult.raw.altitude = Number(stringCoords.substring(15)) * 100;
     } else {
       decodeResult.decoded = false;
       decodeResult.decoder.decodeLevel = "none";
       return decodeResult;
     }
     decodeResult.formatted.items.push({
-      type: "position",
-      label: "Position",
+      type: "aircraft_position",
+      code: "POS",
+      label: "Aircraft Position",
       value: CoordinateUtils.coordinateString(decodeResult.raw.position)
     });
-    decodeResult.formatted.items.push({
-      type: "origin",
-      code: "ORG",
-      label: "Origin",
-      value: decodeResult.raw.departure_icao
-    });
-    decodeResult.formatted.items.push({
-      type: "destination",
-      code: "DST",
-      label: "Destination",
-      value: decodeResult.raw.arrival_icao
-    });
+    ResultFormatter.altitude(decodeResult, decodeResult.raw.altitude);
+    ResultFormatter.departureAirport(decodeResult, decodeResult.raw.departure_icao);
+    ResultFormatter.arrivalAirport(decodeResult, decodeResult.raw.arrival_icao);
+    decodeResult.remaining.text = parts.slice(1).join(" ");
     decodeResult.decoded = true;
-    decodeResult.decoder.decodeLevel = "full";
+    decodeResult.decoder.decodeLevel = "partial";
     return decodeResult;
   }
 };
@@ -390,19 +928,14 @@ var Label_16_N_Space = class extends DecoderPlugin {
         latitude: Number(results.groups.lat_coord) * (results.groups.lat == "N" ? 1 : -1),
         longitude: Number(results.groups.long_coord) * (results.groups.long == "E" ? 1 : -1)
       };
-      decodeResult.raw.flight_level = results.groups.alt == "GRD" || results.groups.alt == "***" ? "0" : Number(results.groups.alt);
+      const altitude = results.groups.alt == "GRD" || results.groups.alt == "***" ? 0 : Number(results.groups.alt);
       decodeResult.formatted.items.push({
         type: "aircraft_position",
         code: "POS",
         label: "Aircraft Position",
         value: CoordinateUtils.coordinateString(decodeResult.raw.position)
       });
-      decodeResult.formatted.items.push({
-        type: "flight_level",
-        code: "FL",
-        label: "Flight Level",
-        value: decodeResult.raw.flight_level
-      });
+      ResultFormatter.altitude(decodeResult, altitude);
       decodeResult.remaining.text = `,${results.groups.unkwn1} ,${results.groups.unkwn2}`;
       decodeResult.decoded = true;
       decodeResult.decoder.decodeLevel = "partial";
@@ -435,58 +968,6 @@ var Label_16_N_Space = class extends DecoderPlugin {
   }
 };
 
-// lib/DateTimeUtils.ts
-var DateTimeUtils = class {
-  // Expects a four digit UTC time string (HHMM)
-  static UTCToString(UTCString) {
-    let utcDate = /* @__PURE__ */ new Date();
-    utcDate.setUTCHours(+UTCString.substr(0, 2), +UTCString.substr(2, 2), 0);
-    return utcDate.toTimeString();
-  }
-  // Expects a six digit date string and a four digit UTC time string
-  // (DDMMYY) (HHMM)
-  static UTCDateTimeToString(dateString, timeString) {
-    let utcDate = /* @__PURE__ */ new Date();
-    utcDate.setUTCDate(+dateString.substr(0, 2));
-    utcDate.setUTCMonth(+dateString.substr(2, 2));
-    if (dateString.length === 6) {
-      utcDate.setUTCFullYear(2e3 + +dateString.substr(4, 2));
-    }
-    if (timeString.length === 6) {
-      utcDate.setUTCHours(+timeString.substr(0, 2), +timeString.substr(2, 2), +timeString.substr(4, 2));
-    } else {
-      utcDate.setUTCHours(+timeString.substr(0, 2), +timeString.substr(2, 2), 0);
-    }
-    return utcDate.toUTCString();
-  }
-  /**
-   * 
-   * @param time HHMMSS
-   * @returns seconds since midnight
-   */
-  static convertHHMMSSToTod(time) {
-    const h = Number(time.substring(0, 2));
-    const m = Number(time.substring(2, 4));
-    const s = Number(time.substring(4, 6));
-    const tod = h * 3600 + m * 60 + s;
-    return tod;
-  }
-  /**
-   * 
-   * @param time HHMMSS
-   * @param date MMDDYY or MMDDYYYY
-   * @returns seconds since epoch
-   */
-  static convertDateTimeToEpoch(time, date) {
-    if (date.length === 6) {
-      date = date.substring(0, 4) + `20${date.substring(4, 6)}`;
-    }
-    const timestamp = `${date.substring(4, 8)}-${date.substring(0, 2)}-${date.substring(2, 4)}T${time.substring(0, 2)}:${time.substring(2, 4)}:${time.substring(4, 6)}.000Z`;
-    const millis = Date.parse(timestamp);
-    return millis / 1e3;
-  }
-};
-
 // lib/plugins/Label_1M_Slash.ts
 var Label_1M_Slash = class extends DecoderPlugin {
   name = "label-1m-slash";
@@ -553,16 +1034,17 @@ var Label_20_POS = class extends DecoderPlugin {
     decodeResult.message = message;
     decodeResult.raw.preamble = message.text.substring(0, 3);
     const content = message.text.substring(3);
-    console.log("Content: " + content);
     const fields = content.split(",");
-    console.log("Field Count: " + fields.length);
     if (fields.length == 11) {
-      console.log(`DEBUG: ${this.name}: Variation 1 detected`);
+      if (options.debug) {
+        console.log(`DEBUG: ${this.name}: Variation 1 detected`);
+      }
       const rawCoords = fields[0];
       decodeResult.raw.position = CoordinateUtils.decodeStringCoordinates(rawCoords);
       if (decodeResult.raw.position) {
         decodeResult.formatted.items.push({
           type: "position",
+          code: "POS",
           label: "Position",
           value: CoordinateUtils.coordinateString(decodeResult.raw.position)
         });
@@ -570,12 +1052,15 @@ var Label_20_POS = class extends DecoderPlugin {
       decodeResult.decoded = true;
       decodeResult.decoder.decodeLevel = "full";
     } else if (fields.length == 5) {
-      console.log(`DEBUG: ${this.name}: Variation 2 detected`);
+      if (options.debug) {
+        console.log(`DEBUG: ${this.name}: Variation 2 detected`);
+      }
       const rawCoords = fields[0];
       decodeResult.raw.position = CoordinateUtils.decodeStringCoordinates(rawCoords);
       if (decodeResult.raw.position) {
         decodeResult.formatted.items.push({
           type: "position",
+          code: "POS",
           label: "Position",
           value: CoordinateUtils.coordinateString(decodeResult.raw.position)
         });
@@ -583,7 +1068,9 @@ var Label_20_POS = class extends DecoderPlugin {
       decodeResult.decoded = true;
       decodeResult.decoder.decodeLevel = "full";
     } else {
-      console.log(`DEBUG: ${this.name}: Unknown variation. Field count: ${fields.length}, content: ${content}`);
+      if (options.debug) {
+        console.log(`DEBUG: ${this.name}: Unknown variation. Field count: ${fields.length}, content: ${content}`);
+      }
       decodeResult.decoded = false;
       decodeResult.decoder.decodeLevel = "none";
     }
@@ -607,15 +1094,13 @@ var Label_21_POS = class extends DecoderPlugin {
     decodeResult.message = message;
     decodeResult.raw.preamble = message.text.substring(0, 3);
     const content = message.text.substring(3);
-    console.log("Content: " + content);
     const fields = content.split(",");
-    console.log("Field Count: " + fields.length);
     if (fields.length == 9) {
       processPosition(decodeResult, fields[0].trim());
       processAlt(decodeResult, fields[3]);
       processTemp(decodeResult, fields[6]);
       processArrvApt(decodeResult, fields[8]);
-      decodeResult.raw.remaining = [
+      decodeResult.remaining.text = [
         fields[1],
         fields[2],
         fields[4],
@@ -625,7 +1110,9 @@ var Label_21_POS = class extends DecoderPlugin {
       decodeResult.decoded = true;
       decodeResult.decoder.decodeLevel = "partial";
     } else {
-      console.log(`DEBUG: ${this.name}: Unknown variation. Field count: ${fields.length}, content: ${content}`);
+      if (options.debug) {
+        console.log(`DEBUG: ${this.name}: Unknown variation. Field count: ${fields.length}, content: ${content}`);
+      }
       decodeResult.decoded = false;
       decodeResult.decoder.decodeLevel = "none";
     }
@@ -979,9 +1466,7 @@ var Label_44_POS = class extends DecoderPlugin {
         console.log(results.groups);
       }
       decodeResult.raw.position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(results.groups.unsplit_coords);
-      decodeResult.raw.flight_level = results.groups.flight_level_or_ground == "GRD" || results.groups.flight_level_or_ground == "***" ? "0" : Number(results.groups.flight_level_or_ground);
-      decodeResult.raw.departure_icao = results.groups.departure_icao;
-      decodeResult.raw.arrival_icao = results.groups.arrival_icao;
+      const flight_level = results.groups.flight_level_or_ground == "GRD" || results.groups.flight_level_or_ground == "***" ? 0 : Number(results.groups.flight_level_or_ground);
       decodeResult.raw.current_time = Date.parse(
         (/* @__PURE__ */ new Date()).getFullYear() + "-" + results.groups.current_date.substr(0, 2) + "-" + results.groups.current_date.substr(2, 2) + "T" + results.groups.current_time.substr(0, 2) + ":" + results.groups.current_time.substr(2, 2) + ":00Z"
       );
@@ -999,24 +1484,9 @@ var Label_44_POS = class extends DecoderPlugin {
           value: CoordinateUtils.coordinateString(decodeResult.raw.position)
         });
       }
-      decodeResult.formatted.items.push({
-        type: "origin",
-        code: "ORG",
-        label: "Origin",
-        value: decodeResult.raw.departure_icao
-      });
-      decodeResult.formatted.items.push({
-        type: "destination",
-        code: "DST",
-        label: "Destination",
-        value: decodeResult.raw.arrival_icao
-      });
-      decodeResult.formatted.items.push({
-        type: "flight_level",
-        code: "FL",
-        label: "Flight Level",
-        value: decodeResult.raw.flight_level
-      });
+      ResultFormatter.departureAirport(decodeResult, results.groups.departure_icao);
+      ResultFormatter.arrivalAirport(decodeResult, results.groups.arrival_icao);
+      ResultFormatter.altitude(decodeResult, flight_level * 100);
     }
     decodeResult.decoded = true;
     decodeResult.decoder.decodeLevel = "full";
@@ -1024,6 +1494,64 @@ var Label_44_POS = class extends DecoderPlugin {
   }
 };
 
+// lib/plugins/Label_4N.ts
+var Label_4N = class extends DecoderPlugin {
+  name = "label-4n";
+  qualifiers() {
+    return {
+      labels: ["4N"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "Airline Defined";
+    let text = message.text;
+    if (text.match(/^M\d{2}A\w{6}/)) {
+      ResultFormatter.flightNumber(decodeResult, message.text.substring(4, 10).replace(/^([A-Z]+)0*/g, "$1"));
+      text = text.substring(10);
+    }
+    decodeResult.decoded = true;
+    const fields = text.split(",");
+    if (text.length === 51) {
+      decodeResult.raw.day_of_month = text.substring(0, 2);
+      ResultFormatter.departureAirport(decodeResult, text.substring(8, 11));
+      ResultFormatter.arrivalAirport(decodeResult, text.substring(13, 16));
+      ResultFormatter.position(decodeResult, CoordinateUtils.decodeStringCoordinatesDecimalMinutes(text.substring(30, 45).replace(/^(.)0/, "$1")));
+      ResultFormatter.altitude(decodeResult, text.substring(48, 51) * 100);
+      decodeResult.remaining.text = [text.substring(2, 4), text.substring(19, 29)].join(" ");
+    } else if (fields.length === 33) {
+      decodeResult.raw.date = fields[3];
+      if (fields[1] === "B") {
+        ResultFormatter.position(decodeResult, { latitude: Number(fields[4]), longitude: Number(fields[5]) });
+        ResultFormatter.altitude(decodeResult, fields[6]);
+      }
+      ResultFormatter.departureAirport(decodeResult, fields[8]);
+      ResultFormatter.arrivalAirport(decodeResult, fields[9]);
+      ResultFormatter.alternateAirport(decodeResult, fields[10]);
+      ResultFormatter.arrivalRunway(decodeResult, fields[11].split("/")[0]);
+      if (fields[12].length > 1) {
+        ResultFormatter.alternateRunway(decodeResult, fields[12].split("/")[0]);
+      }
+      ResultFormatter.checksum(decodeResult, fields[32]);
+      decodeResult.remaining.text = [...fields.slice(1, 3), fields[7], ...fields.slice(13, 32)].filter((f) => f != "").join(",");
+    } else {
+      decodeResult.decoded = false;
+      decodeResult.remaining.text = text;
+    }
+    if (decodeResult.decoded) {
+      if (decodeResult.remaining.text === "")
+        decodeResult.decoder.decodeLevel = "full";
+      else
+        decodeResult.decoder.decodeLevel = "partial";
+    } else {
+      decodeResult.decoder.decodeLevel = "none";
+    }
+    return decodeResult;
+  }
+};
+
 // lib/plugins/Label_80.ts
 var Label_80 = class extends DecoderPlugin {
   name = "label-80";
@@ -1055,27 +1583,15 @@ var Label_80 = class extends DecoderPlugin {
     const parts = message.text.split("\n");
     let posRptRegex = /^3N01 POSRPT \d\d\d\d\/\d\d (?<orig>\w+)\/(?<dest>\w+) \.(?<tail>[\w-]+)(\/(?<agate>.+) (?<sta>\w+:\w+))*/;
     let results = parts[0].match(posRptRegex);
+    if (!results?.groups) {
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+      return decodeResult;
+    }
     if (results && results.length > 0) {
-      decodeResult.raw.origin = results.groups.orig;
-      decodeResult.formatted.items.push({
-        type: "origin",
-        code: "ORG",
-        label: "Origin",
-        value: `${results.groups.orig}`
-      });
-      decodeResult.raw.destination = results.groups.dest;
-      decodeResult.formatted.items.push({
-        type: "destination",
-        code: "DST",
-        label: "Destination",
-        value: `${results.groups.dest}`
-      });
-      decodeResult.raw.tail = results.groups.tail;
-      decodeResult.formatted.items.push({
-        type: "tail",
-        label: "Tail",
-        value: `${results.groups.tail}`
-      });
+      ResultFormatter.departureAirport(decodeResult, results.groups.orig);
+      ResultFormatter.arrivalAirport(decodeResult, results.groups.dest);
+      ResultFormatter.tail(decodeResult, results.groups.tail);
       if (results.groups.agate) {
         decodeResult.raw.arrival_gate = results.groups.agate;
         decodeResult.formatted.items.push({
@@ -1097,15 +1613,9 @@ var Label_80 = class extends DecoderPlugin {
       for (const part of remainingParts) {
         const matches = part.matchAll(posRptRegex);
         for (const match of matches) {
-          switch (match.groups.field) {
+          switch (match.groups?.field) {
             case "ALT": {
-              decodeResult.raw.altitude = match.groups.value;
-              decodeResult.formatted.items.push({
-                type: "altitude",
-                code: "ALT",
-                label: this.descriptions[match.groups.field],
-                value: `${decodeResult.raw.altitude} feet`
-              });
+              ResultFormatter.altitude(decodeResult, Number(match.groups.value));
               break;
             }
             case "DWND": {
@@ -1119,13 +1629,8 @@ var Label_80 = class extends DecoderPlugin {
               break;
             }
             case "FL": {
-              decodeResult.raw.flight_level = match.groups.value;
-              decodeResult.formatted.items.push({
-                type: "flight_level",
-                code: "FL",
-                label: this.descriptions[match.groups.field],
-                value: decodeResult.raw.flight_level
-              });
+              const flight_level = Number(match.groups.value);
+              ResultFormatter.altitude(decodeResult, flight_level * 100);
               break;
             }
             case "FOB": {
@@ -1149,7 +1654,7 @@ var Label_80 = class extends DecoderPlugin {
               break;
             }
             case "MCH": {
-              decodeResult.raw.mach = match.groups.value / 1e3;
+              decodeResult.raw.mach = Number(match.groups.value) / 1e3;
               decodeResult.formatted.items.push({
                 type: "mach",
                 code: "MCH",
@@ -1171,20 +1676,13 @@ var Label_80 = class extends DecoderPlugin {
             case "POS": {
               const posRegex = /^(?<latd>[NS])(?<lat>.+)(?<lngd>[EW])(?<lng>.+)/;
               const posResult = match.groups.value.match(posRegex);
-              const lat = Number(posResult.groups.lat) * (posResult.groups.lngd === "S" ? -1 : 1);
-              const lon = Number(posResult.groups.lng) * (posResult.groups.lngd === "W" ? -1 : 1);
-              const latitude = Number.isInteger(lat) ? lat / 1e3 : lat / 100;
-              const longitude = Number.isInteger(lon) ? lon / 1e3 : lon / 100;
-              decodeResult.raw.position = {
-                latitude,
-                longitude
+              const lat = Number(posResult?.groups?.lat) * (posResult?.groups?.lngd === "S" ? -1 : 1);
+              const lon = Number(posResult?.groups?.lng) * (posResult?.groups?.lngd === "W" ? -1 : 1);
+              const position = {
+                latitude: Number.isInteger(lat) ? lat / 1e3 : lat / 100,
+                longitude: Number.isInteger(lon) ? lon / 1e3 : lon / 100
               };
-              decodeResult.formatted.items.push({
-                type: "position",
-                code: "POS",
-                label: "Position",
-                value: CoordinateUtils.coordinateString(decodeResult.raw.position)
-              });
+              ResultFormatter.position(decodeResult, position);
               break;
             }
             case "SWND": {
@@ -1198,7 +1696,7 @@ var Label_80 = class extends DecoderPlugin {
               break;
             }
             default: {
-              if (match.groups.field != void 0) {
+              if (match.groups?.field != void 0) {
                 const description = this.descriptions[match.groups.field] ? this.descriptions[match.groups.field] : "Unknown";
                 decodeResult.formatted.items.push({
                   type: match.groups.field,
@@ -1209,10 +1707,80 @@ var Label_80 = class extends DecoderPlugin {
               }
             }
           }
-        }
+        }
+      }
+      decodeResult.decoded = true;
+      decodeResult.decoder.decodeLevel = "partial";
+    }
+    return decodeResult;
+  }
+};
+
+// lib/plugins/Label_83.ts
+var Label_83 = class extends DecoderPlugin {
+  name = "label-83";
+  qualifiers() {
+    return {
+      labels: ["83"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "Airline Defined";
+    let text = message.text;
+    if (text.match(/^M\d{2}A\w{6}/)) {
+      ResultFormatter.flightNumber(decodeResult, message.text.substring(4, 10).replace(/^([A-Z]+)0*/g, "$1"));
+      text = text.substring(10);
+    }
+    decodeResult.decoded = true;
+    if (text.substring(0, 10) === "4DH3 ETAT2") {
+      const fields = text.split(/\s+/);
+      if (fields[2].length > 5) {
+        decodeResult.raw.day_of_month = fields[2].substring(5);
+      }
+      decodeResult.remaining.text = fields[2].substring(0, 4);
+      const subfields = fields[3].split("/");
+      ResultFormatter.departureAirport(decodeResult, subfields[0]);
+      ResultFormatter.arrivalAirport(decodeResult, subfields[1]);
+      ResultFormatter.tail(decodeResult, fields[4].replace(/\./g, ""));
+      ResultFormatter.eta(decodeResult, fields[6] + "00");
+    } else if (text.substring(0, 5) === "001PR") {
+      decodeResult.raw.day_of_month = text.substring(5, 7);
+      ResultFormatter.position(decodeResult, CoordinateUtils.decodeStringCoordinatesDecimalMinutes(text.substring(13, 28).replace(/\./g, "")));
+      ResultFormatter.altitude(decodeResult, Number(text.substring(28, 33)));
+      decodeResult.remaining.text = text.substring(33);
+    } else {
+      const fields = text.replace(/\s/g, "").split(",");
+      if (fields.length === 9) {
+        ResultFormatter.departureAirport(decodeResult, fields[0]);
+        ResultFormatter.arrivalAirport(decodeResult, fields[1]);
+        decodeResult.raw.day_of_month = fields[2].substring(0, 2);
+        decodeResult.raw.time = fields[2].substring(2);
+        ResultFormatter.position(
+          decodeResult,
+          {
+            latitude: Number(fields[3].replace(/\s/g, "")),
+            longitude: Number(fields[4].replace(/\s/g, ""))
+          }
+        );
+        ResultFormatter.altitude(decodeResult, fields[5]);
+        ResultFormatter.groundspeed(decodeResult, fields[6]);
+        ResultFormatter.heading(decodeResult, fields[7]);
+        decodeResult.remaining.text = fields[8];
+      } else {
+        decodeResult.decoded = false;
+        decodeResult.remaining.text = message.text;
       }
-      decodeResult.decoded = true;
-      decodeResult.decodeLevel = "partial";
+    }
+    if (decodeResult.decoded) {
+      if (decodeResult.remaining.text === "")
+        decodeResult.decoder.decodeLevel = "full";
+      else
+        decodeResult.decoder.decodeLevel = "partial";
+    } else {
+      decodeResult.decoder.decodeLevel = "none";
     }
     return decodeResult;
   }
@@ -1359,183 +1927,6 @@ function processUnknown(decodeResult, value) {
   decodeResult.remaining.text += value;
 }
 
-// lib/utils/result_formatter.ts
-var ResultFormatter = class {
-  static altitude(decodeResult, value) {
-    decodeResult.raw.altitude = value;
-    decodeResult.formatted.items.push({
-      type: "altitude",
-      code: "ALT",
-      label: "Altitude",
-      value: `${decodeResult.raw.altitude} feet`
-    });
-  }
-  static flightNumber(decodeResult, value) {
-    decodeResult.raw.flight_number = value;
-  }
-  static departureAirport(decodeResult, value) {
-    decodeResult.raw.departure_icao = value;
-    decodeResult.formatted.items.push({
-      type: "origin",
-      code: "ORG",
-      label: "Origin",
-      value: decodeResult.raw.departure_icao
-    });
-  }
-  static departureRunway(decodeResult, value) {
-    decodeResult.raw.departure_runway = value;
-    decodeResult.formatted.items.push({
-      type: "runway",
-      code: "DEPRWY",
-      label: "Departure Runway",
-      value: decodeResult.raw.departure_runway
-    });
-  }
-  static arrivalAirport(decodeResult, value) {
-    decodeResult.raw.arrival_icao = value;
-    decodeResult.formatted.items.push({
-      type: "destination",
-      code: "DST",
-      label: "Destination",
-      value: decodeResult.raw.arrival_icao
-    });
-  }
-  static eta(decodeResult, value) {
-    decodeResult.formatted.items.push({
-      type: "eta",
-      code: "ETA",
-      label: "Estimated Time of Arrival",
-      value: value.substring(0, 2) + ":" + value.substring(2, 4) + ":" + value.substring(4, 6)
-    });
-  }
-  static arrivalRunway(decodeResult, value) {
-    decodeResult.raw.arrival_runway = value;
-    decodeResult.formatted.items.push({
-      type: "runway",
-      label: "Arrival Runway",
-      value: decodeResult.raw.arrival_runway
-    });
-  }
-  static currentFuel(decodeResult, value) {
-    decodeResult.raw.fuel_on_board = value;
-    decodeResult.formatted.items.push({
-      type: "fuel_on_board",
-      code: "FOB",
-      label: "Fuel On Board",
-      value: decodeResult.raw.fuel_on_board.toString()
-    });
-  }
-  static remainingFuel(decodeResult, value) {
-    decodeResult.raw.fuel_remaining = value;
-    decodeResult.formatted.items.push({
-      type: "fuel_remaining",
-      label: "Fuel Remaining",
-      value: decodeResult.raw.fuel_remaining.toString()
-    });
-  }
-  static checksum(decodeResult, value) {
-    decodeResult.raw.checksum = Number("0x" + value);
-    decodeResult.formatted.items.push({
-      type: "message_checksum",
-      code: "CHECKSUM",
-      label: "Message Checksum",
-      value: "0x" + ("0000" + decodeResult.raw.checksum.toString(16)).slice(-4)
-    });
-  }
-  static groundspeed(decodeResult, value) {
-    decodeResult.raw.groundspeed = value;
-    decodeResult.formatted.items.push({
-      type: "aircraft_groundspeed",
-      code: "GSPD",
-      label: "Aircraft Groundspeed",
-      value: `${decodeResult.raw.groundspeed}`
-    });
-  }
-  static temperature(decodeResult, value) {
-    decodeResult.raw.outside_air_temperature = Number(value.substring(1)) * (value.charAt(0) === "M" ? -1 : 1);
-    decodeResult.formatted.items.push({
-      type: "outside_air_temperature",
-      code: "OATEMP",
-      label: "Outside Air Temperature (C)",
-      value: `${decodeResult.raw.outside_air_temperature}`
-    });
-  }
-  static unknown(decodeResult, value) {
-    decodeResult.remaining.text += "," + value;
-  }
-};
-
-// lib/utils/route_utils.ts
-var RouteUtils = class _RouteUtils {
-  static routeToString(route) {
-    let str = "";
-    if (route.name) {
-      str += route.name;
-    }
-    if (route.runway) {
-      str += `(${route.runway})`;
-    }
-    if (str.length !== 0 && route.waypoints && route.waypoints.length === 1) {
-      str += " starting at ";
-    } else if (str.length !== 0 && route.waypoints) {
-      str += ": ";
-    }
-    if (route.waypoints) {
-      str += _RouteUtils.waypointsToString(route.waypoints);
-    }
-    return str;
-  }
-  static waypointToString(waypoint) {
-    let s = waypoint.name;
-    if (waypoint.latitude && waypoint.longitude) {
-      s += `(${CoordinateUtils.coordinateString({ latitude: waypoint.latitude, longitude: waypoint.longitude })})`;
-    }
-    if (waypoint.offset) {
-      s += `[${waypoint.offset.bearing}\xB0 ${waypoint.offset.distance}nm]`;
-    }
-    if (waypoint.time && waypoint.timeFormat) {
-      s += `@${_RouteUtils.timestampToString(waypoint.time, waypoint.timeFormat)}`;
-    }
-    return s;
-  }
-  static getWaypoint(leg) {
-    const regex = leg.match(/^([A-Z]+)(\d{3})-(\d{4})$/);
-    if (regex?.length == 4) {
-      return { name: regex[1], offset: { bearing: parseInt(regex[2]), distance: parseInt(regex[3]) / 10 } };
-    }
-    const waypoint = leg.split(",");
-    if (waypoint.length == 2) {
-      const position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(waypoint[1]);
-      if (position) {
-        return { name: waypoint[0], latitude: position.latitude, longitude: position.longitude };
-      }
-    }
-    if (leg.length == 13 || leg.length == 14) {
-      const position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(leg);
-      const name = waypoint.length == 2 ? waypoint[0] : "";
-      if (position) {
-        return { name, latitude: position.latitude, longitude: position.longitude };
-      }
-    }
-    return { name: leg };
-  }
-  // move out if we want public
-  static timestampToString(time, format) {
-    const date = new Date(time * 1e3);
-    if (format == "tod") {
-      return date.toISOString().slice(11, 19);
-    }
-    return date.toISOString().slice(0, -5) + "Z";
-  }
-  static waypointsToString(waypoints) {
-    let str = waypoints.map((x) => _RouteUtils.waypointToString(x)).join(" > ").replaceAll(">  >", ">>");
-    if (str.startsWith(" > ")) {
-      str = ">>" + str.slice(2);
-    }
-    return str;
-  }
-};
-
 // lib/utils/flight_plan_utils.ts
 var FlightPlanUtils = class _FlightPlanUtils {
   /**
@@ -1797,13 +2188,7 @@ function processTimeOfDeparture(decodeResult, data) {
   return false;
 }
 function processIdentification(decodeResult, data) {
-  decodeResult.raw.tail = data[0];
-  decodeResult.formatted.items.push({
-    type: "tail",
-    code: "TAIL",
-    label: "Tail",
-    value: decodeResult.raw.tail
-  });
+  ResultFormatter.tail(decodeResult, data[0]);
   if (data.length > 1) {
     decodeResult.raw.flight_number = data[1];
   }
@@ -1900,8 +2285,6 @@ function processPS(decodeResult, data) {
   } else {
     allKnownFields = false;
   }
-  console.log("PS data.length: ", data.length);
-  console.log("PS data: ", data);
   if (data.length === 9) {
     processRoute(decodeResult, data[3], data[1], data[5], data[4], void 0);
     ResultFormatter.altitude(decodeResult, Number(data[2]) * 100);
@@ -1936,8 +2319,6 @@ function processPosition2(decodeResult, data) {
   } else {
     allKnownFields = false;
   }
-  console.log("data.length: ", data.length);
-  console.log("data: ", data);
   if (data.length >= 10) {
     ResultFormatter.altitude(decodeResult, Number(data[3]) * 100);
     processRoute(decodeResult, data[1], data[2], data[4], data[5], data[6]);
@@ -1995,7 +2376,7 @@ var Label_H1_FPN = class extends DecoderPlugin {
     decodeResult.decoded = true;
     decodeResult.decoder.decodeLevel = fulllyDecoded ? "full" : "partial";
     if (decodeResult.formatted.items.length === 0) {
-      if (options?.debug) {
+      if (options.debug) {
         console.log(`Decoder: Unknown H1 message: ${message.text}`);
       }
       decodeResult.remaining.text = message.text;
@@ -2025,7 +2406,7 @@ var Label_H1_FTX = class extends DecoderPlugin {
     decodeResult.decoded = true;
     decodeResult.decoder.decodeLevel = fulllyDecoded ? "full" : "partial";
     if (decodeResult.formatted.items.length === 0) {
-      if (options?.debug) {
+      if (options.debug) {
         console.log(`Decoder: Unknown H1 message: ${message.text}`);
       }
       decodeResult.remaining.text = message.text;
@@ -2056,7 +2437,7 @@ var Label_H1_INI = class extends DecoderPlugin {
     decodeResult.decoded = true;
     decodeResult.decoder.decodeLevel = fulllyDecoded ? "full" : "partial";
     if (decodeResult.formatted.items.length === 0) {
-      if (options?.debug) {
+      if (options.debug) {
         console.log(`Decoder: Unknown H1 message: ${message.text}`);
       }
       decodeResult.remaining.text = message.text;
@@ -2145,7 +2526,7 @@ var Label_H1_POS = class extends DecoderPlugin {
     decodeResult.decoded = true;
     decodeResult.decoder.decodeLevel = fulllyDecoded ? "full" : "partial";
     if (decodeResult.formatted.items.length === 0) {
-      if (options?.debug) {
+      if (options.debug) {
         console.log(`Decoder: Unknown H1 message: ${message.text}`);
       }
       decodeResult.remaining.text = message.text;
@@ -2212,6 +2593,60 @@ function processUnknown2(decodeResult, value) {
   decodeResult.remaining.text += value;
 }
 
+// lib/plugins/Label_HX.ts
+var Label_HX = class extends DecoderPlugin {
+  name = "label-hx";
+  qualifiers() {
+    return {
+      labels: ["HX"],
+      preambles: ["RA FMT LOCATION", "RA FMT 43"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "Undelivered Uplink Report";
+    const parts = message.text.split(" ");
+    decodeResult.decoded = true;
+    if (parts[2] === "LOCATION") {
+      let latdir = parts[3].substring(0, 1);
+      let latdeg = Number(parts[3].substring(1, 3));
+      let latmin = Number(parts[3].substring(3, 7));
+      let londir = parts[4].substring(0, 1);
+      let londeg = Number(parts[4].substring(1, 4));
+      let lonmin = Number(parts[4].substring(4, 8));
+      decodeResult.raw.position = {
+        latitude: (latdeg + latmin / 60) * (latdir === "N" ? 1 : -1),
+        longitude: (londeg + lonmin / 60) * (londir === "E" ? 1 : -1)
+      };
+      decodeResult.remaining.text = parts.slice(5).join(" ");
+    } else if (parts[2] === "43") {
+      ResultFormatter.departureAirport(decodeResult, parts[3]);
+      decodeResult.remaining.text = parts.slice(4).join(" ");
+    } else {
+      decodeResult.decoded = false;
+    }
+    if (decodeResult.raw.position) {
+      decodeResult.formatted.items.push({
+        type: "aircraft_position",
+        code: "POS",
+        label: "Aircraft Position",
+        value: CoordinateUtils.coordinateString(decodeResult.raw.position)
+      });
+    }
+    if (decodeResult.decoded) {
+      if (decodeResult.remaining.text === "")
+        decodeResult.decoder.decodeLevel = "full";
+      else
+        decodeResult.decoder.decodeLevel = "partial";
+    } else {
+      decodeResult.decoder.decodeLevel = "none";
+    }
+    return decodeResult;
+  }
+};
+
 // lib/plugins/Label_SQ.ts
 var Label_SQ = class extends DecoderPlugin {
   name = "label-sq";
@@ -2252,11 +2687,13 @@ var Label_SQ = class extends DecoderPlugin {
     decodeResult.formatted.items = [
       {
         type: "network",
+        code: "NETT",
         label: "Network",
         value: formattedNetwork
       },
       {
         type: "version",
+        code: "VER",
         label: "Version",
         value: decodeResult.raw.version
       }
@@ -2265,6 +2702,7 @@ var Label_SQ = class extends DecoderPlugin {
       if (decodeResult.raw.groundStation.icaoCode && decodeResult.raw.groundStation.number) {
         decodeResult.formatted.items.push({
           type: "ground_station",
+          code: "GNDSTN",
           label: "Ground Station",
           value: `${decodeResult.raw.groundStation.icaoCode}${decodeResult.raw.groundStation.number}`
         });
@@ -2272,6 +2710,7 @@ var Label_SQ = class extends DecoderPlugin {
       if (decodeResult.raw.groundStation.iataCode) {
         decodeResult.formatted.items.push({
           type: "iataCode",
+          code: "IATA",
           label: "IATA",
           value: decodeResult.raw.groundStation.iataCode
         });
@@ -2279,6 +2718,7 @@ var Label_SQ = class extends DecoderPlugin {
       if (decodeResult.raw.groundStation.icaoCode) {
         decodeResult.formatted.items.push({
           type: "icaoCode",
+          code: "ICAO",
           label: "ICAO",
           value: decodeResult.raw.groundStation.icaoCode
         });
@@ -2286,6 +2726,7 @@ var Label_SQ = class extends DecoderPlugin {
       if (decodeResult.raw.groundStation.coordinates.latitude) {
         decodeResult.formatted.items.push({
           type: "coordinates",
+          code: "COORD",
           label: "Ground Station Location",
           value: `${decodeResult.raw.groundStation.coordinates.latitude}, ${decodeResult.raw.groundStation.coordinates.longitude}`
         });
@@ -2293,6 +2734,7 @@ var Label_SQ = class extends DecoderPlugin {
       if (decodeResult.raw.groundStation.airport) {
         decodeResult.formatted.items.push({
           type: "airport",
+          code: "APT",
           label: "Airport",
           value: `${decodeResult.raw.groundStation.airport.name} (${decodeResult.raw.groundStation.airport.icao}) in ${decodeResult.raw.groundStation.airport.location}`
         });
@@ -2301,6 +2743,7 @@ var Label_SQ = class extends DecoderPlugin {
     if (decodeResult.raw.vdlFrequency) {
       decodeResult.formatted.items.push({
         type: "vdlFrequency",
+        code: "VDLFRQ",
         label: "VDL Frequency",
         value: `${decodeResult.raw.vdlFrequency} MHz`
       });
@@ -2457,31 +2900,48 @@ var Label_QQ = class extends DecoderPlugin {
   decode(message, options = {}) {
     const decodeResult = this.defaultResult();
     decodeResult.decoder.name = this.name;
-    decodeResult.raw.origin = message.text.substring(0, 4);
-    decodeResult.raw.destination = message.text.substring(4, 8);
-    decodeResult.raw.wheels_off = message.text.substring(8, 12);
-    decodeResult.remaining.text = message.text.substring(12);
+    decodeResult.message = message;
     decodeResult.formatted.description = "OFF Report";
-    decodeResult.formatted.items = [
-      {
-        type: "origin",
-        code: "ORG",
-        label: "Origin",
-        value: decodeResult.raw.origin
-      },
-      {
-        type: "destination",
-        code: "DST",
-        label: "Destination",
-        value: decodeResult.raw.destination
-      },
-      {
-        type: "wheels_off",
-        code: "WOFF",
-        label: "Wheels OFF",
-        value: decodeResult.raw.wheels_off
+    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
+    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
+    decodeResult.raw.wheels_off = message.text.substring(8, 12);
+    if (message.text.substring(12, 19) === "\r\n001FE") {
+      decodeResult.raw.day_of_month = message.text.substring(19, 21);
+      decodeResult.raw.wheels_off = message.text.substring(21, 27);
+      let latdir = message.text.substring(27, 28);
+      let latdeg = Number(message.text.substring(28, 30));
+      let latmin = Number(message.text.substring(30, 34));
+      let londir = message.text.substring(34, 35);
+      let londeg = Number(message.text.substring(35, 38));
+      let lonmin = Number(message.text.substring(38, 42));
+      decodeResult.raw.position = {
+        latitude: (latdeg + latmin / 60) * (latdir === "N" ? 1 : -1),
+        longitude: (londeg + lonmin / 60) * (londir === "E" ? 1 : -1)
+      };
+      decodeResult.remaining.text = message.text.substring(42, 45);
+      if (decodeResult.remaining.text !== "---") {
+        ResultFormatter.groundspeed(decodeResult, message.text.substring(45, 48));
+      } else {
+        ResultFormatter.unknown(decodeResult, message.text.substring(45, 48));
       }
-    ];
+      ResultFormatter.unknown(decodeResult, message.text.substring(48));
+    } else {
+      decodeResult.remaining.text = message.text.substring(12);
+    }
+    decodeResult.formatted.items.push({
+      type: "wheels_off",
+      code: "WOFF",
+      label: "Wheels OFF",
+      value: decodeResult.raw.wheels_off
+    });
+    if (decodeResult.raw.position) {
+      decodeResult.formatted.items.push({
+        type: "aircraft_position",
+        code: "POS",
+        label: "Aircraft Position",
+        value: CoordinateUtils.coordinateString(decodeResult.raw.position)
+      });
+    }
     decodeResult.decoded = true;
     if (decodeResult.remaining.text === "")
       decodeResult.decoder.decodeLevel = "full";
@@ -3304,7 +3764,11 @@ var MessageDecoder = class {
     this.debug = false;
     this.registerPlugin(new Label_ColonComma(this));
     this.registerPlugin(new Label_5Z(this));
+    this.registerPlugin(new Label_10_LDR(this));
+    this.registerPlugin(new Label_10_POS(this));
+    this.registerPlugin(new Label_10_Slash(this));
     this.registerPlugin(new Label_12_N_Space(this));
+    this.registerPlugin(new Label_13Through18_Slash(this));
     this.registerPlugin(new Label_15(this));
     this.registerPlugin(new Label_15_FST(this));
     this.registerPlugin(new Label_16_N_Space(this));
@@ -3316,6 +3780,7 @@ var MessageDecoder = class {
     this.registerPlugin(new Label_44_OFF(this));
     this.registerPlugin(new Label_44_ON(this));
     this.registerPlugin(new Label_44_POS(this));
+    this.registerPlugin(new Label_4N(this));
     this.registerPlugin(new Label_B6_Forwardslash(this));
     this.registerPlugin(new Label_H1_FPN(this));
     this.registerPlugin(new Label_H1_FLR(this));
@@ -3324,7 +3789,9 @@ var MessageDecoder = class {
     this.registerPlugin(new Label_H1_OHMA(this));
     this.registerPlugin(new Label_H1_POS(this));
     this.registerPlugin(new Label_H1_WRN(this));
+    this.registerPlugin(new Label_HX(this));
     this.registerPlugin(new Label_80(this));
+    this.registerPlugin(new Label_83(this));
     this.registerPlugin(new Label_8E(this));
     this.registerPlugin(new Label_1M_Slash(this));
     this.registerPlugin(new Label_SQ(this));