npm - @airframes/acars-decoder - Versions diffs - 1.6.10 → 1.6.12 - Mend

@airframes/acars-decoder 1.6.10 → 1.6.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js CHANGED Viewed

@@ -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;
@@ -154,10 +222,137 @@ var CoordinateUtils = class {
     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/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({
@@ -178,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({
@@ -197,24 +417,53 @@ 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 eta(decodeResult, value) {
-    decodeResult.raw.eta_time = value;
+  static alternateAirport(decodeResult, value) {
+    decodeResult.raw.alternate_icao = 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)
+      type: "icao",
+      code: "ALT_DST",
+      label: "Alternate Destination",
+      value: decodeResult.raw.alternate_icao
     });
   }
+  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;
     decodeResult.formatted.items.push({
@@ -224,6 +473,15 @@ var ResultFormatter = class {
       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({
@@ -257,16 +515,16 @@ var ResultFormatter = class {
       type: "aircraft_groundspeed",
       code: "GSPD",
       label: "Aircraft Groundspeed",
-      value: `${decodeResult.raw.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.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) {
@@ -278,14 +536,77 @@ var ResultFormatter = class {
       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;
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "OUT",
+      label: "Out of Gate Time",
+      value: DateTimeUtils.timestampToString(time, "tod")
+    });
+  }
+  static off(decodeResult, time) {
+    decodeResult.raw.off_time = time;
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "OFF",
+      label: "Takeoff Time",
+      value: DateTimeUtils.timestampToString(time, "tod")
+    });
+  }
+  static on(decodeResult, time) {
+    decodeResult.raw.on_time = time;
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "ON",
+      label: "Landing Time",
+      value: DateTimeUtils.timestampToString(time, "tod")
+    });
+  }
+  static in(decodeResult, time) {
+    decodeResult.raw.in_time = time;
+    decodeResult.formatted.items.push({
+      type: "time_of_day",
+      code: "IN",
+      label: "In Gate Time",
+      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) {
     decodeResult.remaining.text += "," + value;
   }
 };
-// 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",
@@ -303,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",
@@ -313,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}`);
@@ -384,7 +740,7 @@ var Label_10_LDR = class extends DecoderPlugin {
     decodeResult.message = message;
     const parts = message.text.split(",");
     if (parts.length < 17) {
-      if (options?.debug) {
+      if (options.debug) {
         console.log(`Decoder: Unknown 10 message: ${message.text}`);
       }
       decodeResult.remaining.text = message.text;
@@ -402,8 +758,13 @@ var Label_10_LDR = class extends DecoderPlugin {
     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]);
-    decodeResult.remaining.text = [...parts.slice(0, 5), parts[11], ...parts.slice(13)].join(",");
+    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;
@@ -427,7 +788,7 @@ var Label_10_POS = class extends DecoderPlugin {
     decodeResult.message = message;
     const parts = message.text.split(",");
     if (parts.length !== 12) {
-      if (options?.debug) {
+      if (options.debug) {
         console.log(`Decoder: Unknown 10 message: ${message.text}`);
       }
       decodeResult.remaining.text = message.text;
@@ -450,153 +811,30 @@ 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();
+// 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: ["/"]
+    };
   }
-  // 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
-  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;
+  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[1];
     const lon = parts[2];
@@ -608,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]
     }, {
@@ -685,6 +923,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";
@@ -851,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";
@@ -896,11 +1209,11 @@ 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) {
@@ -914,7 +1227,9 @@ 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) {
@@ -928,7 +1243,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";
     }
@@ -952,25 +1269,25 @@ 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]);
+      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";
     } 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,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;
@@ -987,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";
@@ -1047,20 +1371,9 @@ var Label_30_Slash_EA = class extends DecoderPlugin {
         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
-      });
+    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]);
@@ -1352,23 +1665,296 @@ var Label_44_POS = class extends DecoderPlugin {
   }
 };
-// lib/plugins/Label_80.ts
-var Label_80 = class extends DecoderPlugin {
-  name = "label-80";
-  descriptions = {
-    ALT: "Altitude",
-    DWND: "Wind Direction",
-    ETA: "Estimated Time of Arrival",
-    FOB: "Fuel on Board",
-    FL: "Flight Level",
-    HDG: "Heading",
-    MCH: "Aircraft Speed",
-    NWYP: "Next Waypoint",
-    POS: "Aircraft Position",
-    SAT: "Static Air Temperature",
-    SWND: "Wind Speed",
-    TAS: "True Airspeed",
-    WYP: "Waypoint"
+// 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";
+  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 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 (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") {
+        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 = 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_80.ts
+var Label_80 = class extends DecoderPlugin {
+  name = "label-80";
+  descriptions = {
+    ALT: "Altitude",
+    DWND: "Wind Direction",
+    ETA: "Estimated Time of Arrival",
+    FOB: "Fuel on Board",
+    FL: "Flight Level",
+    HDG: "Heading",
+    MCH: "Aircraft Speed",
+    NWYP: "Next Waypoint",
+    POS: "Aircraft Position",
+    SAT: "Static Air Temperature",
+    SWND: "Wind Speed",
+    TAS: "True Airspeed",
+    WYP: "Waypoint"
   };
   qualifiers() {
     return {
@@ -1383,27 +1969,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({
@@ -1425,15 +1999,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": {
@@ -1447,9 +2015,8 @@ var Label_80 = class extends DecoderPlugin {
               break;
             }
             case "FL": {
-              const flight_level = match.groups.value;
-              decodeResult.raw.altitude = flight_level * 100;
-              ResultFormatter.altitude(decodeResult, decodeResult.raw.altitude);
+              const flight_level = Number(match.groups.value);
+              ResultFormatter.altitude(decodeResult, flight_level * 100);
               break;
             }
             case "FOB": {
@@ -1473,7 +2040,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",
@@ -1495,20 +2062,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": {
@@ -1522,7 +2082,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,
@@ -1536,7 +2096,80 @@ var Label_80 = class extends DecoderPlugin {
         }
       }
       decodeResult.decoded = true;
-      decodeResult.decodeLevel = "partial";
+      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 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;
+    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);
+      }
+      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, 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 = text2.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, Number(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;
+      }
+    }
+    if (decodeResult.decoded) {
+      if (!decodeResult.remaining.text)
+        decodeResult.decoder.decodeLevel = "full";
+      else
+        decodeResult.decoder.decodeLevel = "partial";
+    } else {
+      decodeResult.decoder.decodeLevel = "none";
     }
     return decodeResult;
   }
@@ -1562,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";
@@ -1627,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";
@@ -1679,7 +2415,7 @@ var Label_H1_FLR = class extends DecoderPlugin {
     return decodeResult;
   }
 };
-function processUnknown(decodeResult, value) {
+function processUnknown2(decodeResult, value) {
   decodeResult.remaining.text += value;
 }
@@ -1845,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);
@@ -1868,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({
@@ -1904,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) {
@@ -1938,19 +2661,12 @@ 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) {
-  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];
   }
@@ -1959,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]) {
@@ -1972,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]);
@@ -1992,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];
@@ -2028,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;
@@ -2044,11 +2765,7 @@ function processPS(decodeResult, data) {
       label: "Aircraft Position",
       value: CoordinateUtils.coordinateString(position)
     });
-  } 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);
@@ -2066,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;
@@ -2080,11 +2794,7 @@ function processPosition2(decodeResult, data) {
       label: "Aircraft Position",
       value: CoordinateUtils.coordinateString(position)
     });
-  } 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]);
@@ -2098,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);
@@ -2122,229 +2830,24 @@ 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}`);
-      }
-      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: ["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}`);
       }
@@ -2355,9 +2858,6 @@ var Label_H1_WRN = class extends DecoderPlugin {
     return decodeResult;
   }
 };
-function processUnknown2(decodeResult, value) {
-  decodeResult.remaining.text += value;
-}
 // lib/plugins/Label_HX.ts
 var Label_HX = class extends DecoderPlugin {
@@ -2402,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";
@@ -2557,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";
@@ -2602,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";
@@ -2647,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";
@@ -2709,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";
@@ -3529,32 +4029,38 @@ 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));
     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));
     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));
     this.registerPlugin(new Label_8E(this));
     this.registerPlugin(new Label_1M_Slash(this));
     this.registerPlugin(new Label_SQ(this));
@@ -3599,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");