@airframes/acars-decoder 1.6.11 → 1.6.12

package/dist/index.js

@@ -49,6 +49,74 @@ var IcaoDecoder = class {
   }
 };
 
+// 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;
+  }
+  /**
+   * Converts a timestamp to a string
+   * 
+   * ISO-8601 format for 'epoch'
+   * HH:MM:SS for 'tod'
+   * @param time 
+   * @param format 
+   * @returns 
+   */
+  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";
+  }
+};
+
 // lib/DecoderPlugin.ts
 var DecoderPlugin = class {
   decoder;
@@ -167,8 +235,124 @@ var CoordinateUtils = class {
   }
 };
 
+// lib/utils/route_utils.ts
+var RouteUtils = class _RouteUtils {
+  static formatFlightState(state) {
+    switch (state) {
+      case "TO":
+        return "Takeoff";
+      case "IC":
+        return "Initial Climb";
+      case "CL":
+        return "Climb";
+      case "ER":
+        return "En Route";
+      case "DC":
+        return "Descent";
+      case "AP":
+        return "Approach";
+      default:
+        return `Unknown ${state}`;
+    }
+  }
+  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 += `@${DateTimeUtils.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 };
+  }
+  static waypointsToString(waypoints) {
+    let str = waypoints.map((x) => _RouteUtils.waypointToString(x)).join(" > ").replaceAll(">  >", ">>");
+    if (str.startsWith(" > ")) {
+      str = ">>" + str.slice(2);
+    }
+    return str;
+  }
+};
+
 // lib/utils/result_formatter.ts
 var ResultFormatter = class {
+  static state_change(decodeResult, from, to) {
+    decodeResult.raw.state_change = {
+      from,
+      to
+    };
+    from = RouteUtils.formatFlightState(from);
+    to = RouteUtils.formatFlightState(to);
+    decodeResult.formatted.items.push({
+      type: "state_change",
+      code: "STATE_CHANGE",
+      label: "State Change",
+      value: `${from} -> ${to}`
+    });
+  }
+  static freetext(decodeResult, value) {
+    decodeResult.raw.freetext = value;
+    decodeResult.formatted.items.push({
+      type: "freetext",
+      code: "FREE_TEXT",
+      label: "Free Text",
+      value
+    });
+  }
+  static door_event(decodeResult, name, state) {
+    decodeResult.raw.door_event = {
+      door: name,
+      state
+    };
+    decodeResult.formatted.items.push({
+      type: "door_event",
+      code: "DOOR",
+      label: "Door Event",
+      value: `${name} ${state}`
+    });
+  }
   static position(decodeResult, value) {
     decodeResult.raw.position = value;
     decodeResult.formatted.items.push({
@@ -189,16 +373,41 @@ var ResultFormatter = class {
   }
   static flightNumber(decodeResult, value) {
     decodeResult.raw.flight_number = value;
+    decodeResult.formatted.items.push({
+      type: "flight_number",
+      code: "FLIGHT",
+      label: "Flight Number",
+      value: decodeResult.raw.flight_number
+    });
   }
-  static departureAirport(decodeResult, value) {
-    decodeResult.raw.departure_icao = value;
+  static callsign(decodeResult, value) {
+    decodeResult.raw.callsign = value;
     decodeResult.formatted.items.push({
-      type: "origin",
-      code: "ORG",
-      label: "Origin",
-      value: decodeResult.raw.departure_icao
+      type: "callsign",
+      code: "CALLSIGN",
+      label: "Callsign",
+      value: decodeResult.raw.callsign
     });
   }
+  static departureAirport(decodeResult, value, type = "ICAO") {
+    if (type === "ICAO") {
+      decodeResult.raw.departure_icao = value;
+      decodeResult.formatted.items.push({
+        type: "icao",
+        code: "ORG",
+        label: "Origin",
+        value
+      });
+    } else {
+      decodeResult.raw.departure_iata = value;
+      decodeResult.formatted.items.push({
+        type: "iata",
+        code: "ORG",
+        label: "Origin",
+        value
+      });
+    }
+  }
   static departureRunway(decodeResult, value) {
     decodeResult.raw.departure_runway = value;
     decodeResult.formatted.items.push({
@@ -208,33 +417,52 @@ var ResultFormatter = class {
       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 arrivalAirport(decodeResult, value, type = "ICAO") {
+    if (type === "ICAO") {
+      decodeResult.raw.arrival_icao = value;
+      decodeResult.formatted.items.push({
+        type: "icao",
+        code: "DST",
+        label: "Destination",
+        value
+      });
+    } else {
+      decodeResult.raw.arrival_iata = value;
+      decodeResult.formatted.items.push({
+        type: "iata",
+        code: "DST",
+        label: "Destination",
+        value
+      });
+    }
   }
   static alternateAirport(decodeResult, value) {
     decodeResult.raw.alternate_icao = value;
     decodeResult.formatted.items.push({
-      type: "destination",
+      type: "icao",
       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 eta(decodeResult, time, type = "tod") {
+    if (type === "tod") {
+      decodeResult.raw.eta_time = time;
+      decodeResult.formatted.items.push({
+        type: "time_of_day",
+        code: "ETA",
+        label: "Estimated Time of Arrival",
+        value: DateTimeUtils.timestampToString(time, "tod")
+      });
+    } else {
+      decodeResult.raw.eta_date = time;
+      decodeResult.formatted.items.push({
+        type: "epoch",
+        code: "ETA",
+        label: "Estimated Time of Arrival",
+        value: DateTimeUtils.timestampToString(time, "epoch")
+      });
+    }
   }
   static arrivalRunway(decodeResult, value) {
     decodeResult.raw.arrival_runway = value;
@@ -291,12 +519,12 @@ var ResultFormatter = class {
     });
   }
   static temperature(decodeResult, value) {
-    decodeResult.raw.outside_air_temperature = Number(value.substring(1)) * (value.charAt(0) === "M" ? -1 : 1);
+    decodeResult.raw.outside_air_temperature = Number(value.replace("M", "-").replace("P", "+"));
     decodeResult.formatted.items.push({
       type: "outside_air_temperature",
       code: "OATEMP",
       label: "Outside Air Temperature (C)",
-      value: `${decodeResult.raw.outside_air_temperature}`
+      value: `${decodeResult.raw.outside_air_temperature} degrees`
     });
   }
   static heading(decodeResult, value) {
@@ -319,42 +547,56 @@ var ResultFormatter = class {
   }
   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)
+      value: DateTimeUtils.timestampToString(time, "tod")
     });
   }
   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)
+      value: DateTimeUtils.timestampToString(time, "tod")
     });
   }
   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)
+      value: DateTimeUtils.timestampToString(time, "tod")
     });
   }
   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)
+      value: DateTimeUtils.timestampToString(time, "tod")
+    });
+  }
+  static time_of_day(decodeResult, time) {
+    decodeResult.raw.time_of_day = time;
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "MSG_TOD",
+      label: "Message Timestamp",
+      value: DateTimeUtils.timestampToString(time, "tod")
+    });
+  }
+  static text(decodeResult, text2) {
+    decodeResult.raw.text = text2;
+    decodeResult.formatted.items.push({
+      type: "text",
+      code: "TEXT",
+      label: "Text Message",
+      value: text2
     });
   }
   static unknown(decodeResult, value) {
@@ -362,9 +604,9 @@ var ResultFormatter = class {
   }
 };
 
-// lib/plugins/Label_5Z.ts
-var Label_5Z = class extends DecoderPlugin {
-  name = "label-5z";
+// lib/plugins/Label_5Z_Slash.ts
+var Label_5Z_Slash = class extends DecoderPlugin {
+  name = "label-5z-slash";
   descriptions = {
     B1: "Request Weight and Balance",
     B3: "Request Departure Clearance",
@@ -382,6 +624,7 @@ var Label_5Z = class extends DecoderPlugin {
     D6: "From-To + Date",
     D7: "From-To + Alternate + Time",
     EO: "In Range",
+    ET: "Expected Time",
     PW: "Position Weather",
     RL: "Request Release",
     R3: "Request HOWGOZIT Message",
@@ -392,48 +635,82 @@ var Label_5Z = class extends DecoderPlugin {
   };
   qualifiers() {
     return {
-      labels: ["5Z"]
+      labels: ["5Z"],
+      preambles: ["/"]
     };
   }
   decode(message, options = {}) {
     const decodeResult = this.defaultResult();
     decodeResult.decoder.name = this.name;
     decodeResult.formatted.description = "Airline Designated Downlink";
-    const uaRegex = /^\/(?<type>\w+) (?<remainder>.+)/;
-    let results = message.text.match(uaRegex);
-    if (results && results.length >= 2) {
-      const type = results.groups.type.split("/")[0];
-      const { remainder } = results.groups;
-      const typeDescription = this.descriptions[type] ? this.descriptions[type] : "Unknown";
+    const lines = message.text.split("\r\n");
+    if (lines[0] === "/TXT") {
+      ResultFormatter.text(decodeResult, lines.slice(1).join("\r\n"));
+      decodeResult.decoded = true;
+      decodeResult.decoder.decodeLevel = "full";
+      return decodeResult;
+    }
+    const data = lines[0].split("/");
+    const header = data[1].split(" ");
+    const type = header[0];
+    const typeDescription = this.descriptions[type];
+    if (typeDescription) {
       decodeResult.raw.airline = "United Airlines";
       decodeResult.formatted.items.push({
         type: "airline",
+        code: "AIRLINE",
         label: "Airline",
         value: "United Airlines"
       });
       decodeResult.raw.message_type = type;
       decodeResult.formatted.items.push({
         type: "message_type",
+        code: "MSG_TYPE",
         label: "Message Type",
         value: `${typeDescription} (${type})`
       });
-      if (type === "B3") {
-        const rdcRegex = /^(?<from>\w\w\w)(?<to>\w\w\w) (?<unknown1>\d\d) R(?<runway>.+) G(?<unknown2>.+)$/;
-        results = remainder.match(rdcRegex);
-        if (results) {
-          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}`);
-          }
+      if (type === "B3" && data[1] === "B3 TO DATA REQ    ") {
+        const info = data[2].split(" ");
+        ResultFormatter.departureAirport(decodeResult, info[1]);
+        ResultFormatter.arrivalAirport(decodeResult, info[2]);
+        decodeResult.raw.day_of_month = Number(info[3]);
+        ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(info[4]));
+        ResultFormatter.arrivalRunway(decodeResult, info[5].slice(1));
+        decodeResult.remaining.text = data.slice(3).join("/");
+      } else if (type === "B3") {
+        ResultFormatter.departureAirport(decodeResult, header[1].substring(0, 3), "IATA");
+        ResultFormatter.arrivalAirport(decodeResult, header[1].substring(3), "IATA");
+        decodeResult.raw.day_of_month = Number(header[2]);
+        ResultFormatter.arrivalRunway(decodeResult, header[3].slice(1));
+        if (header.length > 4) {
+          decodeResult.remaining.text = header.slice(4).join(" ");
         }
+      } else if (type === "C3" && data[1] === "C3 GATE REQ       ") {
+        const info = data[2].split(" ");
+        ResultFormatter.departureAirport(decodeResult, info[1]);
+        ResultFormatter.arrivalAirport(decodeResult, info[2]);
+        decodeResult.raw.day_of_month = Number(info[3]);
+        ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(info[4]));
+        decodeResult.remaining.text = info.slice(5).join(" ");
+      } else if (type === "C3") {
+        ResultFormatter.departureAirport(decodeResult, header[1].substring(0, 3), "IATA");
+        ResultFormatter.arrivalAirport(decodeResult, header[1].substring(3), "IATA");
+      } else if (type === "ET") {
+        const airports = data[2].split(" ");
+        ResultFormatter.departureAirport(decodeResult, airports[1]);
+        ResultFormatter.arrivalAirport(decodeResult, airports[2]);
+        decodeResult.raw.day_of_month = Number(airports[3]);
+        ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(airports[4]));
+        const estimates = data[3].split(" ");
+        ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(estimates[1] + "00"));
+        decodeResult.remaining.text = estimates[2];
       } else {
-        decodeResult.remaining.text = remainder;
+        if (options.debug) {
+          console.log(`Decoder: Unkown 5Z RDC format: ${message.text}`);
+        }
       }
       decodeResult.decoded = true;
