metar-taf-parser 1.3.1 → 3.1.0

package/README.md

@@ -1,9 +1,21 @@
 # ✈️ [metar-taf-parser](https://aeharding.github.io/metar-taf-parser)
 
-Parser for METeorological Aerodrome Reports (METARs) and Terminal Aerodrome Forecasts (TAFs). This is a port of [python-metar-taf-parser](https://github.com/mivek/python-metar-taf-parser) to Typescript. It's dependency-free, fully typed, tested, has i18n support, and can run on Node or in the browser.
+Parser for METeorological Aerodrome Reports (METARs) and Terminal Aerodrome Forecasts (TAFs). This is a port of [python-metar-taf-parser](https://github.com/mivek/python-metar-taf-parser) to Typescript with some additional features.
 
 [Check out the demo here](https://aeharding.github.io/metar-taf-parser)
 
+Features:
+
+- ✈️ Complete METAR and TAF parsing
+- 🛠 Fully typed
+- 🪶 Dependency free
+- 🧪 Full test suite
+- ✅ Runs anywhere: Web browser or Node
+- 🌎 i18n: Translations
+- 🌏 i18n: Handling international TAF & METAR report format differences
+- 🌪 Remark parsing to human and machine readable formats
+- 🗓 [`Forecast` abstraction](https://aeharding.github.io/metar-taf-parser/forecast) to easily query TAF reports by `Date`
+
 ## Installation
 
 ```sh
@@ -14,31 +26,131 @@ npm i --save metar-taf-parser
 
 ## Usage
 
-### Parse a METAR
+### Parsing
+
+The `parseMetar` & `parseTAF` functions are designed to parse the raw report string into an object representation of a METAR/TAF.
+
+#### `parseMetar`
 
 ```ts
-import { parseMetar } from 'metar-taf-parser'
+import { parseMetar } from "metar-taf-parser";
+
+const metar = parseMetar(rawMetarString);
 
-const metar = parseMetar(rawMetarString)
+// -or-
+
+// Optionally pass a date (approximately when the report was issued, +/- a week)
+// to get the issued date on the report:
+const datedMetar = parseMetar(rawMetarString, { date: new Date() });
 ```
 
-### Parse a TAF
+#### `parseTAF`
+
+👉 **Note:** One of the common use cases for TAF reports is to get relevant forecast data for a given date. Check out [the `Forecast` abstraction](#higher-level-parsing-the-forecast-abstraction) below which may provide TAF data in a more normalized format, depending on your use case.
 
 ```ts
-import { parseTAF } from 'metar-taf-parser'
+import { parseTAF } from "metar-taf-parser";
+
+const taf = parseTAF(rawTAFString);
+
+// -or-
+
+// Optionally pass a date (approximately when the report was issued, +/- a week)
+// to get the report issued and trend validity dates (start/end) on the report:
+const datedTAF = parseTAF(rawTAFString, { date: new Date() });
+```
+
+### Higher level parsing: The Forecast abstraction
+
+TAF reports are a little funky... FM, BECMG, PROB, etc. You may find the `Forecast` abstraction more helpful.
+
+#### `parseTAFAsForecast`
+
+Returns a more normalized TAF report. Most notably: while the `parseTAF` function returns initial weather conditions on the base of the returned result (and further conditions on `trends[]`), the `parseTAFAsForecast` function returns the initial weather conditions as the first element of the `forecast[]` property, followed by subsequent trends. This makes it much easier to iterate though.
+
+```ts
+import { parseTAFAsForecast } from "metar-taf-parser";
+
+// You must provide an issued date to use the Forecast abstraction
+const report = parseTAFAsForecast(rawTAFString, { date: tafIssuedDate });
+
+console.log(report.forecast);
+```
+
+#### `getCompositeForecastForDate`
+
+> ⚠️ **Warning:** Experimental API
+
+Provides all relevant weather conditions for a given timestamp. It returns a `ICompositeForecast` with a `base` and `additional` component. The `base` component is the base weather condition period (the FM part of the report) - and there will always be one.
+
+The `additional` property is an array of weather condition periods valid for the given timestamp (any `BECMG`, `PROB`, `TEMPO`, etc.)
 
-const taf = parseTAF(rawTAFString)
+You will still need to write some logic to use this API to determine what data to use - for example, if `additional[0].visibility` exists, use it over `base.visibility`.
+
+#### Example
+
+This example provides an array of hourly weather conditions over the duration of the TAF report.
+
+```ts
+import { eachHourOfInterval } from "date-fns";
+import {
+  parseTAFAsForecast,
+  getCompositeForecastForDate,
+} from "metar-taf-parser";
+
+const report = parseTAFAsForecast(rawTAFString, { date: tafIssuedDate });
+
+const forecastPerHour = eachHourOfInterval({
+  start: report.start,
+  end: report.end,
+}).map((hour) => ({
+  hour,
+  ...getCompositeForecastForDate(hour, report),
+}));
 ```
 
 ## i18n
 
+The `description` property in the `Remark` is translated, if available.
+
 ```ts
-import { parseMetar } from 'metar-taf-parser'
-import de from 'metar-taf-parser/dist/locale/de'
+import { parseMetar } from "metar-taf-parser";
+import de from "metar-taf-parser/dist/locale/de";
 
-const { metar } = await myService.getAirportData('KMSN')
+const rawMetarReport = "KTTN 051853Z 04011KT RMK SLP176";
 
-const metarResult = parseMetar(metar, { locale: de })
+const metarResult = parseMetar(rawMetarReport, {
+  locale: de,
+});
+
+console.log(metarReport.remarks[0].description);
+```
+
+## Handling remarks
+
+Remarks may be found on base TAF and METARs, along with TAF trends.
+
+Each Remark will have a `description` (if translated), `type` and `raw` properties. There are additional properties for each unique remark, depending on the remark's `type`. We can type guard on `type` to access these unique properties.
+
+If the remark is not understood, it will have `type` as `RemarkType.Unknown`, with `raw` containing everything until the next understood remark.
+
+### Example
+
+```ts
+import { Remark, RemarkType } from "metar-taf-parser";
+
+/**
+ * Find the sea level pressure given remarks, if defined
+ */
+function findSeaLevelPressure(remarks: Remark[]): number | undefined {
+  for (const remark of remarks) {
+    switch (remark.type) {
+      case RemarkType.SeaLevelPressure:
+        // can now access remark.pressure
+        return remark.pressure;
+    }
+  }
+}
 ```
 
 ## Development
@@ -49,8 +161,8 @@ Please see [the example site README.md](example/README.md).
 
 ## Contributing
 
-This project is intended to provide feature parity with [python-metar-taf-parser](https://github.com/mivek/python-metar-taf-parser) and will only accept PRs to maintain feature parity or to fix inconsistencies with that project.
+This project is based on [python-metar-taf-parser](https://github.com/mivek/python-metar-taf-parser) and the parsing should be as similar to that project as possible. That being said, PRs are welcome.
 
 ## Acknowledgment
 
-This software port was made possible due to the fantastic work of [@mivek](https://github.com/mivek) in [python-metar-taf-parser](https://github.com/mivek/python-metar-taf-parser). If you like this project, please [consider buying @mivek a coffee](https://ko-fi.com/mivek).
+This software port was made possible due to the fantastic work of [@mivek](https://github.com/mivek) in [python-metar-taf-parser](https://github.com/mivek/python-metar-taf-parser). If you like this project, please [consider buying @mivek a coffee](https://ko-fi.com/mivek).

package/dist/command/common.js

@@ -92,8 +92,10 @@ class MainVisibilityCommand {
             return false;
         const distance = converter.convertVisibility(matches[1]);
         if (!container.visibility)
-            container.visibility = { distance };
-        container.visibility.distance = distance;
+            container.visibility = distance;
+        container.visibility = Object.assign(Object.assign({}, container.visibility), distance);
+        if (matches[2] === "NDV")
+            container.visibility.ndv = true;
         return true;
     }
 }
@@ -136,7 +138,7 @@ class WindVariationCommand {
     }
     execute(container, windString) {
         if (!container.wind)
-            throw new errors_1.InvalidWeatherStatementError();
+            throw new errors_1.UnexpectedParseError();
         this.parseWindVariation(container.wind, windString);
         return true;
     }
@@ -182,7 +184,7 @@ exports.VerticalVisibilityCommand = VerticalVisibilityCommand;
 _VerticalVisibilityCommand_regex = new WeakMap();
 class MinimalVisibilityCommand {
     constructor() {
-        _MinimalVisibilityCommand_regex.set(this, /^(\d{4}[a-z])$/);
+        _MinimalVisibilityCommand_regex.set(this, /^(\d{4}[a-zA-Z]{1,2})$/);
     }
     execute(container, visibilityString) {
         const matches = visibilityString.match(__classPrivateFieldGet(this, _MinimalVisibilityCommand_regex, "f"));
@@ -190,8 +192,10 @@ class MinimalVisibilityCommand {
             throw new errors_1.UnexpectedParseError("Vertical visibility should be defined");
         if (!container.visibility)
             throw new errors_1.UnexpectedParseError("container.visibility not instantiated");
-        container.visibility.minDistance = +matches[1].slice(0, 4);
-        container.visibility.minDirection = matches[1][4];
+        container.visibility.min = {
+            value: +matches[1].slice(0, 4),
+            direction: matches[1].slice(4),
+        };
         return true;
     }
     canParse(windString) {
@@ -202,12 +206,11 @@ exports.MinimalVisibilityCommand = MinimalVisibilityCommand;
 _MinimalVisibilityCommand_regex = new WeakMap();
 class MainVisibilityNauticalMilesCommand {
     constructor() {
-        _MainVisibilityNauticalMilesCommand_regex.set(this, /^(\d)*(\s)?((\d\/\d)?SM)$/);
+        _MainVisibilityNauticalMilesCommand_regex.set(this, /^(P|M)?(\d)*(\s)?((\d\/\d)?SM)$/);
     }
     execute(container, visibilityString) {
-        if (!container.visibility)
-            container.visibility = { distance: visibilityString };
-        container.visibility.distance = visibilityString;
+        const distance = converter.convertNauticalMilesVisibility(visibilityString);
+        container.visibility = distance;
         return true;
     }
     canParse(windString) {
@@ -230,8 +233,7 @@ class CommandSupplier {
         ]);
     }
     get(input) {
-        for (let i = 0; i < __classPrivateFieldGet(this, _CommandSupplier_commands, "f").length; i++) {
-            const command = __classPrivateFieldGet(this, _CommandSupplier_commands, "f")[i];
+        for (const command of __classPrivateFieldGet(this, _CommandSupplier_commands, "f")) {
             if (command.canParse(input))
                 return command;
         }

package/dist/command/metar/AltimeterCommand.d.ts

@@ -0,0 +1,7 @@
+import { IMetar } from "../../model/model";
+import { ICommand } from "../metar";
+export declare class AltimeterCommand implements ICommand {
+    #private;
+    canParse(input: string): boolean;
+    execute(metar: IMetar, input: string): void;
+}

package/dist/command/metar/AltimeterCommand.js

@@ -0,0 +1,26 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AltimeterCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltimeterCommand = void 0;
+const errors_1 = require("../../commons/errors");
+class AltimeterCommand {
+    constructor() {
+        _AltimeterCommand_regex.set(this, /^Q(\d{4})$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _AltimeterCommand_regex, "f").test(input);
+    }
+    execute(metar, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _AltimeterCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Match not found");
+        metar.altimeter = Math.trunc(+matches[1]);
+    }
+}
+exports.AltimeterCommand = AltimeterCommand;
+_AltimeterCommand_regex = new WeakMap();

package/dist/command/metar/AltimeterMercuryCommand.d.ts

@@ -0,0 +1,7 @@
+import { IMetar } from "../../model/model";
+import { ICommand } from "../metar";
+export declare class AltimeterMercuryCommand implements ICommand {
+    #private;
+    canParse(input: string): boolean;
+    execute(metar: IMetar, input: string): void;
+}

package/dist/command/metar/AltimeterMercuryCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AltimeterMercuryCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AltimeterMercuryCommand = void 0;
+const converter = __importStar(require("../../commons/converter"));
+const errors_1 = require("../../commons/errors");
+class AltimeterMercuryCommand {
+    constructor() {
+        _AltimeterMercuryCommand_regex.set(this, /^A(\d{4})$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _AltimeterMercuryCommand_regex, "f").test(input);
+    }
+    execute(metar, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _AltimeterMercuryCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Match not found");
+        const mercury = +matches[1] / 100;
+        metar.altimeter = Math.trunc(converter.convertInchesMercuryToPascal(mercury));
+    }
+}
+exports.AltimeterMercuryCommand = AltimeterMercuryCommand;
+_AltimeterMercuryCommand_regex = new WeakMap();

package/dist/command/metar/RunwayCommand.d.ts

@@ -0,0 +1,7 @@
+import { IMetar } from "../../model/model";
+import { ICommand } from "../metar";
+export declare class RunwayCommand implements ICommand {
+    #private;
+    canParse(input: string): boolean;
+    execute(metar: IMetar, input: string): void;
+}

package/dist/command/metar/RunwayCommand.js

@@ -0,0 +1,60 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RunwayCommand_genericRegex, _RunwayCommand_runwayMaxRangeRegex, _RunwayCommand_runwayRegex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunwayCommand = void 0;
+const errors_1 = require("../../commons/errors");
+const helpers_1 = require("../../helpers/helpers");
+const enum_1 = require("../../model/enum");
+class RunwayCommand {
+    constructor() {
+        _RunwayCommand_genericRegex.set(this, /^(R\d{2}\w?\/)/);
+        _RunwayCommand_runwayMaxRangeRegex.set(this, /^R(\d{2}\w?)\/(\d{4})V(\d{3,4})([UDN])?(FT)?/);
+        _RunwayCommand_runwayRegex.set(this, /^R(\d{2}\w?)\/([MP])?(\d{4})([UDN])?(FT)?$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _RunwayCommand_genericRegex, "f").test(input);
+    }
+    execute(metar, input) {
+        // TODO idk if this matches super well...
+        if (__classPrivateFieldGet(this, _RunwayCommand_runwayRegex, "f").test(input)) {
+            const matches = input.match(__classPrivateFieldGet(this, _RunwayCommand_runwayRegex, "f"));
+            if (!matches)
+                throw new errors_1.UnexpectedParseError("Should be able to parse");
+            const indicator = matches[2] ? (0, helpers_1.as)(matches[2], enum_1.ValueIndicator) : undefined;
+            const trend = matches[4] ? (0, helpers_1.as)(matches[4], enum_1.RunwayInfoTrend) : undefined;
+            const unit = matches[5]
+                ? (0, helpers_1.as)(matches[5], enum_1.RunwayInfoUnit)
+                : enum_1.RunwayInfoUnit.Meters;
+            metar.runwaysInfo.push({
+                name: matches[1],
+                indicator,
+                minRange: +matches[3],
+                trend,
+                unit,
+            });
+        }
+        else if (__classPrivateFieldGet(this, _RunwayCommand_runwayMaxRangeRegex, "f").test(input)) {
+            const matches = input.match(__classPrivateFieldGet(this, _RunwayCommand_runwayMaxRangeRegex, "f"));
+            if (!matches)
+                throw new errors_1.UnexpectedParseError("Should be able to parse");
+            const trend = matches[4] ? (0, helpers_1.as)(matches[4], enum_1.RunwayInfoTrend) : undefined;
+            const unit = matches[5]
+                ? (0, helpers_1.as)(matches[5], enum_1.RunwayInfoUnit)
+                : enum_1.RunwayInfoUnit.Meters;
+            metar.runwaysInfo.push({
+                name: matches[1],
+                minRange: +matches[2],
+                maxRange: +matches[3],
+                trend,
+                unit,
+            });
+        }
+    }
+}
+exports.RunwayCommand = RunwayCommand;
+_RunwayCommand_genericRegex = new WeakMap(), _RunwayCommand_runwayMaxRangeRegex = new WeakMap(), _RunwayCommand_runwayRegex = new WeakMap();

package/dist/command/metar/TemperatureCommand.d.ts

@@ -0,0 +1,7 @@
+import { IMetar } from "../../model/model";
+import { ICommand } from "../metar";
+export declare class TemperatureCommand implements ICommand {
+    #private;
+    canParse(input: string): boolean;
+    execute(metar: IMetar, input: string): void;
+}

package/dist/command/metar/TemperatureCommand.js

@@ -0,0 +1,51 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TemperatureCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemperatureCommand = void 0;
+const converter = __importStar(require("../../commons/converter"));
+const errors_1 = require("../../commons/errors");
+class TemperatureCommand {
+    constructor() {
+        _TemperatureCommand_regex.set(this, /^(M?\d{2})\/(M?\d{2})$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _TemperatureCommand_regex, "f").test(input);
+    }
+    execute(metar, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _TemperatureCommand_regex, "f"));
+        if (!matches)
+            throw new errors_1.UnexpectedParseError("Match not found");
+        metar.temperature = converter.convertTemperature(matches[1]);
+        metar.dewPoint = converter.convertTemperature(matches[2]);
+    }
+}
+exports.TemperatureCommand = TemperatureCommand;
+_TemperatureCommand_regex = new WeakMap();

package/dist/command/metar.d.ts

@@ -1,30 +1,9 @@
 import { IMetar } from "../model/model";
-interface ICommand {
+export interface ICommand {
     canParse(str: string): boolean;
     execute(metar: IMetar, str: string): void;
 }
-export declare class AltimeterCommand implements ICommand {
-    #private;
-    canParse(input: string): boolean;
-    execute(metar: IMetar, input: string): void;
-}
-export declare class AltimeterMercuryCommand implements ICommand {
-    #private;
-    canParse(input: string): boolean;
-    execute(metar: IMetar, input: string): void;
-}
-export declare class RunwayCommand implements ICommand {
-    #private;
-    canParse(input: string): boolean;
-    execute(metar: IMetar, input: string): void;
-}
-export declare class TemperatureCommand implements ICommand {
-    #private;
-    canParse(input: string): boolean;
-    execute(metar: IMetar, input: string): void;
-}
 export declare class CommandSupplier {
     #private;
     get(input: string): ICommand | undefined;
 }
-export {};

package/dist/command/metar.js

@@ -1,131 +1,27 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AltimeterCommand_regex, _AltimeterMercuryCommand_regex, _RunwayCommand_genericRegex, _RunwayCommand_runwayMaxRangeRegex, _RunwayCommand_runwayRegex, _TemperatureCommand_regex, _CommandSupplier_commands;
+var _CommandSupplier_commands;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandSupplier = exports.TemperatureCommand = exports.RunwayCommand = exports.AltimeterMercuryCommand = exports.AltimeterCommand = void 0;
-const converter = __importStar(require("../commons/converter"));
-const errors_1 = require("../commons/errors");
-class AltimeterCommand {
-    constructor() {
-        _AltimeterCommand_regex.set(this, /^Q(\d{4})$/);
-    }
-    canParse(input) {
-        return __classPrivateFieldGet(this, _AltimeterCommand_regex, "f").test(input);
-    }
-    execute(metar, input) {
-        const matches = input.match(__classPrivateFieldGet(this, _AltimeterCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        metar.altimeter = Math.trunc(+matches[1]);
-    }
-}
-exports.AltimeterCommand = AltimeterCommand;
-_AltimeterCommand_regex = new WeakMap();
-class AltimeterMercuryCommand {
-    constructor() {
-        _AltimeterMercuryCommand_regex.set(this, /^A(\d{4})$/);
-    }
-    canParse(input) {
-        return __classPrivateFieldGet(this, _AltimeterMercuryCommand_regex, "f").test(input);
-    }
-    execute(metar, input) {
-        const matches = input.match(__classPrivateFieldGet(this, _AltimeterMercuryCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        const mercury = +matches[1] / 100;
-        metar.altimeter = Math.trunc(converter.convertInchesMercuryToPascal(mercury));
-    }
-}
-exports.AltimeterMercuryCommand = AltimeterMercuryCommand;
-_AltimeterMercuryCommand_regex = new WeakMap();
-class RunwayCommand {
-    constructor() {
-        _RunwayCommand_genericRegex.set(this, /^(R\d{2}\w?\/)/);
-        _RunwayCommand_runwayMaxRangeRegex.set(this, /^R(\d{2}\w?)\/(\d{4})V(\d{3})(\w{0,2})/);
-        _RunwayCommand_runwayRegex.set(this, /^R(\d{2}\w?)\/(\w)?(\d{4})(\w{0,2})$/);
-    }
-    canParse(input) {
-        return __classPrivateFieldGet(this, _RunwayCommand_genericRegex, "f").test(input);
-    }
-    execute(metar, input) {
-        const matches = input.match(__classPrivateFieldGet(this, _RunwayCommand_runwayRegex, "f"));
-        // TODO idk if this matches super well...
-        if (matches) {
-            metar.runwaysInfo.push({
-                name: matches[1],
-                minRange: +matches[3],
-                trend: matches[4],
-            });
-        }
-        const maxRangeMatches = input.match(__classPrivateFieldGet(this, _RunwayCommand_runwayMaxRangeRegex, "f"));
-        if (maxRangeMatches) {
-            metar.runwaysInfo.push({
-                name: maxRangeMatches[1],
-                minRange: +maxRangeMatches[2],
-                maxRange: +maxRangeMatches[3],
-                trend: maxRangeMatches[4],
-            });
-        }
-    }
-}
-exports.RunwayCommand = RunwayCommand;
-_RunwayCommand_genericRegex = new WeakMap(), _RunwayCommand_runwayMaxRangeRegex = new WeakMap(), _RunwayCommand_runwayRegex = new WeakMap();
-class TemperatureCommand {
-    constructor() {
-        _TemperatureCommand_regex.set(this, /^(M?\d{2})\/(M?\d{2})$/);
-    }
-    canParse(input) {
-        return __classPrivateFieldGet(this, _TemperatureCommand_regex, "f").test(input);
-    }
-    execute(metar, input) {
-        const matches = input.match(__classPrivateFieldGet(this, _TemperatureCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        metar.temperature = converter.convertTemperature(matches[1]);
-        metar.dewPoint = converter.convertTemperature(matches[2]);
-    }
-}
-exports.TemperatureCommand = TemperatureCommand;
-_TemperatureCommand_regex = new WeakMap();
+exports.CommandSupplier = void 0;
+const AltimeterCommand_1 = require("./metar/AltimeterCommand");
+const AltimeterMercuryCommand_1 = require("./metar/AltimeterMercuryCommand");
+const RunwayCommand_1 = require("./metar/RunwayCommand");
+const TemperatureCommand_1 = require("./metar/TemperatureCommand");
 class CommandSupplier {
     constructor() {
         _CommandSupplier_commands.set(this, [
-            new RunwayCommand(),
-            new TemperatureCommand(),
-            new AltimeterCommand(),
-            new AltimeterMercuryCommand(),
+            new RunwayCommand_1.RunwayCommand(),
+            new TemperatureCommand_1.TemperatureCommand(),
+            new AltimeterCommand_1.AltimeterCommand(),
+            new AltimeterMercuryCommand_1.AltimeterMercuryCommand(),
         ]);
     }
     get(input) {
-        for (let i = 0; i < __classPrivateFieldGet(this, _CommandSupplier_commands, "f").length; i++) {
-            const command = __classPrivateFieldGet(this, _CommandSupplier_commands, "f")[i];
+        for (const command of __classPrivateFieldGet(this, _CommandSupplier_commands, "f")) {
             if (command.canParse(input))
                 return command;
         }

package/dist/command/remark/CeilingHeightCommand.d.ts

@@ -0,0 +1,18 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface ICeilingHeightRemark extends IBaseRemark {
+    type: RemarkType.CeilingHeight;
+    /**
+     * Ceiling min height (varying between min and max) above ground level
+     */
+    min: number;
+    /**
+     * Ceiling max height (varying between min and max) above ground level
+     */
+    max: number;
+}
+export declare class CeilingHeightCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}