@airframes/acars-decoder 1.8.2 → 1.8.4

package/dist/index.mjs

@@ -140,7 +140,6 @@ var CoordinateUtils = class _CoordinateUtils {
    * @returns An object with latitude and longitude properties
    */
   static decodeStringCoordinates(stringCoords) {
-    var results = {};
     const firstChar = stringCoords.substring(0, 1);
     let middleChar = stringCoords.substring(6, 7);
     let longitudeChars = stringCoords.substring(7, 13);
@@ -149,12 +148,12 @@ var CoordinateUtils = class _CoordinateUtils {
       longitudeChars = stringCoords.substring(8, 14);
     }
     if ((firstChar === "N" || firstChar === "S") && (middleChar === "W" || middleChar === "E")) {
-      results.latitude = Number(stringCoords.substring(1, 6)) / 1e3 * _CoordinateUtils.getDirection(firstChar);
-      results.longitude = Number(longitudeChars) / 1e3 * _CoordinateUtils.getDirection(middleChar);
-    } else {
-      return;
+      return {
+        latitude: Number(stringCoords.substring(1, 6)) / 1e3 * _CoordinateUtils.getDirection(firstChar),
+        longitude: Number(longitudeChars) / 1e3 * _CoordinateUtils.getDirection(middleChar)
+      };
     }
-    return results;
+    return void 0;
   }
   /**
   * Decode a string of coordinates into an object with latitude and longitude in degrees and decimal minutes
@@ -163,7 +162,6 @@ var CoordinateUtils = class _CoordinateUtils {
   * @returns An object with latitude and longitude properties
   */
   static decodeStringCoordinatesDecimalMinutes(stringCoords) {
-    var results = {};
     const firstChar = stringCoords.substring(0, 1);
     let middleChar = stringCoords.substring(6, 7);
     let longitudeChars = stringCoords.substring(7, 13);
@@ -176,12 +174,12 @@ var CoordinateUtils = class _CoordinateUtils {
     const lonDeg = Math.trunc(Number(longitudeChars) / 1e3);
     const lonMin = Number(longitudeChars) % 1e3 / 10;
     if ((firstChar === "N" || firstChar === "S") && (middleChar === "W" || middleChar === "E")) {
-      results.latitude = (latDeg + latMin / 60) * _CoordinateUtils.getDirection(firstChar);
-      results.longitude = (lonDeg + lonMin / 60) * _CoordinateUtils.getDirection(middleChar);
-    } else {
-      return;
+      return {
+        latitude: (latDeg + latMin / 60) * _CoordinateUtils.getDirection(firstChar),
+        longitude: (lonDeg + lonMin / 60) * _CoordinateUtils.getDirection(middleChar)
+      };
     }
-    return results;
+    return void 0;
   }
   static coordinateString(coords) {
     const latDir = coords.latitude > 0 ? "N" : "S";
@@ -475,6 +473,15 @@ var ResultFormatter = class {
       value: decodeResult.raw.fuel_on_board.toString()
     });
   }
+  static burnedFuel(decodeResult, value) {
+    decodeResult.raw.fuel_burned = value;
+    decodeResult.formatted.items.push({
+      type: "fuel_burned",
+      code: "FB",
+      label: "Fuel Burned",
+      value: decodeResult.raw.fuel_burned.toString()
+    });
+  }
   static remainingFuel(decodeResult, value) {
     decodeResult.raw.fuel_remaining = value;
     decodeResult.formatted.items.push({
@@ -650,6 +657,24 @@ var ResultFormatter = class {
       value: text
     });
   }
+  static mac(decodeResult, mac) {
+    decodeResult.raw.mac = mac;
+    decodeResult.formatted.items.push({
+      type: "mac",
+      code: "MAC",
+      label: "Mean Aerodynamic Chord",
+      value: `${mac} %`
+    });
+  }
+  static trim(decodeResult, trim) {
+    decodeResult.raw.trim = trim;
+    decodeResult.formatted.items.push({
+      type: "trim",
+      code: "TRIM",
+      label: "Trim",
+      value: `${trim} units`
+    });
+  }
   static windData(decodeResult, windData) {
     decodeResult.raw.wind_data = windData;
     for (const wind of windData) {
@@ -665,6 +690,64 @@ var ResultFormatter = class {
       });
     }
   }
+  static cg(decodeResult, value, type = "center") {
+    switch (type) {
+      case "center":
+        decodeResult.raw.center_of_gravity = value;
+        decodeResult.formatted.items.push({
+          type: "center_of_gravity",
+          code: "CG",
+          label: "Center of Gravity",
+          value: `${decodeResult.raw.center_of_gravity} %`
+        });
+        break;
+      case "lower":
+        decodeResult.raw.cg_lower_limit = value;
+        decodeResult.formatted.items.push({
+          type: "cg_lower_limit",
+          code: "CG_LOWER",
+          label: "Center of Gravity Lower Limit",
+          value: `${decodeResult.raw.cg_lower_limit} %`
+        });
+        break;
+      case "upper":
+        decodeResult.raw.cg_upper_limit = value;
+        decodeResult.formatted.items.push({
+          type: "cg_upper_limit",
+          code: "CG_UPPER",
+          label: "Center of Gravity Upper Limit",
+          value: `${decodeResult.raw.cg_upper_limit} %`
+        });
+        break;
+    }
+  }
+  static version(decodeResult, value) {
+    decodeResult.raw.version = value;
+    decodeResult.formatted.items.push({
+      type: "version",
+      code: "VERSION",
+      label: "Message Version",
+      value: `v${decodeResult.raw.version.toFixed(1)}`
+    });
+  }
+  static label(decodeResult, value) {
+    decodeResult.raw.label = value;
+    decodeResult.formatted.items.push({
+      type: "label",
+      code: "LABEL",
+      label: "Message Label",
+      value: `${decodeResult.raw.label}`
+    });
+  }
+  static sublabel(decodeResult, value) {
+    decodeResult.raw.sublabel = value;
+    decodeResult.formatted.items.push({
+      type: "sublabel",
+      code: "SUBLABEL",
+      label: "Message Sublabel",
+      value: `${decodeResult.raw.sublabel}`
+    });
+  }
   static unknown(decodeResult, value, sep = ",") {
     if (!decodeResult.remaining.text)
       decodeResult.remaining.text = value;
@@ -1498,6 +1581,14 @@ var FlightPlanUtils = class _FlightPlanUtils {
         label: "Route Status",
         value: "Route Inactive"
       });
+    } else if (header.startsWith("RM")) {
+      decodeResult.raw.route_status = "RM";
+      decodeResult.formatted.items.push({
+        type: "status",
+        code: "ROUTE_STATUS",
+        label: "Route Status",
+        value: "Route Mapped"
+      });
     } else {
       decodeResult.remaining.text += header;
       allKnownFields = false;
@@ -1573,6 +1664,11 @@ var H1Helper = class _H1Helper {
   static decodeH1Message(decodeResult, message) {
     const checksum = message.slice(-4);
     const data = message.slice(0, message.length - 4);
+    if (calculateChecksum(data) !== checksum) {
+      decodeResult.decoded = false;
+      decodeResult.decoder.decodeLevel = "none";
+      return false;
+    }
     const fields = data.split("/");
     const canDecode = parseMessageType(decodeResult, fields[0]);
     if (!canDecode) {
@@ -1581,53 +1677,71 @@ var H1Helper = class _H1Helper {
       return false;
     }
     for (let i = 1; i < fields.length; ++i) {
-      if (fields[i].startsWith("FN")) {
-        decodeResult.raw.flight_number = fields[i].substring(2);
-      } else if (fields[i].startsWith("SN")) {
-        decodeResult.raw.serial_number = fields[i].substring(2);
-      } else if (fields[i].startsWith("DC")) {
-        processDC(decodeResult, fields[i].substring(2).split(","));
-      } else if (fields[i].startsWith("TS")) {
-        _H1Helper.processTS(decodeResult, fields[i].substring(2).split(","));
-      } else if (fields[i].startsWith("PS")) {
-        _H1Helper.processPS(decodeResult, fields[i].substring(2).split(","));
-      } else if (fields[i].startsWith("DT")) {
-        const data2 = fields[i].substring(2).split(",");
-        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(",");
-        processLR(decodeResult, data2);
-      } else if (fields[i].startsWith("RI") || fields[i].startsWith("RF") || fields[i].startsWith("RP")) {
-        FlightPlanUtils.processFlightPlan(decodeResult, fields[i].split(":"));
-      } else if (fields[i].startsWith("PR")) {
-        ResultFormatter.unknown(decodeResult, fields[i], "/");
-      } else if (fields[i].startsWith("AF")) {
-        processAirField(decodeResult, fields[i].substring(2).split(","));
-      } else if (fields[i].startsWith("TD")) {
-        processTimeOfDeparture(decodeResult, fields[i].substring(2).split(","));
-      } else if (fields[i].startsWith("FX")) {
-        ResultFormatter.freetext(decodeResult, fields[i].substring(2));
-      } else if (fields[i].startsWith("ET")) {
-        if (fields[i].length === 7) {
-          ResultFormatter.day(decodeResult, Number(fields[i].substring(2, 3)));
-          ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[i].substring(3)));
-        } else if (fields[i].length === 8) {
-          ResultFormatter.day(decodeResult, Number(fields[i].substring(2, 4)));
-          ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(fields[i].substring(4)));
-        } else {
+      const key = fields[i].substring(0, 2);
+      const data2 = fields[i].substring(2);
+      switch (key) {
+        case "AF":
+          processAirField(decodeResult, data2.split(","));
+          break;
+        case "CG":
+          processCenterOfGravity(decodeResult, data2.split(","));
+          break;
+        case "DC":
+          processDateCode(decodeResult, data2.split(","));
+          break;
+        case "DT":
+          processDT(decodeResult, data2.split(","));
+          break;
+        case "ET":
+          processETA(data2, decodeResult, fields, i);
+          break;
+        case "FB":
+          ResultFormatter.currentFuel(decodeResult, parseInt(data2, 10));
+          break;
+        case "FN":
+          decodeResult.raw.flight_number = data2;
+          break;
+        case "FX":
+          ResultFormatter.freetext(decodeResult, data2);
+          break;
+        case "ID":
+          processIdentification(decodeResult, data2.split(","));
+          break;
+        case "LR":
+          processLandingReport(decodeResult, data2.split(","));
+          break;
+        case "PR":
+          ResultFormatter.unknown(decodeResult, fields[i], "/");
+          break;
+        case "PS":
+          _H1Helper.processPS(decodeResult, data2.split(","));
+          break;
+        case "RF":
+        case "RI":
+        case "RM":
+        case "RP":
+          FlightPlanUtils.processFlightPlan(decodeResult, fields[i].split(":"));
+          break;
+        case "SN":
+          decodeResult.raw.serial_number = data2;
+          break;
+        case "TD":
+          processTimeOfDeparture(decodeResult, data2.split(","));
+          break;
+        case "TS":
+          _H1Helper.processTimeStamp(decodeResult, data2.split(","));
+          break;
+        case "VR":
+          ResultFormatter.version(decodeResult, parseInt(data2, 10) / 10);
+          break;
+        case "WD":
+          processWindData(decodeResult, data2);
+          break;
+        default:
           ResultFormatter.unknown(decodeResult, fields[i], "/");
-        }
-      } else if (fields[i].startsWith("WD")) {
-        processWindData(decodeResult, fields[i].substring(2));
-      } else {
-        ResultFormatter.unknown(decodeResult, fields[i], "/");
       }
     }
-    if (decodeResult.formatted.items.length > 0) {
-      ResultFormatter.checksum(decodeResult, checksum);
-    }
+    ResultFormatter.checksum(decodeResult, checksum);
     return true;
   }
   static processPS(decodeResult, data) {
@@ -1671,16 +1785,26 @@ var H1Helper = class _H1Helper {
       ResultFormatter.unknownArr(decodeResult, data.slice(10));
     }
   }
-  static processTS(decodeResult, data) {
+  static processTimeStamp(decodeResult, data) {
     let time = DateTimeUtils.convertDateTimeToEpoch(data[0], data[1]);
     if (Number.isNaN(time)) {
       const date = data[1].substring(2, 4) + data[1].substring(0, 2) + data[1].substring(4, 6);
       time = DateTimeUtils.convertDateTimeToEpoch(data[0], date);
     }
-    decodeResult.raw.message_date = data[1];
     decodeResult.raw.message_timestamp = time;
   }
 };
+function processETA(data, decodeResult, fields, i) {
+  if (data.length === 5) {
+    ResultFormatter.day(decodeResult, Number(data.substring(0, 1)));
+    ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(data.substring(1)));
+  } else if (data.length === 6) {
+    ResultFormatter.day(decodeResult, Number(data.substring(0, 2)));
+    ResultFormatter.eta(decodeResult, DateTimeUtils.convertHHMMSSToTod(data.substring(2)));
+  } else {
+    ResultFormatter.unknown(decodeResult, fields[i], "/");
+  }
+}
 function processAirField(decodeResult, data) {
   if (data.length === 2) {
     ResultFormatter.departureAirport(decodeResult, data[0]);
@@ -1740,7 +1864,7 @@ function processDT(decodeResult, data) {
     ResultFormatter.unknownArr(decodeResult, data);
   }
 }
-function processLR(decodeResult, data) {
+function processLandingReport(decodeResult, data) {
   if (data.length === 19) {
     ResultFormatter.unknown(decodeResult, data[1]);
     ResultFormatter.flightNumber(decodeResult, data[2]);
@@ -1752,35 +1876,37 @@ function processLR(decodeResult, data) {
     ResultFormatter.unknown(decodeResult, data.join(","));
   }
 }
-function parseMessageType(decodeResult, messageType) {
-  const parts = messageType.split("#");
-  if (parts.length == 1) {
-    if (parts[0].startsWith("POS")) {
-      H1Helper.processPosition(decodeResult, parts[0].substring(3).split(","));
-      return processMessageType(decodeResult, "POS");
-    } else if (parts[0].length === 13) {
-      if (processMessageType(decodeResult, parts[0].substring(10))) {
-        ResultFormatter.unknown(decodeResult, parts[0].substring(0, 4));
-        ResultFormatter.flightNumber(decodeResult, parts[0].slice(4, 10));
-        return true;
-      }
-    }
-    return processMessageType(decodeResult, parts[0].substring(0, 3));
-  } else if (parts.length == 2) {
-    if (parts[0].length > 0) {
-      ResultFormatter.unknown(decodeResult, parts[0].substring(0, 4));
-      ResultFormatter.flightNumber(decodeResult, parts[0].substring(4));
-      ResultFormatter.unknown(decodeResult, parts[1].length == 5 ? parts[1].substring(0, 2) : parts[1].substring(0, 3), "#");
-    }
-    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) {
-      H1Helper.processPosition(decodeResult, parts[1].substring(6).split(","));
-    }
-    return processMessageType(decodeResult, type);
+function processCenterOfGravity(decodeResult, data) {
+  if (data.length === 1) {
+    if (data[0] !== void 0 && data[0] !== "") {
+      ResultFormatter.cg(decodeResult, parseInt(data[0], 10) / 10);
+    }
+  } else if (data.length === 3) {
+    if (data[0] !== void 0 && data[0] !== "") {
+      ResultFormatter.cg(decodeResult, parseInt(data[0], 10) / 10, "center");
+    }
+    if (data[1] !== void 0 && data[1] !== "") {
+      ResultFormatter.cg(decodeResult, parseInt(data[1], 10) / 10, "lower");
+    }
+    if (data[2] !== void 0 && data[2] !== "") {
+      ResultFormatter.cg(decodeResult, parseInt(data[2], 10) / 10, "upper");
+    }
   } else {
-    ResultFormatter.unknown(decodeResult, messageType);
-    return false;
+    ResultFormatter.unknown(decodeResult, data.join(","));
+  }
+}
+function parseMessageType(decodeResult, messageType) {
+  if (messageType.startsWith("POS")) {
+    H1Helper.processPosition(decodeResult, messageType.substring(3).split(","));
+    return processMessageType(decodeResult, "POS");
+  } else if (messageType.length === 13) {
+    if (processMessageType(decodeResult, messageType.substring(10))) {
+      ResultFormatter.unknown(decodeResult, messageType.substring(0, 4));
+      ResultFormatter.flightNumber(decodeResult, messageType.slice(4, 10));
+      return true;
+    }
   }
+  return processMessageType(decodeResult, messageType.substring(0, 3));
 }
 function processMessageType(decodeResult, type) {
   if (type === "FPN") {
@@ -1789,19 +1915,21 @@ function processMessageType(decodeResult, type) {
     decodeResult.formatted.description = "Free Text";
   } else if (type === "INI") {
     decodeResult.formatted.description = "Flight Plan Initial Report";
+  } else if (type === "PER") {
+    decodeResult.formatted.description = "Performance Report";
   } else if (type === "POS") {
     decodeResult.formatted.description = "Position Report";
   } else if (type === "PRG") {
     decodeResult.formatted.description = "Progress Report";
   } else if (type === "PWI") {
-    decodeResult.formatted.description = "Weather Report";
+    decodeResult.formatted.description = "Pilot Weather Information";
   } else {
     decodeResult.formatted.description = "Unknown H1 Message";
     return false;
   }
   return true;
 }
-function processDC(decodeResult, data) {
+function processDateCode(decodeResult, data) {
   decodeResult.raw.message_date = data[0];
   if (data.length === 1) {
   } else if (data.length === 2) {
@@ -1866,6 +1994,26 @@ function processWindData(decodeResult, message) {
   });
   ResultFormatter.windData(decodeResult, wind);
 }
+function calculateChecksum(data) {
+  let crc = 65535;
+  const bytes = Buffer.from(data, "ascii");
+  for (const byte of bytes) {
+    crc ^= byte;
+    for (let i = 0; i < 8; i++) {
+      if ((crc & 1) !== 0) {
+        crc = crc >>> 1 ^ 33800;
+      } else {
+        crc = crc >>> 1;
+      }
+    }
+  }
+  crc = (crc ^ 65535) & 65535;
+  const nibble1 = crc >> 12 & 15;
+  const nibble2 = crc >> 8 & 15;
+  const nibble3 = crc >> 4 & 15;
+  const nibble4 = crc & 15;
+  return `${nibble4.toString(16)}${nibble3.toString(16)}${nibble2.toString(16)}${nibble1.toString(16)}`.toUpperCase();
+}
 
 // lib/plugins/Label_1J_2J_FTX.ts
 var Label_1J_2J_FTX = class extends DecoderPlugin {
@@ -1880,7 +2028,14 @@ var Label_1J_2J_FTX = class extends DecoderPlugin {
     decodeResult.decoder.name = this.name;
     decodeResult.message = message;
     const msg = message.text.replace(/\n|\r/g, "");
-    const decoded = H1Helper.decodeH1Message(decodeResult, msg);
+    const parts = msg.split("/");
+    let decoded = false;
+    if (parts[0].length > 3) {
+      decoded = H1Helper.decodeH1Message(decodeResult, msg.slice(parts[0].length - 3));
+      decodeResult.remaining.text = parts[0].slice(0, 3) + "/" + decodeResult.remaining.text;
+    } else {
+      decoded = H1Helper.decodeH1Message(decodeResult, msg);
+    }
     decodeResult.decoded = decoded;
     decodeResult.decoder.decodeLevel = !decodeResult.remaining.text ? "full" : "partial";
     if (decodeResult.formatted.items.length === 0) {
@@ -2425,7 +2580,6 @@ var Label_2P_FM3 = class extends DecoderPlugin {
         ResultFormatter.unknown(decodeResult, header[0].substring(0, 4));
         ResultFormatter.flightNumber(decodeResult, header[0].substring(4));
       }
-      console.log(header[1]);
       if (header[1].length === 4) {
         ResultFormatter.time_of_day(decodeResult, DateTimeUtils.convertHHMMSSToTod(header[1]));
       } else {
@@ -2569,7 +2723,14 @@ var Label_2P_POS = class extends DecoderPlugin {
     decodeResult.decoder.name = this.name;
     decodeResult.message = message;
     const msg = message.text.replace(/\n|\r/g, "");
-    const decoded = H1Helper.decodeH1Message(decodeResult, msg);
+    const parts = msg.split("/");
+    let decoded = false;
+    if (parts[0].length > 3) {
+      decoded = H1Helper.decodeH1Message(decodeResult, msg.slice(parts[0].length - 3));
+      decodeResult.remaining.text = parts[0].slice(0, 3) + "/" + decodeResult.remaining.text;
+    } else {
+      decoded = H1Helper.decodeH1Message(decodeResult, msg);
+    }
     decodeResult.decoded = decoded;
     decodeResult.decoder.decodeLevel = !decodeResult.remaining.text ? "full" : "partial";
     if (decodeResult.formatted.items.length === 0) {
@@ -3702,7 +3863,18 @@ var Label_H1 = class extends DecoderPlugin {
     decodeResult.decoder.name = this.name;
     decodeResult.message = message;
     const msg = message.text.replace(/\n|\r/g, "");
-    const decoded = H1Helper.decodeH1Message(decodeResult, msg);
+    const parts = msg.split("#");
+    let decoded = false;
+    if (parts.length === 1) {
+      decoded = H1Helper.decodeH1Message(decodeResult, msg);
+    } else if (parts.length == 2) {
+      const offset = isNaN(parseInt(parts[1][1])) ? 3 : 4;
+      decoded = H1Helper.decodeH1Message(decodeResult, msg.slice(parts[0].length + offset));
+      if (decoded && parts[0].length > 0) {
+        ResultFormatter.flightNumber(decodeResult, parts[0].substring(4));
+        decodeResult.remaining.text = parts[0].substring(0, 4) + "#" + parts[1].substring(0, offset - 1) + "/" + decodeResult.remaining.text;
+      }
+    }
     decodeResult.decoded = decoded;
     decodeResult.decoder.decodeLevel = !decodeResult.remaining.text ? "full" : "partial";
     if (decodeResult.formatted.items.length === 0) {
@@ -3855,7 +4027,7 @@ var Label_H1_FLR = class extends DecoderPlugin {
 
 // lib/plugins/Label_H1_OHMA.ts
 import * as zlib from "minizlib";
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 var Label_H1_OHMA = class extends DecoderPlugin {
   name = "label-h1-ohma";
   qualifiers() {
@@ -3871,12 +4043,12 @@ var Label_H1_OHMA = class extends DecoderPlugin {
     decodeResult.message = message;
     const data = message.text.split("OHMA")[1];
     try {
-      const compressedBuffer = Buffer.from(data, "base64");
-      const decompress = new zlib.Inflate({ windowBits: 15 });
+      const compressedBuffer = Buffer2.from(data, "base64");
+      const decompress = new zlib.Inflate({});
       decompress.write(compressedBuffer);
       decompress.flush(zlib.constants.Z_SYNC_FLUSH);
       const result = decompress.read();
-      const jsonText = result.toString();
+      const jsonText = result?.toString() || "";
       let formattedMsg;
       let jsonMessage;
       try {
@@ -3947,7 +4119,7 @@ var Label_H1_Slash = class extends DecoderPlugin {
     for (let i = 2; i < fields.length; i++) {
       const field = fields[i];
       if (field.startsWith("TS")) {
-        H1Helper.processTS(decodeResult, field.substring(2, 15).split(","));
+        H1Helper.processTimeStamp(decodeResult, field.substring(2, 15).split(","));
       } else if (field.startsWith("PS")) {
         H1Helper.processPS(decodeResult, field.substring(2).split(","));
       } else {
@@ -4102,332 +4274,147 @@ var Label_HX = class extends DecoderPlugin {
   }
 };
 
-// lib/plugins/Label_SQ.ts
-var Label_SQ = class extends DecoderPlugin {
-  name = "label-sq";
-  qualifiers() {
-    return {
-      labels: ["SQ"]
-    };
-  }
-  decode(message, options = {}) {
-    const decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.raw.preamble = message.text.substring(0, 4);
-    decodeResult.raw.version = message.text.substring(1, 2);
-    decodeResult.raw.network = message.text.substring(3, 4);
-    if (decodeResult.raw.version === "2") {
-      const regex = /0(\d)X(?<org>\w)(?<iata>\w\w\w)(?<icao>\w\w\w\w)(?<station>\d)(?<lat>\d+)(?<latd>[NS])(?<lng>\d+)(?<lngd>[EW])V(?<vfreq>\d+)\/.*/;
-      const result = message.text.match(regex);
-      if (result?.groups && result.length >= 8) {
-        decodeResult.raw.groundStation = {
-          number: result.groups.station,
-          iataCode: result.groups.iata,
-          icaoCode: result.groups.icao,
-          coordinates: {
-            latitude: Number(result.groups.lat) / 100 * (result.groups.latd === "S" ? -1 : 1),
-            longitude: Number(result.groups.lng) / 100 * (result.groups.lngd === "W" ? -1 : 1)
-          }
+// lib/utils/miam.ts
+import * as Base85 from "base85";
+import * as zlib2 from "minizlib";
+import { Buffer as Buffer3 } from "buffer";
+var MIAMVersion = /* @__PURE__ */ ((MIAMVersion2) => {
+  MIAMVersion2[MIAMVersion2["V1"] = 1] = "V1";
+  MIAMVersion2[MIAMVersion2["V2"] = 2] = "V2";
+  return MIAMVersion2;
+})(MIAMVersion || {});
+var MIAMFid = /* @__PURE__ */ ((MIAMFid2) => {
+  MIAMFid2["SingleTransfer"] = "T";
+  MIAMFid2["FileTransferRequest"] = "F";
+  MIAMFid2["FileTransferAccept"] = "K";
+  MIAMFid2["FileSegment"] = "S";
+  MIAMFid2["FileTransferAbort"] = "A";
+  MIAMFid2["XOFFIndication"] = "Y";
+  MIAMFid2["XONIndication"] = "X";
+  return MIAMFid2;
+})(MIAMFid || {});
+var MIAMCorePdu = /* @__PURE__ */ ((MIAMCorePdu2) => {
+  MIAMCorePdu2[MIAMCorePdu2["Data"] = 0] = "Data";
+  MIAMCorePdu2[MIAMCorePdu2["Ack"] = 1] = "Ack";
+  MIAMCorePdu2[MIAMCorePdu2["Aloha"] = 2] = "Aloha";
+  MIAMCorePdu2[MIAMCorePdu2["AlohaReply"] = 3] = "AlohaReply";
+  return MIAMCorePdu2;
+})(MIAMCorePdu || {});
+var MIAMCoreApp = /* @__PURE__ */ ((MIAMCoreApp2) => {
+  MIAMCoreApp2[MIAMCoreApp2["ACARS2Char"] = 0] = "ACARS2Char";
+  MIAMCoreApp2[MIAMCoreApp2["ACARS4Char"] = 1] = "ACARS4Char";
+  MIAMCoreApp2[MIAMCoreApp2["ACARS6Char"] = 2] = "ACARS6Char";
+  MIAMCoreApp2[MIAMCoreApp2["NonACARS6Char"] = 3] = "NonACARS6Char";
+  return MIAMCoreApp2;
+})(MIAMCoreApp || {});
+var MIAMCoreV1CRCLength = 4;
+var MIAMCoreV2CRCLength = 2;
+var isMIAMVersion = (x) => Object.values(MIAMVersion).includes(x);
+var isMIAMFid = (x) => Object.values(MIAMFid).includes(x);
+var isMIAMCoreApp = (x) => Object.values(MIAMCoreApp).includes(x);
+var isMIAMCorePdu = (x) => Object.values(MIAMCorePdu).includes(x);
+var MIAMCoreUtils = class {
+  static AppTypeToAppIdLenTable = {
+    [1 /* V1 */]: {
+      [0 /* ACARS2Char */]: 2,
+      [1 /* ACARS4Char */]: 4,
+      [2 /* ACARS6Char */]: 6,
+      [3 /* NonACARS6Char */]: 6
+    },
+    [2 /* V2 */]: {
+      [0 /* ACARS2Char */]: 2,
+      [1 /* ACARS4Char */]: 4,
+      [2 /* ACARS6Char */]: 6,
+      [3 /* NonACARS6Char */]: 6
+    }
+  };
+  static FidHandlerTable = {
+    ["T" /* SingleTransfer */]: (txt) => {
+      if (txt.length < 3) {
+        return {
+          decoded: false,
+          error: "Raw MIAM message too short (" + txt.length + " < 3) "
         };
-        decodeResult.raw.vdlFrequency = Number(result.groups.vfreq) / 1e3;
       }
-    }
-    decodeResult.formatted.description = "Ground Station Squitter";
-    var formattedNetwork = "Unknown";
-    if (decodeResult.raw.network == "A") {
-      formattedNetwork = "ARINC";
-    } else if (decodeResult.raw.network == "S") {
-      formattedNetwork = "SITA";
-    }
-    decodeResult.formatted.items = [
-      {
-        type: "network",
-        code: "NETT",
-        label: "Network",
-        value: formattedNetwork
-      },
-      {
-        type: "version",
-        code: "VER",
-        label: "Version",
-        value: decodeResult.raw.version
+      let bpad = txt[0];
+      if ("0123-.".indexOf(bpad) === -1) {
+        return {
+          decoded: false,
+          error: "Invalid body padding value: '" + bpad + "'"
+        };
       }
-    ];
-    if (decodeResult.raw.groundStation) {
-      if (decodeResult.raw.groundStation.icaoCode && decodeResult.raw.groundStation.number) {
-        decodeResult.formatted.items.push({
-          type: "ground_station",
-          code: "GNDSTN",
-          label: "Ground Station",
-          value: `${decodeResult.raw.groundStation.icaoCode}${decodeResult.raw.groundStation.number}`
-        });
+      if ("0123".indexOf(txt[1]) === -1) {
+        return {
+          decoded: false,
+          error: "Invalid header padding value: '" + txt[1] + "'"
+        };
       }
-      if (decodeResult.raw.groundStation.iataCode) {
-        decodeResult.formatted.items.push({
-          type: "iataCode",
-          code: "IATA",
-          label: "IATA",
-          value: decodeResult.raw.groundStation.iataCode
-        });
+      const hpad = parseInt(txt[1]);
+      const delimIdx = txt.indexOf("|");
+      if (delimIdx === -1) {
+        return {
+          decoded: false,
+          error: "Raw MIAM message missing header-body delimiter"
+        };
       }
-      if (decodeResult.raw.groundStation.icaoCode) {
-        decodeResult.formatted.items.push({
-          type: "icaoCode",
-          code: "ICAO",
-          label: "ICAO",
-          value: decodeResult.raw.groundStation.icaoCode
-        });
+      const rawHdr = txt.substring(2, delimIdx);
+      if (rawHdr.length === 0) {
+        return {
+          decoded: false,
+          error: "Empty MIAM message header"
+        };
       }
-      if (decodeResult.raw.groundStation.coordinates.latitude) {
-        decodeResult.formatted.items.push({
-          type: "coordinates",
-          code: "COORD",
-          label: "Ground Station Location",
-          value: `${decodeResult.raw.groundStation.coordinates.latitude}, ${decodeResult.raw.groundStation.coordinates.longitude}`
-        });
+      let hdr = Base85.decode("<~" + rawHdr + "~>", "ascii85");
+      if (!hdr || hdr.length < hpad) {
+        return {
+          decoded: false,
+          error: "Ascii85 decode failed for MIAM message header"
+        };
       }
-      if (decodeResult.raw.groundStation.airport) {
-        decodeResult.formatted.items.push({
-          type: "airport",
-          code: "APT",
-          label: "Airport",
-          value: `${decodeResult.raw.groundStation.airport.name} (${decodeResult.raw.groundStation.airport.icao}) in ${decodeResult.raw.groundStation.airport.location}`
-        });
-      }
-    }
-    if (decodeResult.raw.vdlFrequency) {
-      decodeResult.formatted.items.push({
-        type: "vdlFrequency",
-        code: "VDLFRQ",
-        label: "VDL Frequency",
-        value: `${decodeResult.raw.vdlFrequency} MHz`
-      });
-    }
-    decodeResult.decoded = true;
-    decodeResult.decoder.decodeLevel = "full";
-    return decodeResult;
-  }
-};
-
-// lib/plugins/Label_QR.ts
-var Label_QR = class extends DecoderPlugin {
-  name = "label-qr";
-  qualifiers() {
-    return {
-      labels: ["QR"]
-    };
-  }
-  decode(message, options = {}) {
-    const decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "ON Report";
-    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
-    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
-    ResultFormatter.on(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(8, 12)));
-    ResultFormatter.unknown(decodeResult, message.text.substring(12));
-    decodeResult.decoded = true;
-    if (!decodeResult.remaining.text)
-      decodeResult.decoder.decodeLevel = "full";
-    else
-      decodeResult.decoder.decodeLevel = "partial";
-    return decodeResult;
-  }
-};
-
-// lib/plugins/Label_QP.ts
-var Label_QP = class extends DecoderPlugin {
-  name = "label-qp";
-  qualifiers() {
-    return {
-      labels: ["QP"]
-    };
-  }
-  decode(message, options = {}) {
-    const decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "OUT Report";
-    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
-    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
-    ResultFormatter.out(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(8, 12)));
-    ResultFormatter.unknown(decodeResult, message.text.substring(12));
-    decodeResult.decoded = true;
-    if (!decodeResult.remaining.text)
-      decodeResult.decoder.decodeLevel = "full";
-    else
-      decodeResult.decoder.decodeLevel = "partial";
-    return decodeResult;
-  }
-};
-
-// lib/plugins/Label_QS.ts
-var Label_QS = class extends DecoderPlugin {
-  name = "label-qs";
-  qualifiers() {
-    return {
-      labels: ["QS"]
-    };
-  }
-  decode(message, options = {}) {
-    const decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "IN Report";
-    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
-    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
-    ResultFormatter.in(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(8, 12)));
-    ResultFormatter.unknown(decodeResult, message.text.substring(12));
-    decodeResult.decoded = true;
-    if (!decodeResult.remaining.text)
-      decodeResult.decoder.decodeLevel = "full";
-    else
-      decodeResult.decoder.decodeLevel = "partial";
-    return decodeResult;
-  }
-};
-
-// lib/plugins/Label_QQ.ts
-var Label_QQ = class extends DecoderPlugin {
-  name = "label-qq";
-  qualifiers() {
-    return {
-      labels: ["QQ"]
-    };
-  }
-  decode(message, options = {}) {
-    const decodeResult = this.defaultResult();
-    decodeResult.decoder.name = this.name;
-    decodeResult.message = message;
-    decodeResult.formatted.description = "OFF Report";
-    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
-    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
-    if (message.text.substring(12, 19) === "\r\n001FE") {
-      decodeResult.raw.day = message.text.substring(19, 21);
-      ResultFormatter.off(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(21, 27)));
-      let latdir = message.text.substring(27, 28);
-      let latdeg = Number(message.text.substring(28, 30));
-      let latmin = Number(message.text.substring(30, 34));
-      let londir = message.text.substring(34, 35);
-      let londeg = Number(message.text.substring(35, 38));
-      let lonmin = Number(message.text.substring(38, 42));
-      let pos = {
-        latitude: (latdeg + latmin / 60) * (latdir === "N" ? 1 : -1),
-        longitude: (londeg + lonmin / 60) * (londir === "E" ? 1 : -1)
-      };
-      ResultFormatter.unknown(decodeResult, message.text.substring(42, 45));
-      ResultFormatter.position(decodeResult, pos);
-      if (decodeResult.remaining.text !== "---") {
-        ResultFormatter.groundspeed(decodeResult, Number(message.text.substring(45, 48)));
-      } else {
-        ResultFormatter.unknown(decodeResult, message.text.substring(45, 48));
-      }
-      ResultFormatter.unknown(decodeResult, message.text.substring(48));
-    } else {
-      ResultFormatter.off(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(8, 12) + "00"));
-      ResultFormatter.unknown(decodeResult, message.text.substring(12));
-    }
-    decodeResult.decoded = true;
-    if (!decodeResult.remaining.text)
-      decodeResult.decoder.decodeLevel = "full";
-    else
-      decodeResult.decoder.decodeLevel = "partial";
-    return decodeResult;
-  }
-};
-
-// lib/utils/miam.ts
-import * as Base85 from "base85";
-import * as zlib2 from "minizlib";
-import { Buffer as Buffer2 } from "buffer";
-var MIAMCoreV1CRCLength = 4;
-var MIAMCoreV2CRCLength = 2;
-var MIAMCoreUtils = class {
-  static AppTypeToAppIdLenTable = {
-    1: {
-      [0 /* ACARS2Char */]: 2,
-      [1 /* ACARS4Char */]: 4,
-      [2 /* ACARS6Char */]: 6,
-      [3 /* NonACARS6Char */]: 6
-    },
-    2: {
-      [0 /* ACARS2Char */]: 2,
-      [1 /* ACARS4Char */]: 4,
-      [2 /* ACARS6Char */]: 6,
-      [3 /* NonACARS6Char */]: 6
-    }
-  };
-  static FidHandlerTable = {
-    ["T" /* SingleTransfer */]: (txt) => {
-      if (txt.length < 3) {
-        return {
-          decoded: false,
-          error: "Raw MIAM message too short (" + txt.length + " < 3) "
-        };
-      }
-      let bpad = txt[0];
-      if ("0123-.".indexOf(bpad) === -1) {
-        return {
-          decoded: false,
-          error: "Invalid body padding value: '" + bpad + "'"
-        };
-      }
-      if ("0123".indexOf(txt[1]) === -1) {
-        return {
-          decoded: false,
-          error: "Invalid header padding value: '" + txt[1] + "'"
-        };
-      }
-      const hpad = parseInt(txt[1]);
-      const delimIdx = txt.indexOf("|");
-      if (delimIdx === -1) {
-        return {
-          decoded: false,
-          error: "Raw MIAM message missing header-body delimiter"
-        };
-      }
-      const rawHdr = txt.substring(2, delimIdx);
-      if (rawHdr.length === 0) {
-        return {
-          decoded: false,
-          error: "Empty MIAM message header"
-        };
-      }
-      let hdr = Base85.decode("<~" + rawHdr + "~>", "ascii85");
-      if (!hdr || hdr.length < hpad) {
-        return {
-          decoded: false,
-          error: "Ascii85 decode failed for MIAM message header"
-        };
-      }
-      let body = void 0;
-      const rawBody = txt.substring(delimIdx + 1);
-      if (rawBody.length > 0) {
-        if ("0123".indexOf(bpad) >= 0) {
-          const bpadValue = parseInt(bpad);
-          body = Base85.decode("<~" + rawBody + "~>", "ascii85") || void 0;
-          if (body && body.length >= bpadValue) {
-            body = body.subarray(0, body.length - bpadValue);
-          }
-        } else if (bpad === "-") {
-          body = Buffer2.from(rawBody);
-        }
+      let body = void 0;
+      const rawBody = txt.substring(delimIdx + 1);
+      if (rawBody.length > 0) {
+        if ("0123".indexOf(bpad) >= 0) {
+          const bpadValue = parseInt(bpad);
+          body = Base85.decode("<~" + rawBody + "~>", "ascii85") || void 0;
+          if (body && body.length >= bpadValue) {
+            body = body.subarray(0, body.length - bpadValue);
+          }
+        } else if (bpad === "-") {
+          body = Buffer3.from(rawBody);
+        }
       }
       hdr = hdr.subarray(0, hdr.length - hpad);
       const version = hdr.readUInt8(0) & 15;
       const pduType = hdr.readUInt8(0) >> 4 & 15;
-      const versionPduHandler = this.VersionPduHandlerTable[version][pduType];
-      if (versionPduHandler === void 0) {
+      if (isMIAMVersion(version) && isMIAMCorePdu(pduType)) {
+        const versionPduHandler = this.VersionPduHandlerTable[version][pduType];
+        return versionPduHandler(hdr, body);
+      } else {
         return {
           decoded: false,
           error: "Invalid version and PDU type combination: v=" + version + ", pdu=" + pduType
         };
       }
-      return versionPduHandler(hdr, body);
     },
-    ["F" /* FileTransferRequest */]: void 0,
-    ["K" /* FileTransferAccept */]: void 0,
-    ["S" /* FileSegment */]: void 0,
-    ["A" /* FileTransferAbort */]: void 0,
-    ["Y" /* XOFFIndication */]: void 0,
-    ["X" /* XONIndication */]: void 0
+    ["F" /* FileTransferRequest */]: () => {
+      return { decoded: false, error: "File Transfer Request not implemented" };
+    },
+    ["K" /* FileTransferAccept */]: () => {
+      return { decoded: false, error: "File Transfer Accept not implemented" };
+    },
+    ["S" /* FileSegment */]: () => {
+      return { decoded: false, error: "File Segment not implemented" };
+    },
+    ["A" /* FileTransferAbort */]: () => {
+      return { decoded: false, error: "File Transfer Abort not implemented" };
+    },
+    ["Y" /* XOFFIndication */]: () => {
+      return { decoded: false, error: "XOFF Indication not implemented" };
+    },
+    ["X" /* XONIndication */]: () => {
+      return { decoded: false, error: "XON Indication not implemented" };
+    }
   };
   static arincCrc16(buf, seed) {
     const crctable = [
@@ -4961,14 +4948,15 @@ var MIAMCoreUtils = class {
   }
   static parse(txt) {
     const fidType = txt[0];
-    const handler = this.FidHandlerTable[fidType];
-    if (handler === void 0) {
+    if (isMIAMFid(fidType)) {
+      const handler = this.FidHandlerTable[fidType];
+      return handler(txt.substring(1));
+    } else {
       return {
         decoded: false,
         error: "Unsupported FID type: " + fidType
       };
     }
-    return handler(txt.substring(1));
   }
   static corePduDataHandler(version, minHdrSize, crcLen, hdr, body) {
     if (hdr.length < minHdrSize) {
@@ -4983,14 +4971,14 @@ var MIAMCoreUtils = class {
     let pduAppType = 0;
     let pduAppId = "";
     let pduCrc = 0;
-    let pduData = void 0;
+    let pduData = null;
     let pduCrcIsOk = false;
     let pduIsComplete = true;
     let pduErrors = [];
     let tail = void 0;
     let msgNum = 0;
     let ackOptions = 0;
-    if (version === 1) {
+    if (version === 1 /* V1 */) {
       pduSize = hdr.readUInt8(1) << 16 | hdr.readUInt8(2) << 8 | hdr.readUInt8(3);
       const msgSize = hdr.length + (body === void 0 ? 0 : body.length);
       if (pduSize > msgSize) {
@@ -5000,7 +4988,7 @@ var MIAMCoreUtils = class {
       hdr = hdr.subarray(4);
       tail = hdr.subarray(0, 7).toString("ascii");
       hdr = hdr.subarray(7);
-    } else if (version === 2) {
+    } else if (version === 2 /* V2 */) {
       hdr = hdr.subarray(1);
     }
     msgNum = hdr.readUInt8(0) >> 1 & 127;
@@ -5010,9 +4998,11 @@ var MIAMCoreUtils = class {
     pduEncoding = hdr.readUInt8(1) >> 4 & 3;
     pduAppType = hdr.readUInt8(1) & 15;
     hdr = hdr.subarray(2);
-    let appIdLen = this.AppTypeToAppIdLenTable[version][pduAppType];
-    if (appIdLen === void 0) {
-      if (version === 2 && (pduAppType & 8) !== 0 && pduAppType !== 13) {
+    let appIdLen;
+    if (isMIAMCoreApp(pduAppType)) {
+      appIdLen = this.AppTypeToAppIdLenTable[version][pduAppType];
+    } else {
+      if (version === 2 /* V2 */ && (pduAppType & 8) !== 0 && pduAppType !== 13) {
         appIdLen = (pduAppType & 7) + 1;
       } else {
         return {
@@ -5022,9 +5012,6 @@ var MIAMCoreUtils = class {
       }
     }
     const pduIsACARS = [
-      0 /* ACARS2Char */,
-      1 /* ACARS4Char */,
-      2 /* ACARS6Char */,
       0 /* ACARS2Char */,
       1 /* ACARS4Char */,
       2 /* ACARS6Char */
@@ -5046,7 +5033,7 @@ var MIAMCoreUtils = class {
     if (body !== void 0 && body.length > 0) {
       if ([1 /* Deflate */, 1 /* Deflate */].indexOf(pduCompression) >= 0) {
         try {
-          const decompress = new zlib2.InflateRaw({ windowBits: 15 });
+          const decompress = new zlib2.InflateRaw({});
           decompress.write(body);
           decompress.flush(zlib2.constants.Z_SYNC_FLUSH);
           pduData = decompress.read();
@@ -5058,18 +5045,18 @@ var MIAMCoreUtils = class {
       } else {
         pduErrors.push("Unsupported v" + version + " compression type: " + pduCompression);
       }
-      if (pduData !== void 0) {
+      if (pduData !== null) {
         const crcAlgoHandlerByVersion = {
-          1: (buf, seed) => {
+          [1 /* V1 */]: (buf, seed) => {
             return ~this.arinc665Crc32(buf, seed);
           },
-          2: this.arincCrc16
+          [2 /* V2 */]: this.arincCrc16
         };
         const crcAlgoHandler = crcAlgoHandlerByVersion[version];
         if (crcAlgoHandler === void 0) {
           return {
             decoded: false,
-            errors: "No CRC handler for v" + version
+            error: "No CRC handler for v" + version
           };
         }
         const crcCheck = crcAlgoHandler(pduData, 4294967295);
@@ -5117,25 +5104,315 @@ var MIAMCoreUtils = class {
     };
   }
   static VersionPduHandlerTable = {
-    1: {
+    [1 /* V1 */]: {
       [0 /* Data */]: (hdr, body) => {
-        return this.corePduDataHandler(1, 20, MIAMCoreV1CRCLength, hdr, body);
+        return this.corePduDataHandler(1 /* V1 */, 20, MIAMCoreV1CRCLength, hdr, body);
+      },
+      [1 /* Ack */]: () => {
+        return { decoded: false, error: "v1 Ack PDU not implemented" };
+      },
+      [2 /* Aloha */]: () => {
+        return { decoded: false, error: "v1 Aloha PDU not implemented" };
       },
-      [1 /* Ack */]: void 0,
-      [2 /* Aloha */]: void 0,
-      [3 /* AlohaReply */]: void 0
+      [3 /* AlohaReply */]: () => {
+        return { decoded: false, error: "v1 AlohaReply PDU not implemented" };
+      }
     },
-    2: {
+    [2 /* V2 */]: {
       [0 /* Data */]: (hdr, body) => {
-        return this.corePduDataHandler(2, 7, MIAMCoreV2CRCLength, hdr, body);
+        return this.corePduDataHandler(2 /* V2 */, 7, MIAMCoreV2CRCLength, hdr, body);
+      },
+      [1 /* Ack */]: () => {
+        return { decoded: false, error: "v2 Ack PDU not implemented" };
+      },
+      [2 /* Aloha */]: () => {
+        return { decoded: false, error: "v2 Aloha PDU not implemented" };
       },
-      [1 /* Ack */]: void 0,
-      [2 /* Aloha */]: void 0,
-      [3 /* AlohaReply */]: void 0
+      [3 /* AlohaReply */]: () => {
+        return { decoded: false, error: "v2 Aloha reply PDU not implemented" };
+      }
     }
   };
 };
 
+// lib/plugins/Label_MA.ts
+var Label_MA = class extends DecoderPlugin {
+  name = "label-ma";
+  qualifiers() {
+    return {
+      labels: ["MA"]
+    };
+  }
+  decode(message, options = {}) {
+    let decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    const miamResult = MIAMCoreUtils.parse(message.text);
+    if (miamResult.decoded && miamResult.message.data !== void 0 && miamResult.message.data.crcOk && miamResult.message.data.complete && miamResult.message.data.acars !== void 0) {
+      decodeResult.decoded = true;
+      decodeResult.decoder.decodeLevel = "partial";
+      ResultFormatter.label(decodeResult, miamResult.message.data.acars.label);
+      if (miamResult.message.data.acars.sublabel) {
+        ResultFormatter.sublabel(decodeResult, miamResult.message.data.acars.sublabel);
+      }
+      if (miamResult.message.data.acars.tail) {
+        ResultFormatter.tail(decodeResult, miamResult.message.data.acars.tail);
+      }
+      const messageText = miamResult.message.data.acars.text;
+      if (messageText) {
+        const decoded = this.decoder.decode({
+          label: miamResult.message.data.acars.label,
+          sublabel: miamResult.message.data.acars.sublabel,
+          text: messageText
+        }, options);
+        if (decoded.decoded) {
+          decodeResult.decoder.decodeLevel = decoded.decoder.decodeLevel;
+          decodeResult.raw = { ...decodeResult.raw, ...decoded.raw };
+          decodeResult.formatted.items.push(...decoded.formatted.items);
+        } else {
+          ResultFormatter.text(decodeResult, messageText);
+        }
+        message.text = messageText;
+      }
+      message.label = miamResult.message.data.acars.label;
+      message.sublabel = miamResult.message.data.acars.sublabel;
+      return decodeResult;
+    }
+    return decodeResult;
+  }
+};
+
+// lib/plugins/Label_SQ.ts
+var Label_SQ = class extends DecoderPlugin {
+  name = "label-sq";
+  qualifiers() {
+    return {
+      labels: ["SQ"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.raw.preamble = message.text.substring(0, 4);
+    decodeResult.raw.version = message.text.substring(1, 2);
+    decodeResult.raw.network = message.text.substring(3, 4);
+    if (decodeResult.raw.version === "2") {
+      const regex = /0(\d)X(?<org>\w)(?<iata>\w\w\w)(?<icao>\w\w\w\w)(?<station>\d)(?<lat>\d+)(?<latd>[NS])(?<lng>\d+)(?<lngd>[EW])V(?<vfreq>\d+)\/.*/;
+      const result = message.text.match(regex);
+      if (result?.groups && result.length >= 8) {
+        decodeResult.raw.groundStation = {
+          number: result.groups.station,
+          iataCode: result.groups.iata,
+          icaoCode: result.groups.icao,
+          coordinates: {
+            latitude: Number(result.groups.lat) / 100 * (result.groups.latd === "S" ? -1 : 1),
+            longitude: Number(result.groups.lng) / 100 * (result.groups.lngd === "W" ? -1 : 1)
+          }
+        };
+        decodeResult.raw.vdlFrequency = Number(result.groups.vfreq) / 1e3;
+      }
+    }
+    decodeResult.formatted.description = "Ground Station Squitter";
+    var formattedNetwork = "Unknown";
+    if (decodeResult.raw.network == "A") {
+      formattedNetwork = "ARINC";
+    } else if (decodeResult.raw.network == "S") {
+      formattedNetwork = "SITA";
+    }
+    decodeResult.formatted.items = [
+      {
+        type: "network",
+        code: "NETT",
+        label: "Network",
+        value: formattedNetwork
+      },
+      {
+        type: "version",
+        code: "VER",
+        label: "Version",
+        value: decodeResult.raw.version
+      }
+    ];
+    if (decodeResult.raw.groundStation) {
+      if (decodeResult.raw.groundStation.icaoCode && decodeResult.raw.groundStation.number) {
+        decodeResult.formatted.items.push({
+          type: "ground_station",
+          code: "GNDSTN",
+          label: "Ground Station",
+          value: `${decodeResult.raw.groundStation.icaoCode}${decodeResult.raw.groundStation.number}`
+        });
+      }
+      if (decodeResult.raw.groundStation.iataCode) {
+        decodeResult.formatted.items.push({
+          type: "iataCode",
+          code: "IATA",
+          label: "IATA",
+          value: decodeResult.raw.groundStation.iataCode
+        });
+      }
+      if (decodeResult.raw.groundStation.icaoCode) {
+        decodeResult.formatted.items.push({
+          type: "icaoCode",
+          code: "ICAO",
+          label: "ICAO",
+          value: decodeResult.raw.groundStation.icaoCode
+        });
+      }
+      if (decodeResult.raw.groundStation.coordinates.latitude) {
+        decodeResult.formatted.items.push({
+          type: "coordinates",
+          code: "COORD",
+          label: "Ground Station Location",
+          value: `${decodeResult.raw.groundStation.coordinates.latitude}, ${decodeResult.raw.groundStation.coordinates.longitude}`
+        });
+      }
+      if (decodeResult.raw.groundStation.airport) {
+        decodeResult.formatted.items.push({
+          type: "airport",
+          code: "APT",
+          label: "Airport",
+          value: `${decodeResult.raw.groundStation.airport.name} (${decodeResult.raw.groundStation.airport.icao}) in ${decodeResult.raw.groundStation.airport.location}`
+        });
+      }
+    }
+    if (decodeResult.raw.vdlFrequency) {
+      decodeResult.formatted.items.push({
+        type: "vdlFrequency",
+        code: "VDLFRQ",
+        label: "VDL Frequency",
+        value: `${decodeResult.raw.vdlFrequency} MHz`
+      });
+    }
+    decodeResult.decoded = true;
+    decodeResult.decoder.decodeLevel = "full";
+    return decodeResult;
+  }
+};
+
+// lib/plugins/Label_QR.ts
+var Label_QR = class extends DecoderPlugin {
+  name = "label-qr";
+  qualifiers() {
+    return {
+      labels: ["QR"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "ON Report";
+    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
+    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
+    ResultFormatter.on(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(8, 12)));
+    ResultFormatter.unknown(decodeResult, message.text.substring(12));
+    decodeResult.decoded = true;
+    if (!decodeResult.remaining.text)
+      decodeResult.decoder.decodeLevel = "full";
+    else
+      decodeResult.decoder.decodeLevel = "partial";
+    return decodeResult;
+  }
+};
+
+// lib/plugins/Label_QP.ts
+var Label_QP = class extends DecoderPlugin {
+  name = "label-qp";
+  qualifiers() {
+    return {
+      labels: ["QP"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "OUT Report";
+    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
+    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
+    ResultFormatter.out(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(8, 12)));
+    ResultFormatter.unknown(decodeResult, message.text.substring(12));
+    decodeResult.decoded = true;
+    if (!decodeResult.remaining.text)
+      decodeResult.decoder.decodeLevel = "full";
+    else
+      decodeResult.decoder.decodeLevel = "partial";
+    return decodeResult;
+  }
+};
+
+// lib/plugins/Label_QS.ts
+var Label_QS = class extends DecoderPlugin {
+  name = "label-qs";
+  qualifiers() {
+    return {
+      labels: ["QS"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.formatted.description = "IN Report";
+    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
+    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
+    ResultFormatter.in(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(8, 12)));
+    ResultFormatter.unknown(decodeResult, message.text.substring(12));
+    decodeResult.decoded = true;
+    if (!decodeResult.remaining.text)
+      decodeResult.decoder.decodeLevel = "full";
+    else
+      decodeResult.decoder.decodeLevel = "partial";
+    return decodeResult;
+  }
+};
+
+// lib/plugins/Label_QQ.ts
+var Label_QQ = class extends DecoderPlugin {
+  name = "label-qq";
+  qualifiers() {
+    return {
+      labels: ["QQ"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    decodeResult.formatted.description = "OFF Report";
+    ResultFormatter.departureAirport(decodeResult, message.text.substring(0, 4));
+    ResultFormatter.arrivalAirport(decodeResult, message.text.substring(4, 8));
+    if (message.text.substring(12, 19) === "\r\n001FE") {
+      decodeResult.raw.day = message.text.substring(19, 21);
+      ResultFormatter.off(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(21, 27)));
+      let latdir = message.text.substring(27, 28);
+      let latdeg = Number(message.text.substring(28, 30));
+      let latmin = Number(message.text.substring(30, 34));
+      let londir = message.text.substring(34, 35);
+      let londeg = Number(message.text.substring(35, 38));
+      let lonmin = Number(message.text.substring(38, 42));
+      let pos = {
+        latitude: (latdeg + latmin / 60) * (latdir === "N" ? 1 : -1),
+        longitude: (londeg + lonmin / 60) * (londir === "E" ? 1 : -1)
+      };
+      ResultFormatter.unknown(decodeResult, message.text.substring(42, 45));
+      ResultFormatter.position(decodeResult, pos);
+      if (decodeResult.remaining.text !== "---") {
+        ResultFormatter.groundspeed(decodeResult, Number(message.text.substring(45, 48)));
+      } else {
+        ResultFormatter.unknown(decodeResult, message.text.substring(45, 48));
+      }
+      ResultFormatter.unknown(decodeResult, message.text.substring(48));
+    } else {
+      ResultFormatter.off(decodeResult, DateTimeUtils.convertHHMMSSToTod(message.text.substring(8, 12) + "00"));
+      ResultFormatter.unknown(decodeResult, message.text.substring(12));
+    }
+    decodeResult.decoded = true;
+    if (!decodeResult.remaining.text)
+      decodeResult.decoder.decodeLevel = "full";
+    else
+      decodeResult.decoder.decodeLevel = "partial";
+    return decodeResult;
+  }
+};
+
 // lib/MessageDecoder.ts
 var MessageDecoder = class {
   name;
@@ -5203,6 +5480,7 @@ var MessageDecoder = class {
     this.registerPlugin(new Label_83(this));
     this.registerPlugin(new Label_8E(this));
     this.registerPlugin(new Label_1M_Slash(this));
+    this.registerPlugin(new Label_MA(this));
     this.registerPlugin(new Label_SQ(this));
     this.registerPlugin(new Label_QP(this));
     this.registerPlugin(new Label_QQ(this));
@@ -5215,18 +5493,6 @@ var MessageDecoder = class {
     return true;
   }
   decode(message, options = {}) {
-    if (message.label === "MA") {
-      const decodeResult = MIAMCoreUtils.parse(message.text);
-      if (decodeResult.decoded && decodeResult.message.data !== void 0 && decodeResult.message.data.crcOk && decodeResult.message.data.complete && decodeResult.message.data.acars !== void 0) {
-        message = {
-          ...message,
-          label: decodeResult.message.data.acars.label,
-          ...decodeResult.message.data.acars.sublabel ? { sublabel: decodeResult.message.data.acars.sublabel } : {},
-          ...decodeResult.message.data.acars.mfi ? { mfi: decodeResult.message.data.acars.mfi } : {},
-          ...decodeResult.message.data.acars.text ? { text: decodeResult.message.data.acars.text } : {}
-        };
-      }
-    }
     const usablePlugins = this.plugins.filter((plugin) => {
       const qualifiers = plugin.qualifiers();
       if (qualifiers.labels.includes(message.label)) {
@@ -5276,11 +5542,6 @@ var MessageDecoder = class {
     }
     return result;
   }
-  lookupAirportByIata(iata) {
-    const airportsArray = [];
-    const airport = airportsArray.filter((e) => e.iata === iata);
-    return airport;
-  }
 };
 export {
   IcaoDecoder,