@airframes/acars-decoder 1.9.4 → 1.9.5

package/dist/bin/acars-decoder-test.js

@@ -76,8 +76,8 @@ var CoordinateUtils = class _CoordinateUtils {
     };
   }
   static coordinateString(coords) {
-    const latDir = coords.latitude > 0 ? "N" : "S";
-    const lonDir = coords.longitude > 0 ? "E" : "W";
+    const latDir = coords.latitude >= 0 ? "N" : "S";
+    const lonDir = coords.longitude >= 0 ? "E" : "W";
     return `${Math.abs(coords.latitude).toFixed(3)} ${latDir}, ${Math.abs(coords.longitude).toFixed(3)} ${lonDir}`;
   }
   static getDirection(coord) {
@@ -127,16 +127,16 @@ var DateTimeUtils = class {
     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;
+    const tod2 = h * 3600 + m * 60 + s;
+    return tod2;
   }
   static convertDayTimeToTod(time) {
     const d = Number(time.substring(0, 2));
     const h = Number(time.substring(2, 4));
     const m = Number(time.substring(4, 6));
     const s = Number(time.substring(6, 8));
-    const tod = d * 86400 + h * 3600 + m * 60 + s;
-    return tod;
+    const tod2 = d * 86400 + h * 3600 + m * 60 + s;
+    return tod2;
   }
   /**
    *
@@ -412,6 +412,16 @@ var ResultFormatter = class {
       value: decodeResult.raw.alternate_icao
     });
   }
+  /** The airport landing data is for: the destination, or the airport of a divert. */
+  static landingAirport(decodeResult, value) {
+    decodeResult.raw.landing_icao = value;
+    decodeResult.formatted.items.push({
+      type: "icao",
+      code: "LAND",
+      label: "Landing Airport",
+      value: decodeResult.raw.landing_icao
+    });
+  }
   static eta(decodeResult, time) {
     if (isNaN(time)) {
       return;
@@ -602,6 +612,144 @@ var ResultFormatter = class {
       value: `${decodeResult.raw.heading}`
     });
   }
+  static indicatedAirspeed(decodeResult, value) {
+    if (isNaN(value)) {
+      return;
+    }
+    decodeResult.raw.indicated_airspeed = value;
+    decodeResult.formatted.items.push({
+      type: "indicated_airspeed",
+      code: "IAS",
+      label: "Indicated Airspeed",
+      value: `${decodeResult.raw.indicated_airspeed} knots`
+    });
+  }
+  static track(decodeResult, value) {
+    if (isNaN(value)) {
+      return;
+    }
+    decodeResult.raw.track = value;
+    decodeResult.formatted.items.push({
+      type: "track",
+      code: "TRK",
+      label: "Track",
+      value: `${decodeResult.raw.track} degrees`
+    });
+  }
+  /** Wind at the aircraft; either half may be missing. */
+  static wind(decodeResult, direction, speed) {
+    const hasDirection = direction !== void 0 && !isNaN(direction);
+    const hasSpeed = speed !== void 0 && !isNaN(speed);
+    if (hasDirection) decodeResult.raw.wind_direction = direction;
+    if (hasSpeed) decodeResult.raw.wind_speed = speed;
+    if (!hasDirection && !hasSpeed) {
+      return;
+    }
+    decodeResult.formatted.items.push({
+      type: "wind",
+      code: "WIND",
+      label: !hasSpeed ? "Wind Direction" : !hasDirection ? "Wind Speed" : "Wind",
+      value: [
+        hasDirection ? `${direction} degrees` : "",
+        hasSpeed ? `${speed} knots` : ""
+      ].filter((s) => s !== "").join(" at ")
+    });
+  }
+  static variableWind(decodeResult, speed) {
+    if (isNaN(speed)) {
+      return;
+    }
+    decodeResult.raw.wind_speed = speed;
+    decodeResult.raw.wind_variable = true;
+    decodeResult.formatted.items.push({
+      type: "wind",
+      code: "WIND",
+      label: "Wind",
+      value: `variable at ${speed} knots`
+    });
+  }
+  /**
+   * One point of a recorded track. The track is the route as flown, so each point is added to
+   * the route's waypoints; the item shows what the aircraft measured there as well.
+   */
+  static trackPoint(decodeResult, point) {
+    decodeResult.raw.route = {
+      ...decodeResult.raw.route,
+      waypoints: [...decodeResult.raw.route?.waypoints ?? [], point]
+    };
+    decodeResult.formatted.items.push({
+      type: "track_point",
+      code: "TRKPT",
+      label: "Track Point",
+      value: `${CoordinateUtils.coordinateString(point)} on day ${point.day} at ${DateTimeUtils.timestampToString(point.time)}, ${point.altitude} feet, ${point.temperature} C, wind ${point.windDirection} degrees at ${point.windSpeed} knots, ${point.phase}` + (point.waterVapor === void 0 ? "" : `, water vapor ${point.waterVapor} ppmv`)
+    });
+  }
+  static runwayLandingData(decodeResult, data) {
+    decodeResult.raw.landing_runways = [
+      ...decodeResult.raw.landing_runways ?? [],
+      data
+    ];
+    const parts = [];
+    if (data.length !== void 0) parts.push(`${data.length} feet`);
+    if (data.flaps !== void 0) parts.push(`flaps ${data.flaps}`);
+    if (data.headwind !== void 0) {
+      parts.push(
+        data.headwind < 0 ? `tailwind ${-data.headwind} knots` : `headwind ${data.headwind} knots`
+      );
+    }
+    if (data.crosswind !== void 0) {
+      const side = { L: " left", R: " right" }[data.crosswindSide ?? "L"];
+      parts.push(
+        `crosswind ${data.crosswind} knots${data.crosswindSide ? side : ""}`
+      );
+    }
+    if (data.vref !== void 0) parts.push(`VREF ${data.vref} knots`);
+    if (data.vtarget !== void 0) {
+      const add = data.additive === void 0 ? "" : ` (${data.additive < 0 ? "" : "+"}${data.additive})`;
+      parts.push(`VTGT ${data.vtarget} knots${add}`);
+    }
+    if (data.maxLandingWeight !== void 0) {
+      parts.push(`MRLW ${data.maxLandingWeight}`);
+    }
+    if (data.landingWeight !== void 0) {
+      parts.push(`LDW ${data.landingWeight} pounds`);
+    }
+    const margins = Object.entries(data.stoppingMargins).map(
+      ([setting, feet]) => `${setting} ${feet} feet`
+    );
+    if (margins.length > 0) {
+      parts.push(`stopping margin ${margins.join(", ")}`);
+    }
+    parts.push(...data.notes ?? []);
+    const variant2 = data.variant === void 0 ? "" : ` (${data.variant})`;
+    decodeResult.formatted.items.push({
+      type: "runway_landing_data",
+      code: "RWYLDG",
+      label: "Runway Landing Data",
+      value: `${data.runway}${variant2}: ${parts.join(", ")}`
+    });
+  }
+  static grossWeight(decodeResult, pounds3) {
+    if (isNaN(pounds3)) {
+      return;
+    }
+    decodeResult.raw.gross_weight = pounds3;
+    decodeResult.formatted.items.push({
+      type: "gross_weight",
+      code: "GWT",
+      label: "Gross Weight",
+      value: `${decodeResult.raw.gross_weight} pounds`
+    });
+  }
+  static arrivalGate(decodeResult, value) {
+    decodeResult.raw.arrival_gate = value;
+    decodeResult.formatted.items.push({
+      type: "gate",
+      code: "AGATE",
+      label: "Arrival Gate",
+      value: decodeResult.raw.arrival_gate
+    });
+  }
   static tail(decodeResult, value) {
     decodeResult.raw.tail = value;
     decodeResult.formatted.items.push({
@@ -921,6 +1069,14 @@ var ResultFormatter = class {
       value: decodeResult.raw.sequence_response.toString()
     });
   }
+  /**
+   * A field with no specific helper: `key` is its name in `raw` and its item type. `rawValue`
+   * is stored in `raw` when it differs from the text shown (a number, for example).
+   */
+  static raw(decodeResult, key, code, label, value, rawValue = value) {
+    decodeResult.raw[key] = rawValue;
+    decodeResult.formatted.items.push({ type: key, code, label, value });
+  }
   static unknown(decodeResult, value, sep = ",") {
     if (!decodeResult.remaining.text) decodeResult.remaining.text = value;
     else decodeResult.remaining.text += sep + value;
@@ -1266,13 +1422,13 @@ function addCompanyRoute(decodeResult, value) {
   const segments = value.split(".");
   const parens_idx = segments[0].indexOf("(");
   let name;
-  let runway;
+  let runway2;
   if (parens_idx === -1) {
     name = segments[0];
   } else {
     name = segments[0].slice(0, parens_idx);
     const close_paren_idx = segments[0].indexOf(")");
-    runway = segments[0].slice(
+    runway2 = segments[0].slice(
       parens_idx + 1,
       close_paren_idx === -1 ? void 0 : close_paren_idx
     );
@@ -1283,7 +1439,7 @@ function addCompanyRoute(decodeResult, value) {
   }
   decodeResult.raw.company_route = {
     name,
-    runway,
+    runway: runway2,
     waypoints
   };
   decodeResult.formatted.items.push({
@@ -2119,7 +2275,54 @@ var Label_5Z_Slash = class extends DecoderPlugin {
   }
 };
 
+// lib/utils/swa_request.ts
+var AIRLINES = { "189": "Southwest" };
+function swaRequestHeader(decodeResult, airlineId, layout, software) {
+  const airline = AIRLINES[airlineId];
+  ResultFormatter.raw(
+    decodeResult,
+    "airline_id",
+    "AIRLINE",
+    "Airline ID",
+    airline ? `${airlineId} (${airline})` : airlineId,
+    airlineId
+  );
+  ResultFormatter.raw(
+    decodeResult,
+    "request_layout",
+    "LAYOUT",
+    "Request Layout",
+    layout
+  );
+  ResultFormatter.raw(
+    decodeResult,
+    "software_version",
+    "SWVER",
+    "Software Version",
+    software
+  );
+}
+
 // lib/plugins/Label_10_LDR.ts
+function pounds(value) {
+  if (value.trim() === "") return void 0;
+  const thousands = Number(value);
+  return Number.isFinite(thousands) ? Math.round(thousands * 1e3) : void 0;
+}
+function runway(value) {
+  const [rwy, suffix = ""] = value.trim().split("/");
+  return suffix.trim() === "" ? rwy.trim() : `${rwy.trim()}/${suffix.trim()}`;
+}
+var RUNWAY_CONDITION = {
+  6: "dry",
+  5: "good",
+  4: "good to medium",
+  3: "medium",
+  2: "medium to poor",
+  1: "poor",
+  0: "nil"
+};
+var FLAPS = { "0": 30, "1": 40, "2": 15 };
 var Label_10_LDR = class extends DecoderPlugin {
   name = "label-10-ldr";
   qualifiers() {
@@ -2131,18 +2334,13 @@ var Label_10_LDR = class extends DecoderPlugin {
   decode(message, options = {}) {
     const decodeResult = this.defaultResult();
     decodeResult.decoder.name = this.name;
-    decodeResult.formatted.description = "Position Report";
+    decodeResult.formatted.description = "Landing Data Request";
     decodeResult.message = message;
     const parts = message.text.split(",");
-    if (parts.length < 17) {
-      if (options.debug) {
-        console.log(`Decoder: Unknown 10 message: ${message.text}`);
-      }
-      ResultFormatter.unknown(decodeResult, message.text);
-      decodeResult.decoded = false;
-      decodeResult.decoder.decodeLevel = "none";
-      return decodeResult;
+    if (parts.length < 31) {
+      return this.failUnknown(decodeResult, message.text, options);
     }
+    swaRequestHeader(decodeResult, parts[1], parts[2], parts[3]);
     const lat = parts[5];
     const lon = parts[6];
     const position = {
@@ -2150,25 +2348,209 @@ var Label_10_LDR = class extends DecoderPlugin {
       longitude: (lon[0] === "E" ? 1 : -1) * Number(lon.substring(1).trim())
     };
     ResultFormatter.position(decodeResult, position);
-    ResultFormatter.altitude(decodeResult, Number(parts[7]));
+    if (parts[7].trim() !== "") {
+      ResultFormatter.altitude(decodeResult, Number(parts[7]));
+    }
+    const fuel = pounds(parts[8]);
+    if (fuel !== void 0) ResultFormatter.currentFuel(decodeResult, fuel);
     ResultFormatter.departureAirport(decodeResult, parts[9]);
     ResultFormatter.arrivalAirport(decodeResult, parts[10]);
-    ResultFormatter.alternateAirport(decodeResult, parts[11]);
-    ResultFormatter.arrivalRunway(decodeResult, parts[12].split("/")[0]);
-    const altRwy = [parts[13].split("/")[0], parts[14].split("/")[0]].filter((r) => r != "").join(",");
+    ResultFormatter.landingAirport(decodeResult, parts[11]);
+    ResultFormatter.arrivalRunway(decodeResult, runway(parts[12]));
+    const altRwy = [runway(parts[13]), runway(parts[14])].filter((r) => r != "").join(",");
     if (altRwy != "") {
       ResultFormatter.alternateRunway(decodeResult, altRwy);
     }
-    ResultFormatter.unknownArr(decodeResult, [
-      ...parts.slice(0, 5),
-      ...parts.slice(15)
-    ]);
+    const unknown = [parts[4]];
+    const condition = parts[15].trim();
+    if (/^[1-6]$/.test(condition)) {
+      const code = 6 - Number(condition);
+      ResultFormatter.raw(
+        decodeResult,
+        "runway_condition_code",
+        "RCC",
+        "Runway Condition Code",
+        `${code} (${RUNWAY_CONDITION[code]})`,
+        code
+      );
+    } else if (condition !== "0") {
+      unknown.push(parts[15]);
+    }
+    const flaps = FLAPS[parts[16].trim()];
+    if (flaps !== void 0) {
+      ResultFormatter.raw(
+        decodeResult,
+        "landing_flaps",
+        "FLAPS",
+        "Landing Flaps",
+        `${flaps}`,
+        flaps
+      );
+    } else {
+      unknown.push(parts[16]);
+    }
+    const [windDir, windSpeed, gust, temp, dew, altimeter] = parts.slice(17, 23).map((field) => {
+      const value = field.trim();
+      if (/^-?\d{1,4}$/.test(value)) return Number(value);
+      if (value !== "") unknown.push(field);
+      return void 0;
+    });
+    if (windDir !== void 0 || windSpeed !== void 0) {
+      ResultFormatter.wind(decodeResult, windDir, windSpeed);
+    }
+    if (gust !== void 0) {
+      ResultFormatter.raw(
+        decodeResult,
+        "wind_gust",
+        "GUST",
+        "Wind Gust",
+        `${gust} knots`,
+        gust
+      );
+    }
+    ResultFormatter.temperature(
+      decodeResult,
+      temp === void 0 ? "" : `${temp}`
+    );
+    if (dew !== void 0) {
+      ResultFormatter.raw(
+        decodeResult,
+        "dew_point",
+        "DEWPT",
+        "Dew Point (C)",
+        `${dew} degrees`,
+        dew
+      );
+    }
+    if (altimeter !== void 0) {
+      const inHg = altimeter / 100;
+      ResultFormatter.raw(
+        decodeResult,
+        "altimeter",
+        "ALTIM",
+        "Altimeter",
+        `${inHg.toFixed(2)} inHg`,
+        inHg
+      );
+    }
+    const antiIce = parts[23].trim();
+    if (/^[1-9]$/.test(antiIce)) {
+      ResultFormatter.raw(
+        decodeResult,
+        "anti_ice",
+        "ANTIICE",
+        "Anti-Ice",
+        antiIce === "1" ? "engine" : antiIce,
+        Number(antiIce)
+      );
+    } else if (antiIce !== "0") {
+      unknown.push(parts[23]);
+    }
+    const flags = [
+      [parts[24], "enroute_icing", "ICING", "En Route Icing"],
+      // the card says HGS AIII: 113 of 113 pairs, 32 requests
+      [parts[25], "hgs_approach", "HGS", "HGS Approach"]
+    ];
+    for (const [value, key, code, label] of flags) {
+      if (value.trim() === "1") {
+        ResultFormatter.raw(decodeResult, key, code, label, "yes", true);
+      } else if (value.trim() !== "0") {
+        unknown.push(value);
+      }
+    }
+    const nonNormal = parts[26].trim();
+    if (/^\d+$/.test(nonNormal) && Number(nonNormal) !== 0) {
+      ResultFormatter.raw(
+        decodeResult,
+        "non_normal_configuration",
+        "NNC",
+        "Non-Normal Configuration",
+        `${Number(nonNormal)}`,
+        Number(nonNormal)
+      );
+    } else if (!/^0+$/.test(nonNormal)) {
+      unknown.push(parts[26]);
+    }
+    if (parts[27].trim() !== "") unknown.push(parts[27]);
+    const weights = [
+      ["zero_fuel_weight", "ZFW", "Zero Fuel Weight", parts[28]],
+      ["landing_fuel", "LFUEL", "Landing Fuel", parts[29]],
+      ["landing_weight", "LDW", "Landing Weight", parts[30]]
+    ];
+    for (const [key, code, label, value] of weights) {
+      const amount = pounds(value);
+      if (amount === void 0) continue;
+      ResultFormatter.raw(
+        decodeResult,
+        key,
+        code,
+        label,
+        `${amount} pounds`,
+        amount
+      );
+    }
+    const gradient = (parts[31] ?? "").trim();
+    if (/^\d+$/.test(gradient)) {
+      ResultFormatter.raw(
+        decodeResult,
+        "missed_approach_gradient",
+        "MAGRAD",
+        "Missed Approach Climb Gradient",
+        `${Number(gradient)} feet per nautical mile`,
+        Number(gradient)
+      );
+    } else if (gradient !== "" && gradient !== "----.") {
+      unknown.push(parts[31]);
+    }
+    const missedAltitude = (parts[32] ?? "").trim();
+    if (/^\d+$/.test(missedAltitude)) {
+      ResultFormatter.raw(
+        decodeResult,
+        "missed_approach_altitude",
+        "MAALT",
+        "Missed Approach Altitude",
+        `${Number(missedAltitude)} feet`,
+        Number(missedAltitude)
+      );
+    } else if (missedAltitude !== "") {
+      unknown.push(parts[32]);
+    }
+    unknown.push(...parts.slice(33).filter((field) => field.trim() !== ""));
+    ResultFormatter.unknownArr(decodeResult, unknown);
     decodeResult.decoded = true;
     decodeResult.decoder.decodeLevel = "partial";
     return decodeResult;
   }
 };
 
+// lib/plugins/Label_10_LRW.ts
+var Label_10_LRW = class extends DecoderPlugin {
+  name = "label-10-lrw";
+  qualifiers() {
+    return {
+      labels: ["10"],
+      preambles: ["LRW01,"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.initResult(message, "Landing Runways Request");
+    const parts = message.text.split(",");
+    if (parts.length < 8 || parts[7].trim() === "") {
+      return this.failUnknown(decodeResult, message.text, options);
+    }
+    swaRequestHeader(decodeResult, parts[1], parts[2], parts[3]);
+    ResultFormatter.departureAirport(decodeResult, parts[6]);
+    ResultFormatter.arrivalAirport(decodeResult, parts[7]);
+    ResultFormatter.unknownArr(decodeResult, [
+      parts[4],
+      parts[5],
+      ...parts.slice(8).filter((field) => field.trim() !== "")
+    ]);
+    this.setDecodeLevel(decodeResult, true);
+    return decodeResult;
+  }
+};
+
 // lib/plugins/Label_10_POS.ts
 var Label_10_POS = class extends DecoderPlugin {
   name = "label-10-pos";
@@ -2268,6 +2650,364 @@ var Label_10_Slash = class extends DecoderPlugin {
   }
 };
 
+// lib/utils/runway_utils.ts
+var SIDES = {
+  N: "north",
+  NE: "northeast",
+  E: "east",
+  SE: "southeast",
+  S: "south",
+  SW: "southwest",
+  W: "west",
+  NW: "northwest"
+};
+var RunwayUtils = class {
+  /**
+   * Describe the condition that names a runway variant in Southwest landing data, e.g.
+   * `11/AIB -E1804F`: the runway, the variant's code and its condition.
+   *
+   * -E1804F is 1804 feet taken off the east end, -SWCBL the arresting cable at the southwest
+   * end. Checked on the LRW01 runway lists of six airports, where every variant's length is
+   * the runway's less the feet given, or less 1500 feet for a cable. LAHSO is sent as written.
+   *
+   * @param name - the runway as sent, with its variant
+   * @returns a description of the condition, or undefined when the name has none
+   */
+  static variantDescription(name) {
+    const text = name.trim();
+    const cut = text.match(/-(NE|NW|SE|SW|N|E|S|W)(\d+)F$/);
+    if (cut) {
+      return `${Number(cut[2])} feet off the ${SIDES[cut[1]]} end`;
+    }
+    const cable = text.match(/-(NE|NW|SE|SW|N|E|S|W)CBL$/);
+    if (cable) {
+      return `arresting cable at the ${SIDES[cable[1]]} end`;
+    }
+    if (/(^|\s)LAHSO$/.test(text)) {
+      return "land and hold short";
+    }
+    return void 0;
+  }
+};
+
+// lib/plugins/Label_11_LDR.ts
+function tod(hours, minutes) {
+  const h = Number(hours);
+  const m = Number(minutes);
+  return h <= 23 && m <= 59 ? h * 3600 + m * 60 : void 0;
+}
+function pounds2(value) {
+  return Math.round(Number(value) * 1e3);
+}
+function variant(runway2) {
+  const description = RunwayUtils.variantDescription(runway2);
+  return description === void 0 ? {} : { variant: description };
+}
+var HEADER = [
+  /^LDR01,(\w{4}) LANDING DATA,FLT(?:\s+METAR-(\d{2})(\d{2})Z)?\s*$/,
+  /^(\d{1,4})\s+WIND\s+LDW\s*$/,
+  /^TIME\s+(\d{3}|VRB)\/(\d{2,3})G(\d{2,3}|--)\s+(\d+\.\d)\s*$/,
+  /^(\d{2})(\d{2})Z\s+OAT\/DEW\s*(\S*)\s*$/,
+  /^\s+(-?\d{2,3})\/(-?\d{2,3})\s*(\S*)\s*$/,
+  /^\s+QNH\s*(\S*)\s*$/,
+  // QNH in inches of mercury, or hectopascals outside the US
+  /^\s+(\d{2}\.\d{2}|\d{4})\s*(\S*)\s*$/
+];
+var RUNWAY = /^(\d{1,2}[LRC]?(?:\/\S+)?(?: -\S+)?)\s+(\d{1,5})\s*$/;
+var RUNWAY_START = /^\d{1,2}[LRC]?(?:\/\S+)?(?: -\S+)?(?:\s{2,}\d*)?\s*$/;
+var ALTERNATIVES = "--- ALTERNATIVE RWYS ---";
+var ALTERNATIVE = /^(?:(.+?)\s{2,})?(\d{1,2}[LRC]?(?:\/\S+)?)\s*$/;
+var BLOCK = [
+  /^FLAPS (\d{2}|--)\s*$/,
+  /^VREF\/VTGT\s+(?:(\d{2})([HT])\/(\d{2})([LR])|---\/---)\s*$/,
+  /^\s*(?:(\d{3})\/(\d{3}) ([+-]\d+)|---\/---)\s+(AB\d)\s+(\d+|----)\s*$/,
+  /^MRLW (\d+\.\d\/\S|-+\/-)\s+(AB\d)\s+(\d+|----)\s*$/,
+  /^\s*LDW (\d+\.\d)\s+(ABM)\s+(\d+|----)\s*$/
+];
+var Label_11_LDR = class extends DecoderPlugin {
+  name = "label-11-ldr";
+  qualifiers() {
+    return {
+      labels: ["11"],
+      preambles: ["LDR01,"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.initResult(message, "Landing Data");
+    const nl = message.text.includes("\r\n") ? "\r\n" : "\n";
+    const lines = message.text.split(/\r?\n/);
+    const first = lines[0].match(HEADER[0]);
+    if (!first) {
+      return this.failUnknown(decodeResult, message.text, options);
+    }
+    const unknown = [];
+    ResultFormatter.landingAirport(decodeResult, first[1]);
+    const metar = first[2] === void 0 ? void 0 : tod(first[2], first[3]);
+    if (first[2] !== void 0 && metar === void 0) {
+      unknown.push(`METAR-${first[2]}${first[3]}Z`);
+    }
+    if (metar !== void 0) {
+      ResultFormatter.raw(
+        decodeResult,
+        "metar_time",
+        "METAR",
+        "METAR Time",
+        DateTimeUtils.timestampToString(metar),
+        metar
+      );
+    }
+    const runways = [];
+    let i = 1;
+    for (; i < HEADER.length && i < lines.length; i++) {
+      const m = lines[i].match(HEADER[i]);
+      if (!m) break;
+      if (i === 1) {
+        ResultFormatter.flightNumber(decodeResult, m[1]);
+      } else if (i === 2) {
+        if (m[1] === "VRB") {
+          ResultFormatter.variableWind(decodeResult, Number(m[2]));
+        } else {
+          ResultFormatter.wind(decodeResult, Number(m[1]), Number(m[2]));
+        }
+        if (m[3] !== "--") {
+          ResultFormatter.raw(
+            decodeResult,
+            "wind_gust",
+            "GUST",
+            "Wind Gust",
+            `${Number(m[3])} knots`,
+            Number(m[3])
+          );
+        }
+        ResultFormatter.raw(
+          decodeResult,
+          "landing_weight",
+          "LDW",
+          "Landing Weight",
+          `${pounds2(m[4])} pounds`,
+          pounds2(m[4])
+        );
+      } else if (i === 3) {
+        const time = tod(m[1], m[2]);
+        if (time === void 0) {
+          unknown.push(`${m[1]}${m[2]}Z`);
+        } else {
+          ResultFormatter.timestamp(decodeResult, time);
+        }
+        runways.push(m[3]);
+      } else if (i === 4) {
+        ResultFormatter.temperature(decodeResult, `${Number(m[1])}`);
+        ResultFormatter.raw(
+          decodeResult,
+          "dew_point",
+          "DEWPT",
+          "Dew Point (C)",
+          `${Number(m[2])} degrees`,
+          Number(m[2])
+        );
+        runways.push(m[3]);
+      } else if (i === 5) {
+        runways.push(m[1]);
+      } else {
+        ResultFormatter.raw(
+          decodeResult,
+          "altimeter",
+          "ALTIM",
+          "Altimeter",
+          `${m[1]} ${m[1].includes(".") ? "inHg" : "hPa"}`,
+          Number(m[1])
+        );
+        runways.push(m[2]);
+      }
+    }
+    const listed = runways.filter((r) => r !== "");
+    if (listed.length > 0) {
+      ResultFormatter.raw(
+        decodeResult,
+        "runways",
+        "RWYS",
+        "Runways",
+        listed.join(", "),
+        listed
+      );
+    }
+    const rest = lines.slice(i);
+    let at = 0;
+    const alternatives = [];
+    if (rest[0]?.trim() === "REMARKS") {
+      const remarks = [];
+      for (at = 1; at < rest.length && !RUNWAY_START.test(rest[at]); at++) {
+        if (rest[at].trim() === ALTERNATIVES) {
+          at = this.alternatives(rest, at + 1, alternatives, unknown);
+          break;
+        }
+        if (rest[at].trim() !== "") remarks.push(rest[at].trim());
+      }
+      if (remarks.length > 0) {
+        ResultFormatter.raw(
+          decodeResult,
+          "remarks",
+          "RMK",
+          "Remarks",
+          remarks.join(" ")
+        );
+      }
+    }
+    if (alternatives.length > 0) {
+      ResultFormatter.raw(
+        decodeResult,
+        "alternative_runways",
+        "ALTRWY",
+        "Alternative Runways",
+        alternatives.map((a) => a.variant ? `${a.runway} (${a.variant})` : a.runway).join(", "),
+        alternatives
+      );
+    }
+    const blocks = [];
+    while (at < rest.length) {
+      const block = this.runwayBlock(rest.slice(at, at + 1 + BLOCK.length));
+      if (block) {
+        blocks.push(block);
+        at += 1 + BLOCK.length;
+        continue;
+      }
+      const line = rest[at];
+      const head = line.match(RUNWAY);
+      const next = rest.slice(at + 1).find((l) => l.trim() !== "");
+      if (head && next !== void 0 && !next.startsWith("FLAPS") && // a FLAPS line cut off by the end of the block
+      !"FLAPS".startsWith(next.trim()) && !RUNWAY_START.test(next)) {
+        blocks.push({
+          runway: head[1],
+          ...variant(head[1]),
+          length: Number(head[2]),
+          stoppingMargins: {}
+        });
+        at++;
+        continue;
+      }
+      const last = blocks[blocks.length - 1];
+      if (line.trim() !== "") {
+        if (last && !RUNWAY_START.test(line)) {
+          last.notes = [...last.notes ?? [], line.trim()];
+        } else {
+          unknown.push(...rest.slice(at).filter((l) => l.trim() !== ""));
+          break;
+        }
+      }
+      at++;
+    }
+    for (const block of blocks) {
+      ResultFormatter.runwayLandingData(decodeResult, block);
+    }
+    if (unknown.length > 0) {
+      ResultFormatter.unknown(decodeResult, unknown.join(nl), nl);
+    }
+    this.setDecodeLevel(
+      decodeResult,
+      true,
+      i < HEADER.length ? "partial" : void 0
+    );
+    return decodeResult;
+  }
+  /** The six lines of one runway, or undefined if they are not a whole block. */
+  runwayBlock(lines) {
+    const head = lines[0]?.match(RUNWAY);
+    if (!head || lines.length < 1 + BLOCK.length) return void 0;
+    const m = BLOCK.map((re, n) => lines[n + 1].match(re));
+    if (m.some((x) => !x)) return void 0;
+    const [flaps, wind, speeds, mrlw, ldw] = m;
+    const data = {
+      runway: head[1],
+      ...variant(head[1]),
+      length: Number(head[2]),
+      stoppingMargins: {}
+    };
+    if (flaps[1] !== "--") data.flaps = Number(flaps[1]);
+    if (wind[1] !== void 0) {
+      data.headwind = Number(wind[1]) * (wind[2] === "T" ? -1 : 1);
+      data.crosswind = Number(wind[3]);
+      data.crosswindSide = wind[4];
+    }
+    if (speeds[1] !== void 0) {
+      data.vref = Number(speeds[1]);
+      data.vtarget = Number(speeds[2]);
+      data.additive = Number(speeds[3]);
+    }
+    if (!mrlw[1].startsWith("-")) data.maxLandingWeight = mrlw[1];
+    data.landingWeight = pounds2(ldw[1]);
+    for (const [setting, feet] of [
+      [speeds[4], speeds[5]],
+      [mrlw[2], mrlw[3]],
+      [ldw[2], ldw[3]]
+    ]) {
+      if (feet !== "----") data.stoppingMargins[setting] = Number(feet);
+    }
+    return data;
+  }
+  /**
+   * The runways listed after ALTERNATIVE RWYS, which run to the end of the card. Returns the
+   * index of the line after them.
+   */
+  alternatives(lines, from, out, unknown) {
+    for (let n = from; n < lines.length; n++) {
+      const line = lines[n];
+      if (line.trim() === "") continue;
+      const m = line.match(ALTERNATIVE);
+      if (!m || n === lines.length - 1) {
+        unknown.push(line.trim());
+        continue;
+      }
+      const name = m[1]?.trim();
+      out.push({
+        runway: m[2],
+        ...name === void 0 ? {} : { name },
+        ...variant(name ?? m[2])
+      });
+    }
+    return lines.length;
+  }
+};
+
+// lib/plugins/Label_11_LRW.ts
+var RUNWAY2 = /^(\d{1,2}[LRC]?)\s?(?:\/(\S+))?\s+(?:(-\S+|LAHSO)\s+)?(\d{3,5})\s*$/;
+var Label_11_LRW = class extends DecoderPlugin {
+  name = "label-11-lrw";
+  qualifiers() {
+    return {
+      labels: ["11"],
+      preambles: ["LRW01,"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.initResult(message, "Landing Runways");
+    const nl = message.text.includes("\r\n") ? "\r\n" : "\n";
+    const first = message.text.match(/^LRW01,(\w{4}) LANDING RUNWAYS,/);
+    if (!first) {
+      return this.failUnknown(decodeResult, message.text, options);
+    }
+    ResultFormatter.landingAirport(decodeResult, first[1]);
+    const lines = message.text.slice(first[0].length).split(/\r?\n/);
+    for (const line of lines) {
+      if (line.trim() === "") continue;
+      const m = line.match(RUNWAY2);
+      if (!m) {
+        ResultFormatter.unknown(decodeResult, line.trim(), nl);
+        continue;
+      }
+      const runway2 = [m[2] ? `${m[1]}/${m[2]}` : m[1], m[3]].filter((part) => part !== void 0).join(" ");
+      const description = RunwayUtils.variantDescription(runway2);
+      ResultFormatter.runwayLandingData(decodeResult, {
+        runway: runway2,
+        ...description === void 0 ? {} : { variant: description },
+        length: Number(m[4]),
+        stoppingMargins: {}
+      });
+    }
+    this.setDecodeLevel(decodeResult, true);
+    return decodeResult;
+  }
+};
+
 // lib/plugins/Label_12_N_Space.ts
 var Label_12_N_Space = class extends DecoderPlugin {
   name = "label-12-n-space";
@@ -3695,6 +4435,713 @@ var Label_30_Slash_EA = class extends DecoderPlugin {
   }
 };
 
+// lib/utils/swa_compressed.ts
+var SWA_ALPHABET = " (),-./0123456789:ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var SWA_UNREAD = "\xA4";
+var SWA_LABEL_37_TABLES = {
+  "01": "VIK86MRN5-0PZS4UYXACEHLOTW BGD.123Q(7J9:F)/,",
+  "02": "HG.KZL97QY15WRVTN4JA06(D ,:3MPBICU/8EOFSX)2-",
+  "03": "4GXE/QU5FT)20P8RSJ-169AWHLB.,37MNVCYODIKZ (:",
+  "04": "1BEHMPSUY,048DG269JLOQTWZ (-/37:ACFIKNRVX).5",
+  "05": "3579BDFHJLNPRTVXZ(,.02468:ACEGIKMOQSUWY )-/1",
+  "06": "AGFEDCBRQPONMLKJIH:9876543210/.-,)( ZYXWVUTS",
+  "07": ":.02468ACEGIKMOQSUWY )-/13579BDFHJLNPRTVXZ(,",
+  "08": "1MDS/JQ.OWZ79LNR532-6(: ,APEFTVIKYB08H)U4CXG",
+  "09": "6LQMSR UZYVX(7:3-5KPTACB)021,894NODGJEFIHW./"
+};
+var SWA_LABEL_40_TABLES = {
+  "01": "IRXZ2MY3NOP71-S,UVAJBLCWKD(T)E.0F4Q/6G8 H:95",
+  "02": "GEXHZ)QC3YJ:4D0R/IBMOFSU( NA,.K9TL16V8P75W2-",
+  "03": "XY3KAJ-5B4L 0CM7DZEIQT,1(GU:VHNOS6.892/PF)RW",
+  "04": "HIX2JYK3 8L4Z9M5:NO(P6)Q7,RASB-TC.DU/E0VFW1G",
+  "05": "V:WAXBYCZD E(F)G,HI-J.K/L0M1N2O3P4Q5R6S7T8U9",
+  "06": "RQPONMLKJIHGFEDCBA /.-,)(:9876543210ZYXWVUTS",
+  "07": "CYDZE(F)G,H-I.J/K 0L1M2N3O4P5Q6R7S8T9U:VAWBX",
+  "08": "FDUGB0-R A:W9C4S5EHQX)JKZTN.O6(71I/8,LVM2YP3",
+  "09": "/5GK9YZHJI8N: 6LM7DFEQTURWVSA(,OPB).-C03X421"
+};
+var PASS_37 = { "*": "*", ">": "+" };
+var PASS_40 = {
+  "*": "*",
+  "?": "?",
+  "'": "'",
+  "#": "#",
+  _: "_"
+};
+function lookup(table, c) {
+  const i = SWA_ALPHABET.indexOf(c);
+  return i < 0 ? void 0 : table[i];
+}
+function plain(table, body, pass) {
+  let out = "";
+  for (const c of body) {
+    if (c === "\n") out += "|";
+    else out += lookup(table, c) ?? pass[c] ?? SWA_UNREAD;
+  }
+  return out;
+}
+function decodeSwaLabel37(body) {
+  const b = body.replace(/\r/g, "");
+  const table = SWA_LABEL_37_TABLES[b.substring(0, 2)];
+  if (!table) return void 0;
+  let nl = b.indexOf("\n");
+  if (nl !== 7 && b.length > 7 && lookup(table, b[7]) === ",") nl = 7;
+  if (nl < 0 || nl > 8) return void 0;
+  let type = "";
+  for (const c of b.substring(2, Math.min(nl, 7))) {
+    type += lookup(table, c) ?? SWA_UNREAD;
+  }
+  return { type, text: plain(table, b.substring(nl + 1), PASS_37) };
+}
+function decodeSwaLabel40(body) {
+  const b = body.replace(/\r/g, "");
+  if (b.startsWith("POS01,")) {
+    return { type: "POS01", text: b.trim() };
+  }
+  const code = b[5] === "," ? b.substring(6, 8) : "";
+  if (code === "00") {
+    return {
+      type: b.substring(0, 5),
+      text: b.substring(8).replace(/\n/g, "|")
+    };
+  }
+  const table = SWA_LABEL_40_TABLES[code];
+  if (!table) return void 0;
+  return {
+    type: b.substring(0, 5),
+    text: plain(table, b.substring(8), PASS_40)
+  };
+}
+var SWA_TYPES = {
+  "37": /* @__PURE__ */ new Set([
+    "ADV01",
+    "CLB02",
+    "DIV02",
+    "DVC01",
+    "ETA03",
+    "FCM01",
+    "FCR03",
+    "FFD01",
+    "FHD04",
+    "FLI01",
+    "FTD02",
+    "GAM02",
+    "GSR02",
+    "HGD03",
+    "HLD01",
+    "INN03",
+    "INR04",
+    "MXR03",
+    "OFF02",
+    "OFP01",
+    "ONN02",
+    "OUT03",
+    "PFR03",
+    "PFR04",
+    "PJS01",
+    "PNS01",
+    "POS01",
+    "POS02",
+    "PRM01",
+    "RRR01",
+    "RTG03",
+    "RTG04",
+    "RTG05",
+    "TAR02",
+    "TDM01",
+    "TOD03",
+    "TRB02",
+    "TXI02",
+    "VXR02"
+  ]),
+  "40": /* @__PURE__ */ new Set([
+    "ASR01",
+    "DVP01",
+    "FTX01",
+    "GAR03",
+    "GEN01",
+    "PIC01",
+    "POS01",
+    "WFC01"
+  ])
+};
+function isSwaType(type, label) {
+  return SWA_TYPES[label].has(type);
+}
+
+// lib/utils/swa_fields.ts
+var APT = "(?:[A-Z]{4}| {4}|)";
+var LAT = "(?:[NS] ?\\d{1,2}\\.\\d{3}|-{4}\\.-{3}|)";
+var LON = "(?:[EW] ?\\d{1,3}\\.\\d{3}|-{4}\\.-{3}|)";
+var T4 = "(?:\\d{4}|\\*{4}|-{4})";
+var FOB = "(?: ?\\d{1,2}\\.\\d|\\*\\*\\.\\*)";
+var INT = "(?: *-? *\\d+| *|-+|\\*+)";
+var MACH = "\\.\\d{3}";
+var HMS = "\\d{6}";
+var OC = "[OC]";
+var POS = [
+  APT,
+  APT,
+  LAT,
+  LON,
+  INT,
+  INT,
+  INT,
+  MACH,
+  FOB,
+  T4,
+  INT,
+  INT,
+  INT,
+  INT
+];
+var ASR = " *-?\\d+(?:\\.[\\d-])?|XX\\.X";
+var SWA_LAYOUTS = {
+  ASR01: [[ASR, ASR, ASR, ASR, ASR, ASR, ASR, ASR, "", ""]],
+  CLB02: [[APT, APT, LAT, "", LON, FOB, T4]],
+  ETA03: [[APT, APT, T4, FOB, LAT, LON]],
+  FCM01: [["L[\\d-]", "R[\\d-]", "A[\\d-]", "B[\\d-]", "\\d+", T4]],
+  FHD04: [
+    [
+      ...POS,
+      "(?:OUT|OFF|ON|IN|RET IN)",
+      "X",
+      INT,
+      " *\\d*",
+      HMS,
+      "(?:\\d{6}|-{6})",
+      "\\d{5}"
+    ]
+  ],
+  FLI01: [[APT, APT, T4, FOB, LAT, LON]],
+  GAM02: [[APT, APT, T4, LAT, LON]],
+  GAR03: [
+    [
+      "[A-Z0-9]{1,4} *",
+      "[YN]",
+      "[YN]",
+      "[YN]",
+      "[YN]",
+      "[YN]",
+      "(?:1[23]\\d\\.\\d{1,3}|999\\.999)",
+      "",
+      ""
+    ]
+  ],
+  HGD03: [[...POS, INT]],
+  INN03: [[APT, APT, T4, T4, FOB, OC, OC, OC, OC]],
+  INR04: [[APT, APT, T4, T4, FOB, LAT, LON]],
+  OUT03: [[APT, APT, T4, FOB, FOB, T4]],
+  POS01: [
+    [...POS, INT],
+    [...POS, INT, HMS]
+  ],
+  POS02: [[...POS, INT, HMS]],
+  RTG04: [[APT, APT, T4, T4, T4, FOB, OC, OC, OC, OC]],
+  RTG05: [[APT, APT, T4, T4, T4, FOB, OC, OC, OC, OC]],
+  TDM01: [[APT, APT, LAT, LON, "(?:L1|L2|CR|SV)", OC, T4, HMS]],
+  TXI02: [[APT, APT, T4, FOB]],
+  VXR02: [["[A-Z]{3}"]]
+};
+var SWA_PREFIX_LAYOUTS = {
+  MXR03: [APT, "(?:\\d{4}|)", "[0-3]"]
+};
+function swaFields(text) {
+  return text.replace(/\|/g, ",").split(",");
+}
+function swaMatchesLayout(fields, layouts) {
+  return layouts.some(
+    (layout) => layout.length === fields.length && layout.every((rx, i) => new RegExp(`^(?:${rx})$`).test(fields[i]))
+  );
+}
+var SwaFieldWriter = class {
+  constructor(decodeResult, fields) {
+    this.decodeResult = decodeResult;
+    this.fields = fields;
+  }
+  decodeResult;
+  fields;
+  used = /* @__PURE__ */ new Set();
+  take(i) {
+    this.used.add(i);
+    return this.fields[i] ?? "";
+  }
+  /** A field with no specific ResultFormatter helper; `key` is its name in `raw`. */
+  item(i, key, code, label, value) {
+    this.used.add(i);
+    ResultFormatter.raw(this.decodeResult, key, code, label, value);
+  }
+  /** Marks a field as read without writing it (it was written together with another). */
+  use(i) {
+    return this.take(i);
+  }
+  departure(i) {
+    const v = this.take(i);
+    if (/^[A-Z]{4}$/.test(v))
+      ResultFormatter.departureAirport(this.decodeResult, v);
+  }
+  arrival(i) {
+    const v = this.take(i);
+    if (/^[A-Z]{4}$/.test(v))
+      ResultFormatter.arrivalAirport(this.decodeResult, v);
+  }
+  /**
+   * Writes the position when both coordinates are present and in range. Otherwise the
+   * placeholders are consumed and any coordinate that was sent stays for `remaining`.
+   */
+  position(latIndex, lonIndex) {
+    const lat = this.fields[latIndex] ?? "";
+    const lon = this.fields[lonIndex] ?? "";
+    const latitude = /^[NS] ?\d/.test(lat) ? CoordinateUtils.getDirection(lat) * Number(lat.substring(1).trim()) : NaN;
+    const longitude = /^[EW] ?\d/.test(lon) ? CoordinateUtils.getDirection(lon) * Number(lon.substring(1).trim()) : NaN;
+    if (Math.abs(latitude) <= 90 && Math.abs(longitude) <= 180) {
+      this.used.add(latIndex);
+      this.used.add(lonIndex);
+      ResultFormatter.position(this.decodeResult, { latitude, longitude });
+      return;
+    }
+    if (!/^[NS] ?\d/.test(lat)) this.used.add(latIndex);
+    if (!/^[EW] ?\d/.test(lon)) this.used.add(lonIndex);
+  }
+  /** A whole number, or undefined for a placeholder. */
+  int(i) {
+    const v = this.take(i).replace(/ /g, "");
+    return /^-?\d+$/.test(v) ? Number(v) : void 0;
+  }
+  altitude(i) {
+    const v = this.int(i);
+    if (v !== void 0) ResultFormatter.altitude(this.decodeResult, v);
+  }
+  /** Fuel on board, sent in thousands of pounds; written in pounds. */
+  fuel(i) {
+    const v = this.take(i).trim();
+    if (/^\d+\.\d$/.test(v)) {
+      ResultFormatter.currentFuel(
+        this.decodeResult,
+        Math.round(Number(v) * 1e3)
+      );
+    }
+  }
+  /**
+   * HHMM or HHMMSS as seconds of the day. A placeholder is consumed; a time out of range is
+   * left for `remaining`.
+   */
+  tod(i) {
+    const v = this.fields[i] ?? "";
+    if (/^(?:[01]\d|2[0-3])[0-5]\d(?:[0-5]\d)?$/.test(v)) {
+      this.used.add(i);
+      return DateTimeUtils.convertHHMMSSToTod(v);
+    }
+    if (!/^\d+$/.test(v)) this.used.add(i);
+    return void 0;
+  }
+  /** Writes a time through a ResultFormatter helper such as `out`, `in` or `timestamp`. */
+  time(i, write) {
+    const t = this.tod(i);
+    if (t !== void 0) write(this.decodeResult, t);
+  }
+  /** A time with no ResultFormatter helper, written as HH:MM:SS. */
+  timeItem(i, key, code, label) {
+    const t = this.tod(i);
+    if (t !== void 0) {
+      this.item(i, key, code, label, DateTimeUtils.timestampToString(t));
+    }
+  }
+  eta(i) {
+    this.time(i, (r, t) => ResultFormatter.eta(r, t));
+  }
+  /** Fields not written above, non-empty, to `remaining`. */
+  finish() {
+    const rest = this.fields.filter(
+      (v, i) => !this.used.has(i) && v.trim() !== ""
+    );
+    if (rest.length > 0) ResultFormatter.unknownArr(this.decodeResult, rest);
+    return rest.length;
+  }
+};
+
+// lib/plugins/Label_37_SWA.ts
+var DESCRIPTIONS = {
+  ADV01: "Ride Conditions Report",
+  CLB02: "Climb Report",
+  DVC01: "Divert Plan (Crew Copy)",
+  ETA03: "ETA Report",
+  FCM01: "Engine and Fuel State",
+  FCR03: "Runway Condition Report",
+  FHD04: "Frequency Handoff Report",
+  FLI01: "Flight Initialization",
+  FTD02: "Free Text to Dispatch",
+  GAM02: "Gate Assignment Request",
+  HGD03: "HowGozit Report",
+  HLD01: "Holding Report",
+  INN03: "In Report",
+  INR04: "In Range Report",
+  MXR03: "Maintenance Report",
+  OFF02: "Off Report",
+  ONN02: "On Report",
+  OUT03: "Out Report",
+  PFR03: "Post Flight Report",
+  POS01: "Position Report",
+  POS02: "Position Report",
+  RRR01: "Reroute Report",
+  RTG04: "Return to Gate Report",
+  RTG05: "Return to Gate Report",
+  TDM01: "Door Report",
+  TRB02: "Turbulence Report",
+  TXI02: "Taxi Report",
+  VXR02: "Voice Call Request"
+};
+var DOORS = {
+  L1: "L1 (forward entry)",
+  L2: "L2 (aft entry)",
+  CR: "Cargo",
+  SV: "Service"
+};
+var MXR_CODES = {
+  "0": "Nothing to report",
+  "1": "Status option",
+  "2": "Category and text",
+  "3": "Free text"
+};
+var Label_37_SWA = class extends DecoderPlugin {
+  name = "label-37-swa";
+  qualifiers() {
+    return {
+      labels: ["37"],
+      preambles: ["01", "02", "03", "04", "05", "06", "07", "08", "09"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    const d = decodeSwaLabel37(message.text);
+    if (!d || !isSwaType(d.type, "37")) {
+      if (options.debug) {
+        console.log(`Decoder: Unknown 37 message: ${message.text}`);
+      }
+      ResultFormatter.unknown(decodeResult, message.text);
+      decodeResult.formatted.description = "Unknown";
+      return decodeResult;
+    }
+    decodeResult.decoded = true;
+    decodeResult.formatted.description = DESCRIPTIONS[d.type] ?? "Southwest Message";
+    decodeResult.raw.preamble = d.type;
+    const text = d.text;
+    const fields = swaFields(text);
+    const layouts = SWA_LAYOUTS[d.type];
+    const prefix = SWA_PREFIX_LAYOUTS[d.type];
+    const clean = !text.includes(SWA_UNREAD);
+    if (clean && layouts && swaMatchesLayout(fields, layouts)) {
+      const rest = this.writeFields(decodeResult, d.type, fields);
+      decodeResult.decoder.decodeLevel = rest === 0 ? "full" : "partial";
+      return decodeResult;
+    }
+    if (clean && prefix && swaMatchesLayout(fields.slice(0, prefix.length), [prefix])) {
+      const rest = this.writeMaintenance(decodeResult, text, fields);
+      decodeResult.decoder.decodeLevel = rest === 0 ? "full" : "partial";
+      return decodeResult;
+    }
+    if (clean && !layouts && !prefix) {
+      const lines = text.split("|");
+      const route = lines[0].match(/^([A-Z]{4}),([A-Z]{4})$/);
+      if (route && d.type === "FTD02") {
+        ResultFormatter.departureAirport(decodeResult, route[1]);
+        ResultFormatter.arrivalAirport(decodeResult, route[2]);
+        lines.shift();
+      }
+      ResultFormatter.text(decodeResult, lines.join("\n"));
+      decodeResult.decoder.decodeLevel = "full";
+      return decodeResult;
+    }
+    ResultFormatter.text(decodeResult, text.split("|").join("\n"));
+    decodeResult.decoder.decodeLevel = "partial";
+    return decodeResult;
+  }
+  /** Writes a laid-out type's fields; returns how many went to `remaining`. */
+  writeFields(decodeResult, type, fields) {
+    const w = new SwaFieldWriter(decodeResult, fields);
+    switch (type) {
+      case "POS01":
+      case "POS02":
+      case "HGD03":
+      case "FHD04": {
+        w.departure(0);
+        w.arrival(1);
+        w.position(2, 3);
+        w.altitude(4);
+        const ias = w.int(5);
+        if (ias !== void 0)
+          ResultFormatter.indicatedAirspeed(decodeResult, ias);
+        const tas = w.int(6);
+        if (tas !== void 0) ResultFormatter.airspeed(decodeResult, tas);
+        ResultFormatter.mach(decodeResult, Number(w.use(7)));
+        w.fuel(8);
+        w.eta(9);
+        const track = w.int(10);
+        if (track !== void 0) ResultFormatter.track(decodeResult, track);
+        ResultFormatter.wind(decodeResult, w.int(11), w.int(12));
+        const sat = w.int(13);
+        if (sat !== void 0)
+          ResultFormatter.temperature(decodeResult, `${sat}`);
+        const gwIndex = type === "FHD04" ? 16 : 14;
+        const gw = w.int(gwIndex);
+        if (gw !== void 0) ResultFormatter.grossWeight(decodeResult, gw);
+        if (type !== "FHD04" && fields.length === 16) {
+          w.time(15, (r, t) => ResultFormatter.timestamp(r, t));
+        }
+        if (type === "FHD04") {
+          w.item(14, "event", "EVT", "Event", fields[14]);
+          w.use(15);
+          const freq = w.use(19);
+          if (/^1\d{5}$/.test(freq)) {
+            w.item(
+              19,
+              "frequency",
+              "FREQ",
+              "ACARS Frequency",
+              `${freq.substring(0, 3)}.${freq.substring(3)} MHz`
+            );
+          }
+        }
+        break;
+      }
+      case "GAM02":
+        w.departure(0);
+        w.arrival(1);
+        w.eta(2);
+        w.position(3, 4);
+        break;
+      case "CLB02":
+        w.departure(0);
+        w.arrival(1);
+        w.position(2, 4);
+        w.fuel(5);
+        w.eta(6);
+        break;
+      case "ETA03":
+        w.departure(0);
+        w.arrival(1);
+        w.eta(2);
+        w.fuel(3);
+        w.position(4, 5);
+        break;
+      case "INR04":
+        w.departure(0);
+        w.arrival(1);
+        w.eta(2);
+        w.time(3, (r, t) => ResultFormatter.timestamp(r, t));
+        w.fuel(4);
+        w.position(5, 6);
+        break;
+      case "FLI01":
+        w.departure(0);
+        w.arrival(1);
+        w.time(2, (r, t) => ResultFormatter.timestamp(r, t));
+        w.fuel(3);
+        w.position(4, 5);
+        break;
+      case "OUT03":
+        w.departure(0);
+        w.arrival(1);
+        w.time(2, (r, t) => ResultFormatter.out(r, t));
+        w.fuel(3);
+        w.timeItem(5, "front_door_closed_time", "L1CLS", "Front Door Closed");
+        break;
+      case "TXI02":
+        w.departure(0);
+        w.arrival(1);
+        w.timeItem(2, "taxi_start_time", "TAXI", "Taxi Start Time");
+        w.fuel(3);
+        break;
+      case "INN03":
+        w.departure(0);
+        w.arrival(1);
+        w.time(2, (r, t) => ResultFormatter.in(r, t));
+        w.timeItem(3, "front_door_open_time", "L1OPN", "Front Door Opened");
+        w.fuel(4);
+        break;
+      case "RTG04":
+      case "RTG05":
+        w.departure(0);
+        w.arrival(1);
+        w.time(2, (r, t) => ResultFormatter.out(r, t));
+        w.time(3, (r, t) => ResultFormatter.in(r, t));
+        w.time(4, (r, t) => ResultFormatter.timestamp(r, t));
+        w.fuel(5);
+        break;
+      case "TDM01": {
+        w.departure(0);
+        w.arrival(1);
+        w.position(2, 3);
+        ResultFormatter.door_event(
+          decodeResult,
+          DOORS[w.use(4)],
+          w.use(5) === "O" ? "open" : "closed"
+        );
+        const md = fields[6];
+        if (/^(?:0[1-9]|1[0-2])(?:0[1-9]|[12]\d|3[01])$/.test(md)) {
+          w.use(6);
+          ResultFormatter.month(decodeResult, Number(md.substring(0, 2)));
+          ResultFormatter.day(decodeResult, Number(md.substring(2)));
+        } else if (!/^\d+$/.test(md)) {
+          w.use(6);
+        }
+        w.time(7, (r, t) => ResultFormatter.timestamp(r, t));
+        break;
+      }
+      case "FCM01": {
+        const names = {
+          L: "Left Engine",
+          R: "Right Engine",
+          A: "APU"
+        };
+        for (let i = 0; i < 3; i++) {
+          const v = fields[i];
+          if (v[1] === "0" || v[1] === "1") {
+            w.item(
+              i,
+              `${names[v[0]].toLowerCase().replace(" ", "_")}`,
+              v[0],
+              names[v[0]],
+              v[1] === "1" ? "running" : "off"
+            );
+          }
+        }
+        ResultFormatter.currentFuel(decodeResult, Number(w.use(4)) * 100);
+        w.time(5, (r, t) => ResultFormatter.timestamp(r, t));
+        break;
+      }
+      case "VXR02":
+        w.item(0, "station_iata", "STN", "Station", fields[0]);
+        break;
+    }
+    return w.finish();
+  }
+  /** MXR03: destination, ETA, code, then the category and text; returns how many header
+   * fields went to `remaining`. */
+  writeMaintenance(decodeResult, text, fields) {
+    const w = new SwaFieldWriter(decodeResult, fields.slice(0, 3));
+    w.arrival(0);
+    w.eta(1);
+    w.item(
+      2,
+      "maintenance_code",
+      "MXCODE",
+      "Report Code",
+      `${fields[2]} (${MXR_CODES[fields[2]]})`
+    );
+    const header = text.match(/^[^,|]*[,|][^,|]*[,|][^,|]*[,|]?/);
+    const body = text.substring(header ? header[0].length : 0);
+    if (body.trim() !== "") {
+      ResultFormatter.text(decodeResult, body.split("|").join("\n"));
+    }
+    return w.finish();
+  }
+};
+
+// lib/plugins/Label_40_SWA.ts
+var DESCRIPTIONS2 = {
+  ASR01: "Approach Stability Report",
+  DVP01: "Divert Plan",
+  FTX01: "Dispatch Free Text",
+  GAR03: "Gate Assignment Response",
+  GEN01: "Company Message",
+  PIC01: "Part 117 Duty Extension Request",
+  POS01: "Position Report Request",
+  WFC01: "Field Condition Report"
+};
+var ASR01 = [
+  [
+    "reverser_distance",
+    "REVDIST",
+    "Threshold to Thrust Reverser Deployment (feet)"
+  ],
+  ["max_ias", "MAXIAS", "Highest IAS, 1000 feet to Touchdown (knots)"],
+  ["min_ias", "MINIAS", "Lowest IAS, to Touchdown (knots)"],
+  ["touchdown_distance", "TDDIST", "Threshold to Touchdown (feet)"],
+  ["glideslope_above", "GSHIGH", "Largest Deviation Above Glideslope (dots)"],
+  ["glideslope_below", "GSLOW", "Largest Deviation Below Glideslope (dots)"],
+  ["max_pitch", "MAXPITCH", "Highest Pitch, Flare and Landing (degrees)"],
+  ["tailstrike_pitch", "TSPITCH", "Tail Strike Pitch Limit (degrees)"]
+];
+var Label_40_SWA = class extends DecoderPlugin {
+  name = "label-40-swa";
+  qualifiers() {
+    return {
+      labels: ["40"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.defaultResult();
+    decodeResult.decoder.name = this.name;
+    decodeResult.message = message;
+    const d = decodeSwaLabel40(message.text);
+    if (!d || !isSwaType(d.type, "40")) {
+      if (options.debug) {
+        console.log(`Decoder: Unknown 40 message: ${message.text}`);
+      }
+      ResultFormatter.unknown(decodeResult, message.text);
+      decodeResult.formatted.description = "Unknown";
+      return decodeResult;
+    }
+    decodeResult.decoded = true;
+    decodeResult.formatted.description = DESCRIPTIONS2[d.type] ?? "Southwest Message";
+    decodeResult.raw.preamble = d.type;
+    if (d.type === "POS01") {
+      const m = d.text.match(/^POS01,Y,(\d{2})$/);
+      if (m) {
+        ResultFormatter.raw(
+          decodeResult,
+          "report_interval",
+          "RPTINT",
+          "Position Report Interval",
+          `${Number(m[1])} minutes`,
+          Number(m[1])
+        );
+        decodeResult.decoder.decodeLevel = "full";
+      } else {
+        ResultFormatter.unknown(decodeResult, d.text);
+        decodeResult.decoder.decodeLevel = "partial";
+      }
+      return decodeResult;
+    }
+    const text = d.text;
+    const fields = swaFields(text);
+    const layouts = SWA_LAYOUTS[d.type];
+    const clean = !text.includes(SWA_UNREAD);
+    if (clean && layouts && swaMatchesLayout(fields, layouts)) {
+      const w = new SwaFieldWriter(decodeResult, fields);
+      if (d.type === "ASR01") {
+        ASR01.forEach(([key, code, label], i) => {
+          const v = fields[i].trim();
+          if (v !== "XX.X") w.item(i, key, code, label, v);
+          else w.use(i);
+        });
+      } else if (d.type === "GAR03") {
+        ResultFormatter.arrivalGate(decodeResult, w.use(0).trim());
+        if (fields[6] !== "999.999") {
+          w.item(
+            6,
+            "ramp_frequency",
+            "RAMPFREQ",
+            "Ramp Frequency",
+            `${fields[6]} MHz`
+          );
+        } else {
+          w.use(6);
+        }
+      }
+      const rest = w.finish();
+      decodeResult.decoder.decodeLevel = rest === 0 ? "full" : "partial";
+      return decodeResult;
+    }
+    ResultFormatter.text(decodeResult, text.split("|").join("\n"));
+    decodeResult.decoder.decodeLevel = clean && !layouts ? "full" : "partial";
+    return decodeResult;
+  }
+};
+
 // lib/plugins/Label_44_ETA.ts
 var Label_44_ETA = class extends DecoderPlugin {
   name = "label-44-eta";
@@ -4733,7 +6180,7 @@ var Label_H1_76401 = class extends DecoderPlugin {
       );
       if (position) {
         waypoints.push({
-          name: CoordinateUtils.coordinateString(position),
+          name: line.substring(0, 13),
           latitude: position.latitude,
           longitude: position.longitude,
           time: DateTimeUtils.convertHHMMSSToTod(line.substring(13, 19))
@@ -4980,11 +6427,11 @@ var Label_H1_M_POS = class extends DecoderPlugin {
     const timestamp = fields[2].trim();
     if (timestamp.length === 6) {
       const day = Number(timestamp.substring(0, 2));
-      const tod = DateTimeUtils.convertHHMMSSToTod(
+      const tod2 = DateTimeUtils.convertHHMMSSToTod(
         timestamp.substring(2) + "00"
       );
       ResultFormatter.day(decodeResult, day);
-      ResultFormatter.timestamp(decodeResult, tod);
+      ResultFormatter.timestamp(decodeResult, tod2);
     }
     const lat = parseFloat(fields[3].replace(/\s/g, ""));
     const lon = parseFloat(fields[4].replace(/\s/g, ""));
@@ -5378,6 +6825,135 @@ var Label_H1_StarPOS = class extends DecoderPlugin {
   }
 };
 
+// lib/plugins/Label_H1_SWA_Track.ts
+var PHASES = {
+  TO: "Takeoff",
+  IC: "Initial Climb",
+  CL: "Climb",
+  CR: "Cruise",
+  ER: "En Route",
+  DC: "Descent",
+  AP: "Approach",
+  RO: "Rollout"
+};
+var POINT = /^([NS]\d{4})\.(\d),([EW]\d{5})\.(\d),(\d{2})(\d{2})(\d{2}),\s?(-?\d+),\s?(-?\d+\.\d),(\d{3}),(\d{3}),([A-Z]{2}),(\d{5}),([01]),$/;
+var Label_H1_SWA_Track = class extends DecoderPlugin {
+  name = "label-h1-swa-track";
+  qualifiers() {
+    return {
+      labels: ["H1"],
+      preambles: ["++76502,", "++86501,", "#DFB++76502,", "#DFB++86501,"]
+    };
+  }
+  decode(message, options = {}) {
+    const decodeResult = this.initResult(message, "Track Report");
+    const nl = message.text.includes("\r\n") ? "\r\n" : "\n";
+    const lines = message.text.replace(/#DFB/g, "").split(/\r?\n/);
+    const header = lines[0].replace(/^\+\+/, "").split(",");
+    if (header.length !== 9 || !/^\d{6}$/.test(header[3])) {
+      return this.failUnknown(decodeResult, message.text, options);
+    }
+    const unknown = [];
+    if (/^N\w+$/.test(header[1])) {
+      ResultFormatter.tail(decodeResult, header[1]);
+    } else if (/^\d{1,4}$/.test(header[1])) {
+      ResultFormatter.raw(
+        decodeResult,
+        "ship_number",
+        "SHIP",
+        "Ship Number",
+        header[1]
+      );
+    } else if (header[1] !== "XXX") {
+      unknown.push(header[1]);
+    }
+    ResultFormatter.raw(
+      decodeResult,
+      "aircraft_type",
+      "ACTYPE",
+      "Aircraft Type",
+      header[2]
+    );
+    const d = header[3];
+    ResultFormatter.raw(
+      decodeResult,
+      "report_date",
+      "DATE",
+      "Report Date",
+      `20${d.slice(0, 2)}-${d.slice(2, 4)}-${d.slice(4, 6)}`
+    );
+    ResultFormatter.flightNumber(decodeResult, header[4]);
+    ResultFormatter.departureAirport(decodeResult, header[5]);
+    ResultFormatter.arrivalAirport(decodeResult, header[6]);
+    if (/^\d{1,15}$/.test(header[7])) {
+      ResultFormatter.raw(
+        decodeResult,
+        "leg_counter",
+        "LEGS",
+        "Leg Counter",
+        `${Number(header[7])}`,
+        Number(header[7])
+      );
+    } else {
+      unknown.push(header[7]);
+    }
+    ResultFormatter.raw(
+      decodeResult,
+      "software_version",
+      "SWVER",
+      "Software Version",
+      header[8]
+    );
+    if (unknown.length > 0) ResultFormatter.unknownArr(decodeResult, unknown);
+    const count = lines[1]?.match(/^(\d+),?$/)?.[1];
+    if (lines[1] !== void 0 && count === void 0) {
+      ResultFormatter.unknown(decodeResult, lines[1], nl);
+    }
+    for (const line of lines.slice(2)) {
+      if (line === "" || line === ":") continue;
+      const m = line.match(POINT);
+      if (!m || !(Number(m[5]) >= 1 && Number(m[5]) <= 31) || Number(m[6]) > 23 || Number(m[7]) > 59 || Number(m[10]) > 360 || Number(m[1].slice(3)) > 59 || Number(m[3].slice(4)) > 59) {
+        ResultFormatter.unknown(decodeResult, line, nl);
+        continue;
+      }
+      const position = CoordinateUtils.decodeStringCoordinatesDecimalMinutes(
+        `${m[1]}${m[2]}${m[3]}${m[4]}`
+      );
+      if (!position || Math.abs(position.latitude) > 90 || Math.abs(position.longitude) > 180) {
+        ResultFormatter.unknown(decodeResult, line, nl);
+        continue;
+      }
+      ResultFormatter.trackPoint(decodeResult, {
+        name: `${m[1]}.${m[2]}${m[3]}.${m[4]}`,
+        ...position,
+        day: Number(m[5]),
+        time: Number(m[6]) * 3600 + Number(m[7]) * 60,
+        altitude: Number(m[8]),
+        // -00.0 is sent; keep it as 0
+        temperature: Number(m[9]) || 0,
+        windDirection: Number(m[10]),
+        windSpeed: Number(m[11]),
+        phase: PHASES[m[12]] ?? m[12],
+        humiditySensor: m[14] === "1",
+        ...m[14] === "1" && Number(m[13]) > 0 ? { waterVapor: Number(m[13]) } : {}
+      });
+    }
+    const points = decodeResult.raw.route?.waypoints ?? [];
+    const last = points[points.length - 1];
+    if (last) {
+      ResultFormatter.position(decodeResult, {
+        latitude: last.latitude,
+        longitude: last.longitude
+      });
+      ResultFormatter.altitude(decodeResult, last.altitude);
+      ResultFormatter.timestamp(decodeResult, last.time);
+    }
+    const counted = count !== void 0 && Number(count) === points.length;
+    this.setDecodeLevel(decodeResult, true, counted ? void 0 : "partial");
+    return decodeResult;
+  }
+};
+
 // lib/plugins/Label_H1_WRN.ts
 var Label_H1_WRN = class extends DecoderPlugin {
   name = "label-h1-wrn";
@@ -5476,7 +7052,7 @@ var Label_H2_02E = class extends DecoderPlugin {
     if (text.length !== 32 || !pos) {
       return null;
     }
-    const tod = DateTimeUtils.convertHHMMSSToTod(text.substring(13, 17));
+    const tod2 = DateTimeUtils.convertHHMMSSToTod(text.substring(13, 17));
     const flightLevel = parseInt(text.substring(17, 20), 10);
     const tempSign = text[21] === "M" ? -1 : 1;
     const tempDegreesRaw = parseInt(text.substring(22, 25), 10);
@@ -5491,7 +7067,7 @@ var Label_H2_02E = class extends DecoderPlugin {
         name: posString,
         latitude: pos.latitude,
         longitude: pos.longitude,
-        time: tod
+        time: tod2
       },
       flightLevel,
       windDirection,
@@ -6799,8 +8375,11 @@ var pluginClasses = [
   Label_ColonComma,
   Label_5Z_Slash,
   Label_10_LDR,
+  Label_10_LRW,
   Label_10_POS,
   Label_10_Slash,
+  Label_11_LDR,
+  Label_11_LRW,
   Label_12_N_Space,
   Label_12_POS,
   Label_13Through18_Slash,
@@ -6824,6 +8403,8 @@ var pluginClasses = [
   Label_2P_FM4,
   Label_2P_FM5,
   Label_30_Slash_EA,
+  Label_37_SWA,
+  Label_40_SWA,
   Label_44_ETA,
   Label_44_IN,
   Label_44_OFF,
@@ -6849,6 +8430,7 @@ var pluginClasses = [
   Label_H1_Paren,
   Label_H1_WRN,
   Label_H1_StarPOS,
+  Label_H1_SWA_Track,
   Label_H2_02E,
   Label_HX,
   Label_58,