@airframes/acars-decoder 1.8.3 → 1.8.5

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";
@@ -732,6 +730,24 @@ var ResultFormatter = class {
       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;
@@ -4258,252 +4274,54 @@ 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)
-          }
-        };
-        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/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: {
+    [1 /* V1 */]: {
       [0 /* ACARS2Char */]: 2,
       [1 /* ACARS4Char */]: 4,
       [2 /* ACARS6Char */]: 6,
       [3 /* NonACARS6Char */]: 6
     },
-    2: {
+    [2 /* V2 */]: {
       [0 /* ACARS2Char */]: 2,
       [1 /* ACARS4Char */]: 4,
       [2 /* ACARS6Char */]: 6,
@@ -4569,21 +4387,34 @@ var MIAMCoreUtils = class {
       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 = [
@@ -5117,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) {
@@ -5139,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) {
@@ -5156,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;
@@ -5166,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 {
@@ -5178,9 +5012,6 @@ var MIAMCoreUtils = class {
       }
     }
     const pduIsACARS = [
-      0 /* ACARS2Char */,
-      1 /* ACARS4Char */,
-      2 /* ACARS6Char */,
       0 /* ACARS2Char */,
       1 /* ACARS4Char */,
       2 /* ACARS6Char */
@@ -5202,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();
@@ -5214,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);
@@ -5273,25 +5104,317 @@ 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 */]: void 0,
-      [2 /* Aloha */]: void 0,
-      [3 /* AlohaReply */]: void 0
+      [1 /* Ack */]: () => {
+        return { decoded: false, error: "v1 Ack PDU not implemented" };
+      },
+      [2 /* Aloha */]: () => {
+        return { decoded: false, error: "v1 Aloha PDU not implemented" };
+      },
+      [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 && miamResult.message.data.acars) {
+      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 (miamResult.message.data.crcOk && miamResult.message.data.complete && 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;
+      } else if (messageText) {
+        ResultFormatter.text(decodeResult, 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;
@@ -5359,6 +5482,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));
@@ -5371,18 +5495,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)) {
@@ -5432,11 +5544,6 @@ var MessageDecoder = class {
     }
     return result;
   }
-  lookupAirportByIata(iata) {
-    const airportsArray = [];
-    const airport = airportsArray.filter((e) => e.iata === iata);
-    return airport;
-  }
 };
 export {
   IcaoDecoder,