-      decodeResult.decoder.decodeLevel = "partial";
+      decodeResult.decoder.decodeLevel = decodeResult.remaining.text ? "partial" : "full";
     } else {
       if (options.debug) {
         console.log(`Decoder: Unknown 5Z message: ${message.text}`);
@@ -534,129 +811,6 @@ var Label_10_POS = 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/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/plugins/Label_10_Slash.ts
 var Label_10_Slash = class extends DecoderPlugin {
   // eslint-disable-line camelcase
@@ -692,7 +846,7 @@ var Label_10_Slash = class extends DecoderPlugin {
     ResultFormatter.heading(decodeResult, Number(parts[5]));
     ResultFormatter.altitude(decodeResult, 100 * Number(parts[6]));
     ResultFormatter.arrivalAirport(decodeResult, parts[7]);
-    ResultFormatter.eta(decodeResult, parts[8] + "00");
+    ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(parts[8] + "00"));
     const waypoints = [{
       name: parts[11]
     }, {
@@ -1026,28 +1180,12 @@ var Label_1M_Slash = class extends DecoderPlugin {
         console.log(results);
       }
       decodeResult.raw.flight_number = results[0];
-      decodeResult.raw.departure_icao = results[3];
-      decodeResult.raw.arrival_icao = results[4];
-      decodeResult.raw.alternate_icao = results[5];
-      decodeResult.raw.arrival_runway = results[8].replace(decodeResult.raw.arrival_icao, "");
-      decodeResult.formatted.items.push({
-        type: "eta",
-        code: "ETA",
-        label: "Estimated Time of Arrival",
-        value: DateTimeUtils.UTCDateTimeToString(results[2], results[7])
-      });
-      decodeResult.formatted.items.push({
-        type: "destination",
-        code: "DST",
-        label: "Destination",
-        value: decodeResult.raw.arrival_icao
-      });
-      decodeResult.formatted.items.push({
-        type: "origin",
-        code: "ORG",
-        label: "Origin",
-        value: decodeResult.raw.departure_icao
-      });
+      ResultFormatter.departureAirport(decodeResult, results[3]);
+      ResultFormatter.arrivalAirport(decodeResult, results[4]);
+      ResultFormatter.alternateAirport(decodeResult, results[5]);
+      ResultFormatter.arrivalRunway(decodeResult, results[8].replace(results[4], ""));
+      const yymmdd = results[2];
+      ResultFormatter.eta(decodeResult, DateTimeUtils.convertDateTimeToEpoch(results[7] + "00", yymmdd.substring(2, 4) + yymmdd.substring(4, 6) + yymmdd.substring(0, 2)), "epoch");
     }
     decodeResult.decoded = true;
     decodeResult.decoder.decodeLevel = "partial";
@@ -1134,15 +1272,15 @@ var Label_21_POS = class extends DecoderPlugin {
     const fields = content.split(",");
     if (fields.length == 9) {
       processPosition(decodeResult, fields[0].trim());
-      processAlt(decodeResult, fields[3]);
-      processTemp(decodeResult, fields[6]);
-      processArrvApt(decodeResult, fields[8]);
+      ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[2]));
+      ResultFormatter.altitude(decodeResult, Number(fields[3]));
+      ResultFormatter.temperature(decodeResult, fields[6].replace(/ /g, ""));
+      ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[7]));
+      ResultFormatter.arrivalAirport(decodeResult, fields[8]);
       decodeResult.remaining.text = [
         fields[1],
-        fields[2],
         fields[4],
-        fields[5],
-        fields[7]
+        fields[5]
       ].join(",");
       decodeResult.decoded = true;
       decodeResult.decoder.decodeLevel = "partial";
@@ -1158,7 +1296,7 @@ var Label_21_POS = class extends DecoderPlugin {
 };
 function processPosition(decodeResult, value) {
   if (value.length !== 16 && value[0] !== "N" && value[0] !== "S" && value[8] !== "W" && value[8] !== "E") {
-    return false;
+    return;
   }
   const latDir = value[0] === "N" ? 1 : -1;
   const lonDir = value[8] === "E" ? 1 : -1;
@@ -1166,45 +1304,52 @@ function processPosition(decodeResult, value) {
     latitude: latDir * Number(value.substring(1, 7)),
     longitude: lonDir * Number(value.substring(9, 15))
   };
-  if (position) {
-    decodeResult.raw.position = position;
-    decodeResult.formatted.items.push({
-      type: "aircraft_position",
-      code: "POS",
-      label: "Aircraft Position",
-      value: CoordinateUtils.coordinateString(position)
-    });
-  }
-  return !!position;
-}
-function processAlt(decodeResult, value) {
-  decodeResult.raw.altitude = Number(value);
-  decodeResult.formatted.items.push({
-    type: "altitude",
-    code: "ALT",
-    label: "Altitude",
-    value: `${decodeResult.raw.altitude} feet`
-  });
-}
-function processTemp(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}`
-  });
-}
-function processArrvApt(decodeResult, value) {
-  decodeResult.raw.arrival_icao = value;
-  decodeResult.formatted.items.push({
-    type: "destination",
-    code: "DST",
-    label: "Destination",
-    value: decodeResult.raw.arrival_icao
-  });
+  ResultFormatter.position(decodeResult, position);
 }
 
+// lib/plugins/Label_24_Slash.ts
+var Label_24_Slash = class extends DecoderPlugin {
+  name = "label-24-slash";
+  qualifiers() {
+    return {
+      labels: ["24"],
+      preambles: ["/"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "Position Report";
+    decodeResult.message = message;
+    const fields = message.text.split("/");
+    if (fields.length == 10 && fields[0] == "" && fields[9] == "") {
+      const mmddyy = fields[1].substring(4, 6) + fields[1].substring(2, 4) + fields[1].substring(0, 2);
+      const hhmmss = fields[2] + "00";
+      decodeResult.raw.message_timestamp = DateTimeUtils.convertDateTimeToEpoch(hhmmss, mmddyy);
+      ResultFormatter.flightNumber(decodeResult, fields[3]);
+      ResultFormatter.altitude(decodeResult, Number(fields[4]));
+      const lat = fields[5];
+      const lon = fields[6];
+      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.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[8] + "00"));
+      decodeResult.remaining.text = fields[7];
+      decodeResult.decoded = true;
+      decodeResult.decoder.decodeLevel = "partial";
+    } else {
+      if (options.debug) {
+        console.log(`DEBUG: ${this.name}: Unknown variation. Field count: ${fields.length}. Message: ${message.text}`);
+      }
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+    }
+    return decodeResult;
+  }
+};
+
 // lib/plugins/Label_30_Slash_EA.ts
 var Label_30_Slash_EA = class extends DecoderPlugin {
   name = "label-30-slash-ea";
@@ -1219,27 +1364,16 @@ var Label_30_Slash_EA = class extends DecoderPlugin {
     decodeResult.decoder.name = this.name;
     decodeResult.formatted.description = "ETA Report";
     decodeResult.message = message;
-    const results = message.text.split(/\n|\//).slice(1);
-    if (results) {
-      if (options.debug) {
-        console.log(`Label 30 EA: results`);
-        console.log(results);
-      }
-    }
-    decodeResult.formatted.items.push({
-      type: "eta",
-      code: "ETA",
-      label: "Estimated Time of Arrival",
-      value: DateTimeUtils.UTCToString(results[0].substr(2, 4))
-    });
-    if (results[1].substr(0, 2) === "DS") {
-      decodeResult.raw.arrival_icao = results[1].substr(2, 4);
-      decodeResult.formatted.items.push({
-        type: "destination",
-        code: "DST",
-        label: "Destination",
-        value: decodeResult.raw.arrival_icao
-      });
+    const results = message.text.split(/\n|\//).slice(1);
+    if (results) {
+      if (options.debug) {
+        console.log(`Label 30 EA: results`);
+        console.log(results);
+      }
+    }
+    ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(results[0].substr(2, 4) + "00"));
+    if (results[1].substring(0, 2) === "DS") {
+      ResultFormatter.arrivalAirport(decodeResult, results[1].substring(2, 6));
       decodeResult.remaining.text = "/".concat(results[2]);
     } else {
       decodeResult.remaining.text = "/".concat(results[1], "/", results[2]);
@@ -1531,6 +1665,221 @@ var Label_44_POS = class extends DecoderPlugin {
   }
 };
 
+// lib/plugins/Label_4A.ts
+var Label_4A = class extends DecoderPlugin {
+  name = "label-4a";
+  qualifiers() {
+    return {
+      labels: ["4A"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "Latest New Format";
+    let text2 = message.text;
+    if (text2.match(/^M\d{2}A\w{6}/)) {
+      ResultFormatter.flightNumber(decodeResult, message.text.substring(4, 10).replace(/^([A-Z]+)0*/g, "$1"));
+      text2 = text2.substring(10);
+    }
+    decodeResult.decoded = true;
+    const fields = text2.split(",");
+    if (fields.length === 11) {
+      ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[0]));
+      ResultFormatter.tail(decodeResult, fields[2].replace(".", ""));
+      if (fields[3])
+        ResultFormatter.callsign(decodeResult, fields[3]);
+      ResultFormatter.departureAirport(decodeResult, fields[4]);
+      ResultFormatter.arrivalAirport(decodeResult, fields[5]);
+      ResultFormatter.altitude(decodeResult, text2.substring(48, 51) * 100);
+      decodeResult.remaining.text = fields.slice(8).join(",");
+    } else if (fields.length === 6) {
+      if (fields[0].match(/^[NS]/)) {
+        ResultFormatter.position(decodeResult, CoordinateUtils.decodeStringCoordinates(fields[0].substring(0, 13)));
+        let wp1 = {
+          name: fields[0].substring(13).trim(),
+          time: DateTimeUtils.convertHHMMSSToTod(fields[1].substring(0, 6)),
+          timeFormat: "tod"
+        };
+        ResultFormatter.altitude(decodeResult, fields[1].substring(6, 9) * 100);
+        let wp2 = {
+          name: fields[1].substring(9).trim(),
+          time: DateTimeUtils.convertHHMMSSToTod(fields[2]),
+          timeFormat: "tod"
+        };
+        decodeResult.raw.route = { waypoints: [wp1, wp2] };
+        decodeResult.formatted.items.push({
+          type: "aircraft_route",
+          code: "ROUTE",
+          label: "Aircraft Route",
+          value: RouteUtils.routeToString(decodeResult.raw.route)
+        });
+        ResultFormatter.temperature(decodeResult, fields[3]);
+        decodeResult.remaining.text = fields.slice(4).join(",");
+      } else {
+        ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[0]));
+        ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[1]));
+        decodeResult.remaining.text = fields[2];
+        ResultFormatter.altitude(decodeResult, fields[3]);
+        ResultFormatter.position(decodeResult, CoordinateUtils.decodeStringCoordinates((fields[4] + fields[5]).replace(/[ \.]/g, "")));
+      }
+    } else {
+      decodeResult.decoded = false;
+      decodeResult.remaining.text = text2;
+    }
+    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_4A_01.ts
+var Label_4A_01 = class extends DecoderPlugin {
+  name = "label-4a-01";
+  qualifiers() {
+    return {
+      labels: ["4A"],
+      preambles: ["01"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "Latest New Format";
+    decodeResult.decoded = true;
+    let rgx = message.text.match(/^01([A-Z]{2})([A-Z]{2})\s*(\w+)\/(\d{6})([A-Z]{4})([A-Z]{4})\r\n([+-]\s*\d+)(\d{3}\.\d)([+-]\s*\d+\.\d)/);
+    if (rgx) {
+      ResultFormatter.state_change(decodeResult, rgx[1], rgx[2]);
+      ResultFormatter.callsign(decodeResult, rgx[3]);
+      ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(rgx[4] + "00"));
+      ResultFormatter.departureAirport(decodeResult, rgx[5]);
+      ResultFormatter.arrivalAirport(decodeResult, rgx[6]);
+      ResultFormatter.altitude(decodeResult, Number(rgx[7].replace(/ /g, "")));
+      decodeResult.remaining.text = rgx[8];
+      ResultFormatter.temperature(decodeResult, rgx[9].replace(/ /g, ""));
+    } else {
+      decodeResult.decoded = false;
+      decodeResult.remaining.text = message.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_4A_DIS.ts
+var Label_4A_DIS = class extends DecoderPlugin {
+  name = "label-4a-dis";
+  qualifiers() {
+    return {
+      labels: ["4A"],
+      preambles: ["DIS"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "Latest New Format";
+    decodeResult.decoded = true;
+    const fields = message.text.split(",");
+    ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[1].substring(2) + "00"));
+    ResultFormatter.callsign(decodeResult, fields[2]);
+    ResultFormatter.freetext(decodeResult, fields.slice(3).join(""));
+    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_4A_DOOR.ts
+var Label_4A_DOOR = class extends DecoderPlugin {
+  name = "label-4a-door";
+  qualifiers() {
+    return {
+      labels: ["4A"],
+      preambles: ["DOOR"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "Latest New Format";
+    decodeResult.decoded = true;
+    const fields = message.text.split(" ");
+    if (fields.length === 3) {
+      ResultFormatter.door_event(decodeResult, fields[0].split("/")[1], fields[1]);
+      ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[2] + "00"));
+    } 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_4A_Slash_01.ts
+var Label_4A_Slash_01 = class extends DecoderPlugin {
+  name = "label-4a-slash-01";
+  qualifiers() {
+    return {
+      labels: ["4A"],
+      preambles: ["/01"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "Latest New Format";
+    decodeResult.decoded = true;
+    if (message.text.length === 5 && message.text.substring(0, 4) === "/01-") {
+      decodeResult.remaining.text = message.text.substring(4);
+    } else {
+      decodeResult.decoded = false;
+      decodeResult.remaining.text = message.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_4N.ts
 var Label_4N = class extends DecoderPlugin {
   name = "label-4n";
@@ -1544,20 +1893,20 @@ var Label_4N = class extends DecoderPlugin {
     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}/)) {
+    let text2 = message.text;
+    if (text2.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);
+      text2 = text2.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(" ");
+    const fields = text2.split(",");
+    if (text2.length === 51) {
+      decodeResult.raw.day_of_month = text2.substring(0, 2);
+      ResultFormatter.departureAirport(decodeResult, text2.substring(8, 11));
+      ResultFormatter.arrivalAirport(decodeResult, text2.substring(13, 16));
+      ResultFormatter.position(decodeResult, CoordinateUtils.decodeStringCoordinatesDecimalMinutes(text2.substring(30, 45).replace(/^(.)0/, "$1")));
+      ResultFormatter.altitude(decodeResult, text2.substring(48, 51) * 100);
+      decodeResult.remaining.text = [text2.substring(2, 4), text2.substring(19, 29)].join(" ");
     } else if (fields.length === 33) {
       decodeResult.raw.date = fields[3];
       if (fields[1] === "B") {
@@ -1575,10 +1924,10 @@ var Label_4N = class extends DecoderPlugin {
       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;
+      decodeResult.remaining.text = text2;
     }
     if (decodeResult.decoded) {
-      if (decodeResult.remaining.text === "")
+      if (!decodeResult.remaining.text)
         decodeResult.decoder.decodeLevel = "full";
       else
         decodeResult.decoder.decodeLevel = "partial";
@@ -1766,14 +2115,14 @@ var Label_83 = class extends DecoderPlugin {
     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}/)) {
+    let text2 = message.text;
+    if (text2.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);
+      text2 = text2.substring(10);
     }
     decodeResult.decoded = true;
-    if (text.substring(0, 10) === "4DH3 ETAT2") {
-      const fields = text.split(/\s+/);
+    if (text2.substring(0, 10) === "4DH3 ETAT2") {
+      const fields = text2.split(/\s+/);
       if (fields[2].length > 5) {
         decodeResult.raw.day_of_month = fields[2].substring(5);
       }
@@ -1782,14 +2131,17 @@ var Label_83 = class extends DecoderPlugin {
       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);
+      ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[6] + "00"));
+    } else if (text2.substring(0, 5) === "001PR") {
+      decodeResult.raw.day_of_month = text2.substring(5, 7);
+      const position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(text2.substring(13, 28).replace(/\./g, ""));
+      if (position) {
+        ResultFormatter.position(decodeResult, position);
+      }
+      ResultFormatter.altitude(decodeResult, Number(text2.substring(28, 33)));
+      decodeResult.remaining.text = text2.substring(33);
     } else {
-      const fields = text.replace(/\s/g, "").split(",");
+      const fields = text2.replace(/\s/g, "").split(",");
       if (fields.length === 9) {
         ResultFormatter.departureAirport(decodeResult, fields[0]);
         ResultFormatter.arrivalAirport(decodeResult, fields[1]);
@@ -1802,7 +2154,7 @@ var Label_83 = class extends DecoderPlugin {
             longitude: Number(fields[4].replace(/\s/g, ""))
           }
         );
-        ResultFormatter.altitude(decodeResult, fields[5]);
+        ResultFormatter.altitude(decodeResult, Number(fields[5]));
         ResultFormatter.groundspeed(decodeResult, fields[6]);
         ResultFormatter.heading(decodeResult, fields[7]);
         decodeResult.remaining.text = fields[8];
@@ -1812,7 +2164,7 @@ var Label_83 = class extends DecoderPlugin {
       }
     }
     if (decodeResult.decoded) {
-      if (decodeResult.remaining.text === "")
+      if (!decodeResult.remaining.text)
         decodeResult.decoder.decodeLevel = "full";
       else
         decodeResult.decoder.decodeLevel = "partial";
@@ -1843,19 +2195,8 @@ var Label_8E = class extends DecoderPlugin {
         console.log(`Label 8E ETA: groups`);
         console.log(results.groups);
       }
-      decodeResult.formatted.items.push({
-        type: "eta",
-        code: "ETA",
-        label: "Estimated Time of Arrival",
-        value: DateTimeUtils.UTCToString(results.groups.arrival_eta)
-      });
-      decodeResult.raw.arrival_icao = results.groups.arrival_icao;
-      decodeResult.formatted.items.push({
-        type: "destination",
-        code: "DST",
-        label: "Destination",
-        value: decodeResult.raw.arrival_icao
-      });
+      ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(results.groups.arrival_eta + "00"));
+      ResultFormatter.arrivalAirport(decodeResult, results.groups.arrival_icao);
     }
     decodeResult.decoded = true;
     decodeResult.decoder.decodeLevel = "full";
@@ -1908,44 +2249,158 @@ var Label_ColonComma = class extends DecoderPlugin {
   }
 };
 
-// lib/plugins/Label_H1_FLR.ts
-var Label_H1_FLR = class extends DecoderPlugin {
-  name = "label-h1-flr";
+// lib/plugins/Label_H1_FLR.ts
+var Label_H1_FLR = class extends DecoderPlugin {
+  name = "label-h1-flr";
+  qualifiers() {
+    return {
+      labels: ["H1"],
+      preambles: ["FLR", "#CFBFLR"]
+    };
+  }
+  decode(message, options = {}) {
+    let decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "Fault Log Report";
+    decodeResult.message = message;
+    const parts = message.text.split("/FR");
+    if (parts.length > 1) {
+      decodeResult.remaining.text = "";
+      const fields = parts[0].split("/");
+      for (let i = 1; i < fields.length; i++) {
+        const field = fields[i];
+        if (field.startsWith("PN")) {
+          processUnknown(decodeResult, "/" + field);
+        } else {
+          processUnknown(decodeResult, "/" + field);
+        }
+      }
+      const data = parts[1].substring(0, 20);
+      const msg = parts[1].substring(20);
+      const datetime = data.substring(0, 12);
+      const date = datetime.substring(4, 6) + datetime.substring(2, 4) + datetime.substring(0, 2);
+      processUnknown(decodeResult, data.substring(12));
+      decodeResult.raw.message_timestamp = DateTimeUtils.convertDateTimeToEpoch(datetime.substring(6), date);
+      decodeResult.raw.fault_message = msg;
+      decodeResult.formatted.items.push({
+        type: "fault",
+        code: "FR",
+        label: "Fault Report",
+        value: decodeResult.raw.fault_message
+      });
+      decodeResult.decoded = true;
+      decodeResult.decoder.decodeLevel = "partial";
+    } else {
+      if (options.debug) {
+        console.log(`Decoder: Unknown H1 message: ${message.text}`);
+      }
+      decodeResult.remaining.text = message.text;
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+    }
+    return decodeResult;
+  }
+};
+function processUnknown(decodeResult, value) {
+  decodeResult.remaining.text += value;
+}
+
+// lib/plugins/Label_H1_OHMA.ts
+var zlib = __toESM(require("minizlib"));
+var Label_H1_OHMA = class extends DecoderPlugin {
+  name = "label-h1-ohma";
+  qualifiers() {
+    return {
+      labels: ["H1"],
+      preambles: ["OHMA", "/RTNBOCR.OHMA", "#T1B/RTNBOCR.OHMA"]
+    };
+  }
+  decode(message, options = {}) {
+    let decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "OHMA Message";
+    decodeResult.message = message;
+    decodeResult.remaining.text = "";
+    const data = message.text.split("OHMA")[1];
+    try {
+      const compressedBuffer = Buffer.from(data, "base64");
+      const decompress = new zlib.Inflate({ windowBits: 15 });
+      decompress.write(compressedBuffer);
+      decompress.flush(zlib.constants.Z_SYNC_FLUSH);
+      const result = decompress.read();
+      const jsonText = result.toString();
+      let formattedMsg;
+      let jsonMessage;
+      try {
+        jsonMessage = JSON.parse(jsonText).message;
+      } catch {
+        jsonMessage = jsonText;
+      }
+      try {
+        const ohmaMsg = JSON.parse(jsonMessage);
+        formattedMsg = JSON.stringify(ohmaMsg, null, 2);
+      } catch {
+        formattedMsg = jsonMessage;
+      }
+      decodeResult.decoded = true;
+      decodeResult.decoder.decodeLevel = "full";
+      decodeResult.raw.ohma = jsonText;
+      decodeResult.formatted.items.push({
+        type: "ohma",
+        code: "OHMA",
+        label: "OHMA Downlink",
+        value: formattedMsg
+      });
+    } catch (e) {
+      if (options.debug) {
+        console.log(`Decoder: Unknown H1 OHMA message: ${message.text}`, e);
+      }
+      decodeResult.remaining.text += message.text;
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+    }
+    return decodeResult;
+  }
+};
+
+// lib/plugins/Label_H1_WRN.ts
+var Label_H1_WRN = class extends DecoderPlugin {
+  name = "label-h1-wrn";
   qualifiers() {
     return {
       labels: ["H1"],
-      preambles: ["FLR", "#CFBFLR"]
+      preambles: ["WRN", "#CFBWRN"]
     };
   }
   decode(message, options = {}) {
     let decodeResult = this.defaultResult();
     decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "Fault Log Report";
+    decodeResult.formatted.description = "Warning Message";
     decodeResult.message = message;
-    const parts = message.text.split("/FR");
+    const parts = message.text.split("/WN");
     if (parts.length > 1) {
       decodeResult.remaining.text = "";
       const fields = parts[0].split("/");
       for (let i = 1; i < fields.length; i++) {
         const field = fields[i];
         if (field.startsWith("PN")) {
-          processUnknown(decodeResult, "/" + field);
+          processUnknown2(decodeResult, "/" + field);
         } else {
-          processUnknown(decodeResult, "/" + field);
+          processUnknown2(decodeResult, "/" + field);
         }
       }
       const data = parts[1].substring(0, 20);
       const msg = parts[1].substring(20);
       const datetime = data.substring(0, 12);
       const date = datetime.substring(4, 6) + datetime.substring(2, 4) + datetime.substring(0, 2);
-      processUnknown(decodeResult, data.substring(12));
+      processUnknown2(decodeResult, data.substring(12));
       decodeResult.raw.message_timestamp = DateTimeUtils.convertDateTimeToEpoch(datetime.substring(6), date);
-      decodeResult.raw.fault_message = msg;
+      decodeResult.raw.warning_message = msg;
       decodeResult.formatted.items.push({
-        type: "fault",
-        code: "FR",
-        label: "Fault Report",
-        value: decodeResult.raw.fault_message
+        type: "warning",
+        code: "WRN",
+        label: "Warning Message",
+        value: decodeResult.raw.warning_message
       });
       decodeResult.decoded = true;
       decodeResult.decoder.decodeLevel = "partial";
@@ -1960,7 +2415,7 @@ var Label_H1_FLR = class extends DecoderPlugin {
     return decodeResult;
   }
 };
-function processUnknown(decodeResult, value) {
+function processUnknown2(decodeResult, value) {
   decodeResult.remaining.text += value;
 }
 
@@ -2126,11 +2581,10 @@ function addCompanyRoute(decodeResult, value) {
 // lib/utils/h1_helper.ts
 var H1Helper = class {
   static decodeH1Message(decodeResult, message) {
-    let allKnownFields = true;
     const checksum = message.slice(-4);
     const data = message.slice(0, message.length - 4);
     const fields = data.split("/");
-    allKnownFields = allKnownFields && parseMessageType(decodeResult, fields[0]);
+    parseMessageType(decodeResult, fields[0]);
     for (let i = 1; i < fields.length; ++i) {
       if (fields[i].startsWith("FN")) {
         decodeResult.raw.flight_number = fields[i].substring(2);
@@ -2149,32 +2603,22 @@ var H1Helper = class {
         decodeResult.raw.message_timestamp = time;
       } else if (fields[i].startsWith("PS")) {
         const pos = processPS(decodeResult, fields[i].substring(2).split(","));
-        allKnownFields == allKnownFields && pos;
       } else if (fields[i].startsWith("DT")) {
         const data2 = fields[i].substring(2).split(",");
-        const dt = processDT(decodeResult, data2);
-        allKnownFields = allKnownFields && dt;
+        processDT(decodeResult, data2);
       } else if (fields[i].startsWith("ID")) {
         processIdentification(decodeResult, fields[i].substring(2).split(","));
       } else if (fields[i].startsWith("LR")) {
         const data2 = fields[i].substring(2).split(",");
-        const lr = processLR(decodeResult, data2);
-        allKnownFields = allKnownFields && lr;
+        processLR(decodeResult, data2);
       } else if (fields[i].startsWith("RI") || fields[i].startsWith("RF") || fields[i].startsWith("RP")) {
-        const fp = FlightPlanUtils.processFlightPlan(decodeResult, fields[i].split(":"));
-        allKnownFields = allKnownFields && fp;
+        FlightPlanUtils.processFlightPlan(decodeResult, fields[i].split(":"));
       } else if (fields[i].startsWith("PR")) {
-        allKnownFields = false;
         decodeResult.remaining.text += "/" + fields[i];
-      } else if (fields[i].startsWith("PS")) {
-        allKnownFields = false;
-        decodeResult.remaining.text += fields[i];
       } else if (fields[i].startsWith("AF")) {
-        const af = processAirField(decodeResult, fields[i].substring(2).split(","));
-        allKnownFields = allKnownFields && af;
+        processAirField(decodeResult, fields[i].substring(2).split(","));
       } else if (fields[i].startsWith("TD")) {
-        const td = processTimeOfDeparture(decodeResult, fields[i].substring(2).split(","));
-        allKnownFields = allKnownFields && td;
+        processTimeOfDeparture(decodeResult, fields[i].substring(2).split(","));
       } else if (fields[i].startsWith("FX")) {
         decodeResult.raw.free_text = fields[i].substring(2);
         decodeResult.formatted.items.push({
@@ -2185,23 +2629,21 @@ var H1Helper = class {
         });
       } else {
         decodeResult.remaining.text += "/" + fields[i];
-        allKnownFields = false;
       }
     }
     if (decodeResult.formatted.items.length > 0) {
       ResultFormatter.checksum(decodeResult, checksum);
     }
-    return allKnownFields;
+    return true;
   }
 };
 function processAirField(decodeResult, data) {
   if (data.length === 2) {
     ResultFormatter.departureAirport(decodeResult, data[0]);
     ResultFormatter.arrivalAirport(decodeResult, data[1]);
-    return true;
+  } else {
+    decodeResult.remaining.text += "AF/" + data.join(",");
   }
-  decodeResult.remaining.text += "AF/" + data.join(",");
-  return false;
 }
 function processTimeOfDeparture(decodeResult, data) {
   if (data.length === 2) {
@@ -2219,10 +2661,9 @@ function processTimeOfDeparture(decodeResult, data) {
       label: "Estimated Departure Time",
       value: `${data[1].substring(0, 2)}:${data[1].substring(2)}`
     });
-    return true;
+  } else {
+    decodeResult.remaining.text += "/TD" + data.join(",");
   }
-  decodeResult.remaining.text += "/TD" + data.join(",");
-  return false;
 }
 function processIdentification(decodeResult, data) {
   ResultFormatter.tail(decodeResult, data[0]);
@@ -2234,7 +2675,6 @@ function processIdentification(decodeResult, data) {
   }
 }
 function processDT(decodeResult, data) {
-  let allKnownFields = true;
   if (!decodeResult.raw.arrival_icao) {
     ResultFormatter.arrivalAirport(decodeResult, data[0]);
   } else if (decodeResult.raw.arrival_icao != data[0]) {
@@ -2247,19 +2687,16 @@ function processDT(decodeResult, data) {
     ResultFormatter.currentFuel(decodeResult, Number(data[2]));
   }
   if (data.length > 3) {
-    ResultFormatter.eta(decodeResult, data[3]);
+    ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(data[3]));
   }
   if (data.length > 4) {
     ResultFormatter.remainingFuel(decodeResult, Number(data[4]));
   }
   if (data.length > 5) {
-    allKnownFields = false;
     decodeResult.remaining.text += "," + data.slice(5).join(",");
   }
-  return allKnownFields;
 }
 function processLR(decodeResult, data) {
-  let allKnownFields = true;
   if (data.length === 19) {
     ResultFormatter.unknown(decodeResult, data[1]);
     ResultFormatter.flightNumber(decodeResult, data[2]);
@@ -2267,34 +2704,47 @@ function processLR(decodeResult, data) {
     ResultFormatter.arrivalAirport(decodeResult, data[4]);
     ResultFormatter.arrivalRunway(decodeResult, data[5]);
     ResultFormatter.unknown(decodeResult, data.slice(6, 19).join(","));
-    allKnownFields = false;
   } else {
-    allKnownFields = false;
+    ResultFormatter.unknown(decodeResult, data.join(","));
   }
-  return allKnownFields;
 }
 function parseMessageType(decodeResult, messageType) {
-  let decoded = true;
   const parts = messageType.split("#");
   if (parts.length == 1) {
-    if (parts[0].startsWith("POS") && parts[0].length !== 3 && !parts[0].startsWith("POS/")) {
-      decoded = processPosition2(decodeResult, parts[0].substring(3).split(","));
+    const type = parts[0].substring(0, 3);
+    if (type === "POS" && parts[0].length !== 3) {
+      processPosition2(decodeResult, parts[0].substring(3).split(","));
     }
-    return decoded;
+    return processMessageType(decodeResult, type);
   } else if (parts.length == 2) {
     if (parts[0].length > 0) {
       decodeResult.remaining.text += parts[0].substring(0, 3);
       decodeResult.raw.flight_number = parts[0].substring(3);
-      decodeResult.remaining.text += "#" + parts[1].substring(0, 3);
+      decodeResult.remaining.text += "#" + (parts[1].length == 5 ? parts[1].substring(0, 2) : parts[1].substring(0, 3));
     }
-    if (parts[1].substring(3, 6) === "POS" && parts[1].length !== 6 && parts[1].substring(3, 7) !== "POS/") {
-      decoded = processPosition2(decodeResult, parts[1].substring(6).split(","));
+    const type = parts[1].length == 5 ? parts[1].substring(2, 5) : parts[1].substring(3, 6);
+    if (parts[1].substring(3, 6) === "POS" && parts[1].length > 6) {
+      processPosition2(decodeResult, parts[1].substring(6).split(","));
     }
-    decodeResult.raw.message_type = messageType;
-    return decoded;
+    processMessageType(decodeResult, type);
+  } else {
+    decodeResult.remaining.text += messageType;
+  }
+}
+function processMessageType(decodeResult, type) {
+  if (type === "FPN") {
+    decodeResult.formatted.description = "Flight Plan";
+  } else if (type === "FTX") {
+    decodeResult.formatted.description = "Free Text";
+  } else if (type === "INI") {
+    decodeResult.formatted.description = "Flight Plan Initial Report";
+  } else if (type === "POS") {
+    decodeResult.formatted.description = "Position Report";
+  } else if (type === "PRG") {
+    decodeResult.formatted.description = "Progress Report";
+  } else {
+    decodeResult.formatted.description = "Unknown H1 Message";
   }
-  decodeResult.remaining.text += messageType;
-  return false;
 }
 function processDC(decodeResult, data) {
   decodeResult.raw.message_date = data[0];
@@ -2303,13 +2753,9 @@ function processDC(decodeResult, data) {
     const date = data[0].substring(2, 4) + data[0].substring(0, 2) + data[0].substring(4, 6);
     const time = DateTimeUtils.convertDateTimeToEpoch(data[1], data[0]);
     decodeResult.raw.message_timestamp = time;
-  } else {
-    return false;
   }
-  return true;
 }
 function processPS(decodeResult, data) {
-  let allKnownFields = true;
   const position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(data[0]);
   if (position) {
     decodeResult.raw.position = position;
@@ -2319,8 +2765,6 @@ function processPS(decodeResult, data) {
       label: "Aircraft Position",
       value: CoordinateUtils.coordinateString(position)
     });
-  } else {
-    allKnownFields = false;
   }
   if (data.length === 9) {
     processRoute(decodeResult, data[3], data[1], data[5], data[4], void 0);
@@ -2339,11 +2783,8 @@ function processPS(decodeResult, data) {
     ResultFormatter.unknown(decodeResult, data[9]);
     ResultFormatter.unknown(decodeResult, data.slice(11).join(","));
   }
-  allKnownFields = false;
-  return allKnownFields;
 }
 function processPosition2(decodeResult, data) {
-  let allKnownFields = true;
   const position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(data[0]);
   if (position) {
     decodeResult.raw.position = position;
@@ -2353,8 +2794,6 @@ function processPosition2(decodeResult, data) {
       label: "Aircraft Position",
       value: CoordinateUtils.coordinateString(position)
     });
-  } else {
-    allKnownFields = false;
   }
   if (data.length >= 10) {
     ResultFormatter.altitude(decodeResult, Number(data[3]) * 100);
@@ -2369,8 +2808,6 @@ function processPosition2(decodeResult, data) {
     ResultFormatter.unknown(decodeResult, data[12]);
     ResultFormatter.unknown(decodeResult, data[13]);
   }
-  allKnownFields = false;
-  return allKnownFields;
 }
 function processRoute(decodeResult, last, time, next, eta, then, date) {
   const lastTime = date ? DateTimeUtils.convertDateTimeToEpoch(time, date) : DateTimeUtils.convertHHMMSSToTod(time);
@@ -2393,175 +2830,23 @@ function processRoute(decodeResult, last, time, next, eta, then, date) {
   });
 }
 
-// lib/plugins/Label_H1_FPN.ts
-var Label_H1_FPN = class extends DecoderPlugin {
-  name = "label-h1-fpn";
+// lib/plugins/Label_H1.ts
+var Label_H1 = class extends DecoderPlugin {
+  name = "label-h1";
   qualifiers() {
     return {
-      labels: ["H1"],
-      preambles: ["FPN", "#M1BFPN"]
+      labels: ["H1"]
     };
   }
   decode(message, options = {}) {
     let decodeResult = this.defaultResult();
     decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "Flight Plan";
     decodeResult.message = message;
     decodeResult.remaining.text = "";
     const msg = message.text.replace(/\n|\r/g, "");
-    const fulllyDecoded = H1Helper.decodeH1Message(decodeResult, msg);
-    decodeResult.decoded = true;
-    decodeResult.decoder.decodeLevel = fulllyDecoded ? "full" : "partial";
-    if (decodeResult.formatted.items.length === 0) {
-      if (options.debug) {
-        console.log(`Decoder: Unknown H1 message: ${message.text}`);
-      }
-      decodeResult.remaining.text = message.text;
-      decodeResult.decoded = false;
-      decodeResult.decoder.decodeLevel = "none";
-    }
-    return decodeResult;
-  }
-};
-
-// lib/plugins/Label_H1_FTX.ts
-var Label_H1_FTX = class extends DecoderPlugin {
-  name = "label-h1-ftx";
-  qualifiers() {
-    return {
-      labels: ["H1"],
-      preambles: ["FTX", "- #MDFTX"]
-    };
-  }
-  decode(message, options = {}) {
-    let decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "Free Text";
-    decodeResult.message = message;
-    decodeResult.remaining.text = "";
-    const fulllyDecoded = H1Helper.decodeH1Message(decodeResult, message.text);
-    decodeResult.decoded = true;
-    decodeResult.decoder.decodeLevel = fulllyDecoded ? "full" : "partial";
-    if (decodeResult.formatted.items.length === 0) {
-      if (options.debug) {
-        console.log(`Decoder: Unknown H1 message: ${message.text}`);
-      }
-      decodeResult.remaining.text = message.text;
-      decodeResult.decoded = false;
-      decodeResult.decoder.decodeLevel = "none";
-    }
-    return decodeResult;
-  }
-};
-
-// lib/plugins/Label_H1_INI.ts
-var Label_H1_INI = class extends DecoderPlugin {
-  // eslint-disable-line camelcase
-  name = "label-h1-ini";
-  qualifiers() {
-    return {
-      labels: ["H1"],
-      preambles: ["INI", "- #MDINI"]
-    };
-  }
-  decode(message, options = {}) {
-    const decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "Flight Plan Initial Report";
-    decodeResult.message = message;
-    decodeResult.remaining.text = "";
-    const fulllyDecoded = H1Helper.decodeH1Message(decodeResult, message.text);
-    decodeResult.decoded = true;
-    decodeResult.decoder.decodeLevel = fulllyDecoded ? "full" : "partial";
-    if (decodeResult.formatted.items.length === 0) {
-      if (options.debug) {
-        console.log(`Decoder: Unknown H1 message: ${message.text}`);
-      }
-      decodeResult.remaining.text = message.text;
-      decodeResult.decoded = false;
-      decodeResult.decoder.decodeLevel = "none";
-    }
-    return decodeResult;
-  }
-};
-
-// lib/plugins/Label_H1_OHMA.ts
-var zlib = __toESM(require("minizlib"));
-var Label_H1_OHMA = class extends DecoderPlugin {
-  name = "label-h1-ohma";
-  qualifiers() {
-    return {
-      labels: ["H1"],
-      preambles: ["OHMA", "/RTNBOCR.OHMA", "#T1B/RTNBOCR.OHMA"]
-    };
-  }
-  decode(message, options = {}) {
-    let decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "OHMA Message";
-    decodeResult.message = message;
-    decodeResult.remaining.text = "";
-    const data = message.text.split("OHMA")[1];
-    try {
-      const compressedBuffer = Buffer.from(data, "base64");
-      const decompress = new zlib.Inflate({ windowBits: 15 });
-      decompress.write(compressedBuffer);
-      decompress.flush(zlib.constants.Z_SYNC_FLUSH);
-      const result = decompress.read();
-      const jsonText = result.toString();
-      let formattedMsg;
-      let jsonMessage;
-      try {
-        jsonMessage = JSON.parse(jsonText).message;
-      } catch {
-        jsonMessage = jsonText;
-      }
-      try {
-        const ohmaMsg = JSON.parse(jsonMessage);
-        formattedMsg = JSON.stringify(ohmaMsg, null, 2);
-      } catch {
-        formattedMsg = jsonMessage;
-      }
-      decodeResult.decoded = true;
-      decodeResult.decoder.decodeLevel = "full";
-      decodeResult.raw.ohma = jsonText;
-      decodeResult.formatted.items.push({
-        type: "ohma",
-        code: "OHMA",
-        label: "OHMA Downlink",
-        value: formattedMsg
-      });
-    } catch (e) {
-      if (options.debug) {
-        console.log(`Decoder: Unknown H1 OHMA message: ${message.text}`, e);
-      }
-      decodeResult.remaining.text += message.text;
-      decodeResult.decoded = false;
-      decodeResult.decoder.decodeLevel = "none";
-    }
-    return decodeResult;
-  }
-};
-
-// lib/plugins/Label_H1_POS.ts
-var Label_H1_POS = class extends DecoderPlugin {
-  name = "label-h1-pos";
-  qualifiers() {
-    return {
-      labels: ["H1", "4J"],
-      preambles: ["POS", "#M1BPOS", "/.POS"]
-      //TODO - support data before #
-    };
-  }
-  decode(message, options = {}) {
-    let decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "Position Report";
-    decodeResult.message = message;
-    decodeResult.remaining.text = "";
-    const fulllyDecoded = H1Helper.decodeH1Message(decodeResult, message.text);
-    decodeResult.decoded = true;
-    decodeResult.decoder.decodeLevel = fulllyDecoded ? "full" : "partial";
+    const decoded = H1Helper.decodeH1Message(decodeResult, msg);
+    decodeResult.decoded = decoded;
+    decodeResult.decoder.decodeLevel = decodeResult.remaining.text.length === 0 ? "full" : "partial";
     if (decodeResult.formatted.items.length === 0) {
       if (options.debug) {
         console.log(`Decoder: Unknown H1 message: ${message.text}`);
@@ -2574,62 +2859,6 @@ var Label_H1_POS = class extends DecoderPlugin {
   }
 };
 
-// lib/plugins/Label_H1_WRN.ts
-var Label_H1_WRN = class extends DecoderPlugin {
-  name = "label-h1-wrn";
-  qualifiers() {
-    return {
-      labels: ["H1"],
-      preambles: ["WRN", "#CFBWRN"]
-    };
-  }
-  decode(message, options = {}) {
-    let decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "Warning Message";
-    decodeResult.message = message;
-    const parts = message.text.split("/WN");
-    if (parts.length > 1) {
-      decodeResult.remaining.text = "";
-      const fields = parts[0].split("/");
-      for (let i = 1; i < fields.length; i++) {
-        const field = fields[i];
-        if (field.startsWith("PN")) {
-          processUnknown2(decodeResult, "/" + field);
-        } else {
-          processUnknown2(decodeResult, "/" + field);
-        }
-      }
-      const data = parts[1].substring(0, 20);
-      const msg = parts[1].substring(20);
-      const datetime = data.substring(0, 12);
-      const date = datetime.substring(4, 6) + datetime.substring(2, 4) + datetime.substring(0, 2);
-      processUnknown2(decodeResult, data.substring(12));
-      decodeResult.raw.message_timestamp = DateTimeUtils.convertDateTimeToEpoch(datetime.substring(6), date);
-      decodeResult.raw.warning_message = msg;
-      decodeResult.formatted.items.push({
-        type: "warning",
-        code: "WRN",
-        label: "Warning Message",
-        value: decodeResult.raw.warning_message
-      });
-      decodeResult.decoded = true;
-      decodeResult.decoder.decodeLevel = "partial";
-    } else {
-      if (options.debug) {
-        console.log(`Decoder: Unknown H1 message: ${message.text}`);
-      }
-      decodeResult.remaining.text = message.text;
-      decodeResult.decoded = false;
-      decodeResult.decoder.decodeLevel = "none";
-    }
-    return decodeResult;
-  }
-};
-function processUnknown2(decodeResult, value) {
-  decodeResult.remaining.text += value;
-}
-
 // lib/plugins/Label_HX.ts
 var Label_HX = class extends DecoderPlugin {
   name = "label-hx";
@@ -2673,7 +2902,7 @@ var Label_HX = class extends DecoderPlugin {
       });
     }
     if (decodeResult.decoded) {
-      if (decodeResult.remaining.text === "")
+      if (!decodeResult.remaining.text)
         decodeResult.decoder.decodeLevel = "full";
       else
         decodeResult.decoder.decodeLevel = "partial";
@@ -2828,7 +3057,7 @@ var Label_QR = class extends DecoderPlugin {
       }
     ];
     decodeResult.decoded = true;
-    if (decodeResult.remaining.text === "")
+    if (!decodeResult.remaining.text)
       decodeResult.decoder.decodeLevel = "full";
     else
       decodeResult.decoder.decodeLevel = "partial";
@@ -2873,7 +3102,7 @@ var Label_QP = class extends DecoderPlugin {
       }
     ];
     decodeResult.decoded = true;
-    if (decodeResult.remaining.text === "")
+    if (!decodeResult.remaining.text)
       decodeResult.decoder.decodeLevel = "full";
     else
       decodeResult.decoder.decodeLevel = "partial";
@@ -2918,7 +3147,7 @@ var Label_QS = class extends DecoderPlugin {
       }
     ];
     decodeResult.decoded = true;
-    if (decodeResult.remaining.text === "")
+    if (!decodeResult.remaining.text)
       decodeResult.decoder.decodeLevel = "full";
     else
       decodeResult.decoder.decodeLevel = "partial";
@@ -2980,7 +3209,7 @@ var Label_QQ = class extends DecoderPlugin {
       });
     }
     decodeResult.decoded = true;
-    if (decodeResult.remaining.text === "")
+    if (!decodeResult.remaining.text)
       decodeResult.decoder.decodeLevel = "full";
     else
       decodeResult.decoder.decodeLevel = "partial";
@@ -3800,7 +4029,7 @@ var MessageDecoder = class {
     this.plugins = [];
     this.debug = false;
     this.registerPlugin(new Label_ColonComma(this));
-    this.registerPlugin(new Label_5Z(this));
+    this.registerPlugin(new Label_5Z_Slash(this));
     this.registerPlugin(new Label_10_LDR(this));
     this.registerPlugin(new Label_10_POS(this));
     this.registerPlugin(new Label_10_Slash(this));
@@ -3811,21 +4040,24 @@ var MessageDecoder = class {
     this.registerPlugin(new Label_16_N_Space(this));
     this.registerPlugin(new Label_20_POS(this));
     this.registerPlugin(new Label_21_POS(this));
+    this.registerPlugin(new Label_24_Slash(this));
     this.registerPlugin(new Label_30_Slash_EA(this));
     this.registerPlugin(new Label_44_ETA(this));
     this.registerPlugin(new Label_44_IN(this));
     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_4A(this));
+    this.registerPlugin(new Label_4A_01(this));
+    this.registerPlugin(new Label_4A_DIS(this));
+    this.registerPlugin(new Label_4A_DOOR(this));
+    this.registerPlugin(new Label_4A_Slash_01(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));
-    this.registerPlugin(new Label_H1_FTX(this));
-    this.registerPlugin(new Label_H1_INI(this));
     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_H1(this));
     this.registerPlugin(new Label_HX(this));
     this.registerPlugin(new Label_80(this));
     this.registerPlugin(new Label_83(this));
@@ -3873,29 +4105,30 @@ var MessageDecoder = class {
       console.log("Usable plugins");
       console.log(usablePlugins);
     }
-    let result;
-    if (usablePlugins.length > 0) {
-      const plugin = usablePlugins[0];
+    let result = {
+      decoded: false,
+      error: "No known decoder plugin for this message",
+      decoder: {
+        name: "none",
+        type: "none",
+        decodeLevel: "none"
+      },
+      message,
+      remaining: {
+        text: message.text
+      },
+      raw: {},
+      formatted: {
+        description: "Not Decoded",
+        items: []
+      }
+    };
+    for (let i = 0; i < usablePlugins.length; i++) {
+      const plugin = usablePlugins[i];
       result = plugin.decode(message);
-    } else {
-      result = {
-        decoded: false,
-        error: "No known decoder plugin for this message",
-        decoder: {
-          name: "none",
-          type: "none",
-          decodeLevel: "none"
-        },
-        message,
-        remaining: {
-          text: message.text
-        },
-        raw: {},
-        formatted: {
-          description: "Not Decoded",
-          items: []
-        }
-      };
+      if (result.decoded) {
+        break;
+      }
     }
     if (options.debug) {
       console.log("Result");