metar-taf-parser 7.0.0 → 7.1.1

package/README.md

@@ -175,6 +175,10 @@ function findSeaLevelPressure(remarks: Remark[]): number | undefined {
 }
 ```
 
+## Determining flight category, ceiling, etc
+
+Because certain abstractions such as flight category and flight ceiling can vary by country, this logic is left up to you to implement. However, if you're looking for somewhere to start, check out the example site (based on United States flight rules) in [example/src/helpers/metarTaf.ts](https://github.com/aeharding/metar-taf-parser/blob/main/example/src/helpers/metarTaf.ts). Feel free to copy - it's MIT licensed.
+
 ## Development
 
 ### Example site

package/metar-taf-parser.d.ts

@@ -275,6 +275,57 @@ declare enum RunwayInfoUnit {
     Feet = "FT",
     Meters = "m"
 }
+declare enum IcingIntensity {
+    /**
+     * Trace Icing or None.
+     *
+     * Air Force code 0 means a trace of icing.
+     * World Meteorological Organization code 0 means no icing
+     */
+    None = "0",
+    /** Light Mixed Icing. */
+    Light = "1",
+    /** Light Rime Icing In Cloud. */
+    LightRimeIcingCloud = "2",
+    /** Light Clear Icing In Precipitation. */
+    LightClearIcingPrecipitation = "3",
+    /** Moderate Mixed Icing. */
+    ModerateMixedIcing = "4",
+    /** Moderate Rime Icing In Cloud. */
+    ModerateRimeIcingCloud = "5",
+    /** Moderate Clear Icing In Precipitation. */
+    ModerateClearIcingPrecipitation = "6",
+    /** Severe Mixed Icing. */
+    SevereMixedIcing = "7",
+    /** Severe Rime Icing In Cloud. */
+    SevereRimeIcingCloud = "8",
+    /** Severe Clear Icing In Precipitation. */
+    SevereClearIcingPrecipitation = "9"
+}
+declare enum TurbulenceIntensity {
+    /** None. */
+    None = "0",
+    /** Light turbulence. */
+    Light = "1",
+    /** Moderate turbulence in clear air, occasional. */
+    ModerateClearAirOccasional = "2",
+    /** Moderate turbulence in clear air, frequent. */
+    ModerateClearAirFrequent = "3",
+    /** Moderate turbulence in cloud, occasional. */
+    ModerateCloudOccasional = "4",
+    /** Moderate turbulence in cloud, frequent. */
+    ModerateCloudFrequent = "5",
+    /** Severe turbulence in clear air, occasional. */
+    SevereClearAirOccasional = "6",
+    /** Severe turbulence in clear air, frequent. */
+    SevereClearAirFrequent = "7",
+    /** Severe turbulence in cloud, occasional. */
+    SevereCloudOccasional = "8",
+    /** Severe turbulence in cloud, frequent. */
+    SevereCloudFrequent = "9",
+    /** Extreme turbulence */
+    Extreme = "X"
+}
 
 declare const _default: {
     CloudQuantity: {
@@ -1042,22 +1093,6 @@ declare enum RemarkType {
 }
 declare type Remark = IUnknownRemark | IDefaultCommandRemark | ICeilingHeightRemark | ICeilingSecondLocationRemark | IHailSizeRemark | IHourlyMaximumMinimumTemperatureRemark | IHourlyMaximumTemperatureRemark | IHourlyMinimumTemperatureRemark | IHourlyPrecipitationAmountRemark | IHourlyPressureRemark | IHourlyTemperatureDewPointRemark | IIceAccretionRemark | IObscurationRemark | IPrecipitationAmount24HourRemark | IPrecipitationAmount36HourRemark | IPrecipitationAmount36HourRemark | IPrecipitationBegRemark | IPrecipitationBegEndRemark | IPrecipitationEndRemark | IPrevailingVisibilityRemark | ISeaLevelPressureRemark | ISecondLocationVisibilityRemark | ISectorVisibilityRemark | ISmallHailSizeRemark | ISnowDepthRemark | ISnowIncreaseRemark | ISnowPelletsRemark | ISunshineDurationRemark | ISurfaceVisibilityRemark | IThunderStormLocationRemark | IThunderStormLocationMovingRemark | ITornadicActivityBegRemark | ITornadicActivityBegEndRemark | ITornadicActivityEndRemark | ITowerVisibilityRemark | IVariableSkyRemark | IVariableSkyHeightRemark | IVirgaDirectionRemark | IWaterEquivalentSnowRemark | IWindPeakCommandRemark | IWindShiftRemark | IWindShiftFropaRemark;
 
-interface ICountry {
-    name: string;
-}
-interface IAirport {
-    name: string;
-    city: string;
-    country: string;
-    iata: string;
-    icao: string;
-    latitude: string;
-    longitude: string;
-    altitude: string;
-    timezone: string;
-    dst: boolean;
-    tzDatabase: unknown;
-}
 interface IWind {
     speed: number;
     direction: string;
@@ -1122,6 +1157,12 @@ interface ICloud {
     height?: number;
     quantity: CloudQuantity;
     type?: CloudType;
+    /**
+     * Very uncommon. For example "FEW025TCU/CB" seen at airport VOTR.
+     *
+     * This property can be ignored in almost all cases.
+     */
+    secondaryType?: CloudType;
 }
 interface IFlags {
     /**
@@ -1169,11 +1210,14 @@ interface ITime {
 }
 interface IAbstractWeatherCode extends IAbstractWeatherContainer, ITime {
     day?: number;
-    airport?: IAirport;
     message: string;
     station: string;
     trends: IAbstractTrend[];
 }
+interface ITafGroups {
+    turbulence?: ITurbulence[];
+    icing?: IIcing[];
+}
 interface IAbstractWeatherCodeDated extends IAbstractWeatherCode {
     issued: Date;
 }
@@ -1188,7 +1232,7 @@ interface IMetar extends IAbstractWeatherCode {
      */
     trends: IMetarTrend[];
 }
-interface ITAF extends IAbstractWeatherCode {
+interface ITAF extends IAbstractWeatherCode, ITafGroups {
     validity: IValidity;
     maxTemperature?: ITemperature;
     minTemperature?: ITemperature;
@@ -1208,7 +1252,7 @@ interface IMetarTrendTime extends ITime {
 interface IMetarTrend extends IAbstractTrend {
     times: IMetarTrendTime[];
 }
-interface IBaseTAFTrend extends IAbstractTrend {
+interface IBaseTAFTrend extends IAbstractTrend, ITafGroups {
     /**
      * Will not be found on FM trends. May exist on others.
      *
@@ -1260,6 +1304,36 @@ interface IValidityDated extends IAbstractValidity, IEndValidity {
 interface IFMValidity extends IAbstractValidity {
     startMinutes: number;
 }
+/**
+ * Represents icing in a TAF.
+ *
+ * http://prnfc.org/wp-content/uploads/2016/12/AF-METAR-TAF-Codes.pdf#page=28
+ *
+ * Top of icing = `baseHeight` + `depth`
+ */
+interface IIcing {
+    /** The intensity of the icing. */
+    intensity: IcingIntensity;
+    /** The base of the icing layer in feet. */
+    baseHeight: number;
+    /** The icing layer depth in feet. */
+    depth: number;
+}
+/**
+ * Represents turbulence in a TAF.
+ *
+ * http://prnfc.org/wp-content/uploads/2016/12/AF-METAR-TAF-Codes.pdf#page=29
+ *
+ * Top of icing = `baseHeight` + `depth`
+ */
+interface ITurbulence {
+    /** The intensity of the turbulence. */
+    intensity: TurbulenceIntensity;
+    /** The base limit of the turbulence layer in feet. */
+    baseHeight: number;
+    /** The turbulence layer depth in feet. */
+    depth: number;
+}
 
 interface IMetarDated extends IMetar {
     issued: Date;
@@ -1388,4 +1462,4 @@ declare function parseTAF(rawTAF: string, options?: IMetarTAFParserOptions): ITA
 declare function parseTAF(rawTAF: string, options?: IMetarTAFParserOptionsDated): ITAFDated;
 declare function parseTAFAsForecast(rawTAF: string, options: IMetarTAFParserOptionsDated): IForecastContainer;
 
-export { CloudQuantity, CloudType, CommandExecutionError, Descriptive, Direction, Distance, DistanceUnit, Forecast, IAbstractTrend, IAbstractValidity, IAbstractWeatherCode, IAbstractWeatherCodeDated, IAbstractWeatherContainer, IAirport, IBaseRemark, IBaseTAFTrend, ICeilingHeightRemark, ICeilingSecondLocationRemark, ICloud, ICompositeForecast, ICountry, IEndValidity, IFMValidity, IFlags, IForecastContainer, IHourlyMaximumMinimumTemperatureRemark, IHourlyMaximumTemperatureRemark, IHourlyMinimumTemperatureRemark, IHourlyPrecipitationAmountRemark, IHourlyPressureRemark, IHourlyTemperatureDewPointRemark, IIceAccretionRemark, IMetar, IMetarTAFParserOptions, IMetarTAFParserOptionsDated, IMetarTrend, IMetarTrendTime, IObscurationRemark, IPrecipitationAmount24HourRemark, IPrecipitationAmount36HourRemark, IPrecipitationBegEndRemark, IPrevailingVisibilityRemark, IRunwayInfo, ISeaLevelPressureRemark, ISecondLocationVisibilityRemark, ISectorVisibilityRemark, ISmallHailSizeRemark, ISnowIncreaseRemark, ISnowPelletsRemark, ISunshineDurationRemark, ISurfaceVisibilityRemark, ITAF, ITAFDated, ITemperature, ITemperatureDated, IThunderStormLocationMovingRemark, IThunderStormLocationRemark, ITime, ITornadicActivityBegEndRemark, ITornadicActivityBegRemark, ITornadicActivityEndRemark, ITowerVisibilityRemark, IUnknownRemark, IValidity, IValidityDated, IVariableSkyHeightRemark, IVariableSkyRemark, IVirgaDirectionRemark, IWaterEquivalentSnowRemark, IWeatherCondition, IWind, IWindPeakCommandRemark, IWindShear, IWindShiftFropaRemark, Intensity, InvalidWeatherStatementError, Locale, ParseError, Phenomenon, Remark, RemarkType, RunwayInfoTrend, RunwayInfoUnit, SpeedUnit, TAFTrend, TAFTrendDated, TimeIndicator, TimestampOutOfBoundsError, UnexpectedParseError, ValueIndicator, Visibility, WeatherChangeType, getCompositeForecastForDate, isWeatherConditionValid, parseMetar, parseTAF, parseTAFAsForecast };
+export { CloudQuantity, CloudType, CommandExecutionError, Descriptive, Direction, Distance, DistanceUnit, Forecast, IAbstractTrend, IAbstractValidity, IAbstractWeatherCode, IAbstractWeatherCodeDated, IAbstractWeatherContainer, IBaseRemark, IBaseTAFTrend, ICeilingHeightRemark, ICeilingSecondLocationRemark, ICloud, ICompositeForecast, IEndValidity, IFMValidity, IFlags, IForecastContainer, IHourlyMaximumMinimumTemperatureRemark, IHourlyMaximumTemperatureRemark, IHourlyMinimumTemperatureRemark, IHourlyPrecipitationAmountRemark, IHourlyPressureRemark, IHourlyTemperatureDewPointRemark, IIceAccretionRemark, IIcing, IMetar, IMetarTAFParserOptions, IMetarTAFParserOptionsDated, IMetarTrend, IMetarTrendTime, IObscurationRemark, IPrecipitationAmount24HourRemark, IPrecipitationAmount36HourRemark, IPrecipitationBegEndRemark, IPrevailingVisibilityRemark, IRunwayInfo, ISeaLevelPressureRemark, ISecondLocationVisibilityRemark, ISectorVisibilityRemark, ISmallHailSizeRemark, ISnowIncreaseRemark, ISnowPelletsRemark, ISunshineDurationRemark, ISurfaceVisibilityRemark, ITAF, ITAFDated, ITafGroups, ITemperature, ITemperatureDated, IThunderStormLocationMovingRemark, IThunderStormLocationRemark, ITime, ITornadicActivityBegEndRemark, ITornadicActivityBegRemark, ITornadicActivityEndRemark, ITowerVisibilityRemark, ITurbulence, IUnknownRemark, IValidity, IValidityDated, IVariableSkyHeightRemark, IVariableSkyRemark, IVirgaDirectionRemark, IWaterEquivalentSnowRemark, IWeatherCondition, IWind, IWindPeakCommandRemark, IWindShear, IWindShiftFropaRemark, IcingIntensity, Intensity, InvalidWeatherStatementError, Locale, ParseError, Phenomenon, Remark, RemarkType, RunwayInfoTrend, RunwayInfoUnit, SpeedUnit, TAFTrend, TAFTrendDated, TimeIndicator, TimestampOutOfBoundsError, TurbulenceIntensity, UnexpectedParseError, ValueIndicator, Visibility, WeatherChangeType, getCompositeForecastForDate, isWeatherConditionValid, parseMetar, parseTAF, parseTAFAsForecast };

package/metar-taf-parser.js

@@ -473,6 +473,59 @@ var RunwayInfoUnit;
     RunwayInfoUnit["Feet"] = "FT";
     RunwayInfoUnit["Meters"] = "m";
 })(RunwayInfoUnit || (RunwayInfoUnit = {}));
+var IcingIntensity;
+(function (IcingIntensity) {
+    /**
+     * Trace Icing or None.
+     *
+     * Air Force code 0 means a trace of icing.
+     * World Meteorological Organization code 0 means no icing
+     */
+    IcingIntensity["None"] = "0";
+    /** Light Mixed Icing. */
+    IcingIntensity["Light"] = "1";
+    /** Light Rime Icing In Cloud. */
+    IcingIntensity["LightRimeIcingCloud"] = "2";
+    /** Light Clear Icing In Precipitation. */
+    IcingIntensity["LightClearIcingPrecipitation"] = "3";
+    /** Moderate Mixed Icing. */
+    IcingIntensity["ModerateMixedIcing"] = "4";
+    /** Moderate Rime Icing In Cloud. */
+    IcingIntensity["ModerateRimeIcingCloud"] = "5";
+    /** Moderate Clear Icing In Precipitation. */
+    IcingIntensity["ModerateClearIcingPrecipitation"] = "6";
+    /** Severe Mixed Icing. */
+    IcingIntensity["SevereMixedIcing"] = "7";
+    /** Severe Rime Icing In Cloud. */
+    IcingIntensity["SevereRimeIcingCloud"] = "8";
+    /** Severe Clear Icing In Precipitation. */
+    IcingIntensity["SevereClearIcingPrecipitation"] = "9";
+})(IcingIntensity || (IcingIntensity = {}));
+var TurbulenceIntensity;
+(function (TurbulenceIntensity) {
+    /** None. */
+    TurbulenceIntensity["None"] = "0";
+    /** Light turbulence. */
+    TurbulenceIntensity["Light"] = "1";
+    /** Moderate turbulence in clear air, occasional. */
+    TurbulenceIntensity["ModerateClearAirOccasional"] = "2";
+    /** Moderate turbulence in clear air, frequent. */
+    TurbulenceIntensity["ModerateClearAirFrequent"] = "3";
+    /** Moderate turbulence in cloud, occasional. */
+    TurbulenceIntensity["ModerateCloudOccasional"] = "4";
+    /** Moderate turbulence in cloud, frequent. */
+    TurbulenceIntensity["ModerateCloudFrequent"] = "5";
+    /** Severe turbulence in clear air, occasional. */
+    TurbulenceIntensity["SevereClearAirOccasional"] = "6";
+    /** Severe turbulence in clear air, frequent. */
+    TurbulenceIntensity["SevereClearAirFrequent"] = "7";
+    /** Severe turbulence in cloud, occasional. */
+    TurbulenceIntensity["SevereCloudOccasional"] = "8";
+    /** Severe turbulence in cloud, frequent. */
+    TurbulenceIntensity["SevereCloudFrequent"] = "9";
+    /** Extreme turbulence */
+    TurbulenceIntensity["Extreme"] = "X";
+})(TurbulenceIntensity || (TurbulenceIntensity = {}));
 
 function degreesToCardinal(input) {
     const degrees = +input;
@@ -1741,7 +1794,7 @@ function isWeatherConditionValid(weather) {
             weather.descriptive == Descriptive.SHOWERS));
 }
 
-var _CloudCommand_cloudRegex, _MainVisibilityCommand_regex, _WindCommand_regex, _WindVariationCommand_regex, _WindShearCommand_regex, _VerticalVisibilityCommand_regex, _MinimalVisibilityCommand_regex, _MainVisibilityNauticalMilesCommand_regex, _CommandSupplier_commands$1;
+var _CloudCommand_cloudRegex, _MainVisibilityCommand_regex, _WindCommand_regex, _WindVariationCommand_regex, _WindShearCommand_regex, _VerticalVisibilityCommand_regex, _MinimalVisibilityCommand_regex, _MainVisibilityNauticalMilesCommand_regex, _CommandSupplier_commands$2;
 /**
  * This function creates a wind element.
  * @param wind The wind object
@@ -1761,18 +1814,17 @@ function makeWind(direction, speed, gust, unit) {
 }
 class CloudCommand {
     constructor() {
-        _CloudCommand_cloudRegex.set(this, /^([A-Z]{3})(\d{3})?([A-Z]{2,3})?$/);
+        _CloudCommand_cloudRegex.set(this, /^([A-Z]{3})(?:\/{3}|(\d{3}))?(?:\/{3}|(?:([A-Z]{2,3})(?:\/([A-Z]{2,3}))?))?$/);
     }
     parse(cloudString) {
         const m = cloudString.match(__classPrivateFieldGet(this, _CloudCommand_cloudRegex, "f"));
         if (!m)
             return;
-        const quantity = CloudQuantity[m[1]];
+        const quantity = as(m[1], CloudQuantity);
         const height = 100 * +m[2] || undefined;
-        const type = CloudType[m[3]];
-        if (!quantity)
-            return;
-        return { quantity, height, type };
+        const type = m[3] ? as(m[3], CloudType) : undefined;
+        const secondaryType = m[4] ? as(m[4], CloudType) : undefined;
+        return { quantity, height, type, secondaryType };
     }
     execute(container, cloudString) {
         const cloud = this.parse(cloudString);
@@ -1811,7 +1863,7 @@ class MainVisibilityCommand {
 _MainVisibilityCommand_regex = new WeakMap();
 class WindCommand {
     constructor() {
-        _WindCommand_regex.set(this, /^(VRB|\d{3})(\d{2})G?(\d{2})?(KT|MPS|KM\/H)?/);
+        _WindCommand_regex.set(this, /^(VRB|[0-3]\d{2})(\d{2})G?(\d{2})?(KT|MPS|KM\/H)?/);
     }
     canParse(windString) {
         return __classPrivateFieldGet(this, _WindCommand_regex, "f").test(windString);
@@ -1924,9 +1976,9 @@ class MainVisibilityNauticalMilesCommand {
     }
 }
 _MainVisibilityNauticalMilesCommand_regex = new WeakMap();
-class CommandSupplier$1 {
+class CommandSupplier$2 {
     constructor() {
-        _CommandSupplier_commands$1.set(this, [
+        _CommandSupplier_commands$2.set(this, [
             new WindShearCommand(),
             new WindCommand(),
             new WindVariationCommand(),
@@ -1938,13 +1990,13 @@ class CommandSupplier$1 {
         ]);
     }
     get(input) {
-        for (const command of __classPrivateFieldGet(this, _CommandSupplier_commands$1, "f")) {
+        for (const command of __classPrivateFieldGet(this, _CommandSupplier_commands$2, "f")) {
             if (command.canParse(input))
                 return command;
         }
     }
 }
-_CommandSupplier_commands$1 = new WeakMap();
+_CommandSupplier_commands$2 = new WeakMap();
 
 var _AltimeterCommand_regex;
 class AltimeterCommand {
@@ -2048,16 +2100,76 @@ class TemperatureCommand {
 }
 _TemperatureCommand_regex = new WeakMap();
 
-var _CommandSupplier_commands;
-class CommandSupplier {
+var _CommandSupplier_commands$1;
+class CommandSupplier$1 {
     constructor() {
-        _CommandSupplier_commands.set(this, [
+        _CommandSupplier_commands$1.set(this, [
             new RunwayCommand(),
             new TemperatureCommand(),
             new AltimeterCommand(),
             new AltimeterMercuryCommand(),
         ]);
     }
+    get(input) {
+        for (const command of __classPrivateFieldGet(this, _CommandSupplier_commands$1, "f")) {
+            if (command.canParse(input))
+                return command;
+        }
+    }
+}
+_CommandSupplier_commands$1 = new WeakMap();
+
+var _IcingCommand_regex;
+class IcingCommand {
+    constructor() {
+        _IcingCommand_regex.set(this, /^6(\d)(\d{3})(\d)$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _IcingCommand_regex, "f").test(input);
+    }
+    execute(container, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _IcingCommand_regex, "f"));
+        if (!matches)
+            throw new UnexpectedParseError("Match not found");
+        if (!container.icing)
+            container.icing = [];
+        container.icing.push({
+            intensity: as(matches[1], IcingIntensity),
+            baseHeight: +matches[2] * 100,
+            depth: +matches[3] * 1000,
+        });
+    }
+}
+_IcingCommand_regex = new WeakMap();
+
+var _TurbulenceCommand_regex;
+class TurbulenceCommand {
+    constructor() {
+        _TurbulenceCommand_regex.set(this, /^5(\d|X)(\d{3})(\d)$/);
+    }
+    canParse(input) {
+        return __classPrivateFieldGet(this, _TurbulenceCommand_regex, "f").test(input);
+    }
+    execute(container, input) {
+        const matches = input.match(__classPrivateFieldGet(this, _TurbulenceCommand_regex, "f"));
+        if (!matches)
+            throw new UnexpectedParseError("Match not found");
+        if (!container.turbulence)
+            container.turbulence = [];
+        container.turbulence.push({
+            intensity: as(matches[1], TurbulenceIntensity),
+            baseHeight: +matches[2] * 100,
+            depth: +matches[3] * 1000,
+        });
+    }
+}
+_TurbulenceCommand_regex = new WeakMap();
+
+var _CommandSupplier_commands;
+class CommandSupplier {
+    constructor() {
+        _CommandSupplier_commands.set(this, [new TurbulenceCommand(), new IcingCommand()]);
+    }
     get(input) {
         for (const command of __classPrivateFieldGet(this, _CommandSupplier_commands, "f")) {
             if (command.canParse(input))
@@ -2067,7 +2179,7 @@ class CommandSupplier {
 }
 _CommandSupplier_commands = new WeakMap();
 
-var _AbstractParser_INTENSITY_REGEX, _AbstractParser_CAVOK, _AbstractParser_commonSupplier, _MetarParser_commandSupplier, _TAFParser_validityPattern, _RemarkParser_supplier;
+var _AbstractParser_INTENSITY_REGEX, _AbstractParser_CAVOK, _AbstractParser_commonSupplier, _MetarParser_commandSupplier, _TAFParser_commandSupplier, _TAFParser_validityPattern, _RemarkParser_supplier;
 /**
  * Parses the delivery time of a METAR/TAF
  * @param abstractWeatherCode The TAF or METAR object
@@ -2171,32 +2283,52 @@ class AbstractParser {
         // #TOKENIZE_REGEX = /\s((?=\d\/\dSM)(?<!\s\d\s)|(?!\d\/\dSM))|=/;
         _AbstractParser_INTENSITY_REGEX.set(this, /^(-|\+|VC)/);
         _AbstractParser_CAVOK.set(this, "CAVOK");
-        _AbstractParser_commonSupplier.set(this, new CommandSupplier$1());
+        _AbstractParser_commonSupplier.set(this, new CommandSupplier$2());
     }
     parseWeatherCondition(input) {
         let intensity;
         if (input.match(__classPrivateFieldGet(this, _AbstractParser_INTENSITY_REGEX, "f"))) {
             const match = input.match(__classPrivateFieldGet(this, _AbstractParser_INTENSITY_REGEX, "f"))?.[0];
-            if (match)
+            if (match) {
                 intensity = match;
+                input = input.slice(match.length);
+            }
         }
         let descriptive;
-        for (const key of Object.values(Descriptive)) {
-            if (input.includes(key))
+        const descriptives = Object.values(Descriptive);
+        for (let i = 0; i < descriptives.length; i++) {
+            const key = descriptives[i];
+            if (input.startsWith(key)) {
                 descriptive = key;
+                input = input.slice(key.length);
+                break;
+            }
         }
         const weatherCondition = {
             intensity,
             descriptive,
             phenomenons: [],
         };
-        for (const key of Object.values(Phenomenon)) {
+        const phenomenons = Object.values(Phenomenon);
+        for (let i = 0; i < phenomenons.length; i++) {
+            const key = phenomenons[i];
             // Thunderstorm as descriptive should not be added as a phenomenon
             if (descriptive === key)
                 continue;
-            if (input.includes(key))
+            // Phenomenons can be separated with a slash
+            const conditionRegex = new RegExp(`^\/?${key}`);
+            const inputMatch = input.match(conditionRegex)?.[0];
+            if (inputMatch) {
                 weatherCondition.phenomenons.push(key);
+                input = input.slice(inputMatch.length);
+                // Restart the search for an additional phenomenon
+                i = -1;
+                continue;
+            }
         }
+        // If anything is left unparsed, it's not a valid weather condition
+        if (input.replace(/\//g, "").length)
+            return;
         return weatherCondition;
     }
     /**
@@ -2238,15 +2370,22 @@ class AbstractParser {
             };
             return true;
         }
-        const command = __classPrivateFieldGet(this, _AbstractParser_commonSupplier, "f").get(input);
-        if (command) {
-            return command.execute(abstractWeatherContainer, input);
-        }
         const weatherCondition = this.parseWeatherCondition(input);
-        if (isWeatherConditionValid(weatherCondition)) {
+        if (weatherCondition && isWeatherConditionValid(weatherCondition)) {
             abstractWeatherContainer.weatherConditions.push(weatherCondition);
             return true;
         }
+        const command = __classPrivateFieldGet(this, _AbstractParser_commonSupplier, "f").get(input);
+        if (command) {
+            try {
+                return command.execute(abstractWeatherContainer, input);
+            }
+            catch (error) {
+                if (error instanceof CommandExecutionError)
+                    return false;
+                throw error;
+            }
+        }
         return false;
     }
 }
@@ -2256,7 +2395,7 @@ class MetarParser extends AbstractParser {
         super(...arguments);
         this.AT = "AT";
         this.TL = "TL";
-        _MetarParser_commandSupplier.set(this, new CommandSupplier());
+        _MetarParser_commandSupplier.set(this, new CommandSupplier$1());
     }
     /**
      * Parses a trend of a metar
@@ -2354,6 +2493,7 @@ class TAFParser extends AbstractParser {
         this.PROB = "PROB";
         this.TX = "TX";
         this.TN = "TN";
+        _TAFParser_commandSupplier.set(this, new CommandSupplier());
         _TAFParser_validityPattern.set(this, /^\d{4}\/\d{4}$/);
     }
     /**
@@ -2406,13 +2546,17 @@ class TAFParser extends AbstractParser {
         };
         for (let i = index + 1; i < lines[0].length; i++) {
             const token = lines[0][i];
+            const tafCommand = __classPrivateFieldGet(this, _TAFParser_commandSupplier, "f").get(token);
             if (token == this.RMK) {
                 parseRemark(taf, lines[0], i, this.locale);
                 break;
             }
+            else if (tafCommand) {
+                tafCommand.execute(taf, token);
+            }
             else {
-                parseFlags(taf, token);
                 this.generalParse(taf, token);
+                parseFlags(taf, token);
             }
         }
         const minMaxTemperatureLines = [
@@ -2537,6 +2681,7 @@ class TAFParser extends AbstractParser {
      */
     parseTrend(index, line, trend) {
         for (let i = index; i < line.length; i++) {
+            const tafCommand = __classPrivateFieldGet(this, _TAFParser_commandSupplier, "f").get(line[i]);
             if (line[i] === this.RMK) {
                 parseRemark(trend, line, i, this.locale);
                 break;
@@ -2544,6 +2689,9 @@ class TAFParser extends AbstractParser {
             // already parsed
             else if (__classPrivateFieldGet(this, _TAFParser_validityPattern, "f").test(line[i]))
                 continue;
+            else if (tafCommand) {
+                tafCommand.execute(trend, line[i]);
+            }
             else
                 super.generalParse(trend, line[i]);
         }
@@ -2556,7 +2704,7 @@ class TAFParser extends AbstractParser {
         };
     }
 }
-_TAFParser_validityPattern = new WeakMap();
+_TAFParser_commandSupplier = new WeakMap(), _TAFParser_validityPattern = new WeakMap();
 class RemarkParser {
     constructor(locale) {
         this.locale = locale;
@@ -2592,7 +2740,7 @@ _RemarkParser_supplier = new WeakMap();
  * @param minute Minute (from the report)
  * @returns
  */
-function determineReportIssuedDate(date, day, hour, minute) {
+function determineReportDate(date, day, hour, minute = 0) {
     // Some TAF reports do not include a delivery time
     if (day == null || hour == null)
         return date;
@@ -2608,17 +2756,6 @@ function determineReportIssuedDate(date, day, hour, minute) {
     }))
         .sort((a, b) => a.difference - b.difference)[0].date;
 }
-function getReportDate(issued, day, hour, minute = 0) {
-    let date = new Date(issued);
-    if (day < date.getUTCDate()) {
-        date = addMonthsUTC(date, 1);
-    }
-    date.setUTCDate(day);
-    date.setUTCHours(hour);
-    if (minute != null)
-        date.setUTCMinutes(minute);
-    return date;
-}
 function setDateComponents(date, day, hour, minute) {
     date.setUTCDate(day);
     date.setUTCHours(hour);
@@ -2641,30 +2778,30 @@ function addMonthsUTC(date, count) {
 function metarDatesHydrator(report, date) {
     return {
         ...report,
-        issued: determineReportIssuedDate(date, report.day, report.hour, report.minute),
+        issued: determineReportDate(date, report.day, report.hour, report.minute),
     };
 }
 
 function tafDatesHydrator(report, date) {
-    const issued = determineReportIssuedDate(date, report.day, report.hour, report.minute);
+    const issued = determineReportDate(date, report.day, report.hour, report.minute);
     return {
         ...report,
         issued,
         validity: {
             ...report.validity,
-            start: getReportDate(issued, report.validity.startDay, report.validity.startHour),
-            end: getReportDate(issued, report.validity.endDay, report.validity.endHour),
+            start: determineReportDate(issued, report.validity.startDay, report.validity.startHour),
+            end: determineReportDate(issued, report.validity.endDay, report.validity.endHour),
         },
         minTemperature: report.minTemperature
             ? {
                 ...report.minTemperature,
-                date: getReportDate(issued, report.minTemperature.day, report.minTemperature.hour),
+                date: determineReportDate(issued, report.minTemperature.day, report.minTemperature.hour),
             }
             : undefined,
         maxTemperature: report.maxTemperature
             ? {
                 ...report.maxTemperature,
-                date: getReportDate(issued, report.maxTemperature.day, report.maxTemperature.hour),
+                date: determineReportDate(issued, report.maxTemperature.day, report.maxTemperature.hour),
             }
             : undefined,
         trends: report.trends.map((trend) => ({
@@ -2674,13 +2811,13 @@ function tafDatesHydrator(report, date) {
                     case WeatherChangeType.FM:
                         return {
                             ...trend.validity,
-                            start: getReportDate(issued, trend.validity.startDay, trend.validity.startHour, trend.validity.startMinutes),
+                            start: determineReportDate(issued, trend.validity.startDay, trend.validity.startHour, trend.validity.startMinutes),
                         };
                     default:
                         return {
                             ...trend.validity,
-                            start: getReportDate(issued, trend.validity.startDay, trend.validity.startHour),
-                            end: getReportDate(issued, trend.validity.endDay, trend.validity.endHour),
+                            start: determineReportDate(issued, trend.validity.startDay, trend.validity.startHour),
+                            end: determineReportDate(issued, trend.validity.endDay, trend.validity.endHour),
                         };
                 }
             })(),
@@ -2692,8 +2829,8 @@ function getForecastFromTAF(taf) {
     const { trends, wind, visibility, verticalVisibility, windShear, cavok, remark, remarks, clouds, weatherConditions, initialRaw, validity, ...tafWithoutBaseProperties } = taf;
     return {
         ...tafWithoutBaseProperties,
-        start: getReportDate(taf.issued, taf.validity.startDay, taf.validity.startHour),
-        end: getReportDate(taf.issued, taf.validity.endDay, taf.validity.endHour),
+        start: determineReportDate(taf.issued, taf.validity.startDay, taf.validity.startHour),
+        end: determineReportDate(taf.issued, taf.validity.endDay, taf.validity.endHour),
         forecast: hydrateEndDates([makeInitialForecast(taf), ...taf.trends], taf.validity),
     };
 }
@@ -2712,6 +2849,8 @@ function makeInitialForecast(taf) {
         clouds: taf.clouds,
         weatherConditions: taf.weatherConditions,
         raw: taf.initialRaw,
+        turbulence: taf.turbulence,
+        icing: taf.icing,
         validity: {
             // End day/hour are for end of the entire TAF
             startDay: taf.validity.startDay,
@@ -2781,6 +2920,8 @@ function hydrateEndDates(trends, reportValidity) {
  * it needs to be populated
  */
 function hydrateWithPreviousContextIfNeeded(forecast, context) {
+    // BECMG is the only forecast type that inherits old conditions
+    // Anything else starts anew
     if (forecast.type !== WeatherChangeType.BECMG || !context)
         return forecast;
     // Remarks should not be carried over
@@ -2790,6 +2931,12 @@ function hydrateWithPreviousContextIfNeeded(forecast, context) {
     // vertical visibility should not be carried over, if clouds exist
     if (forecast.clouds.length)
         delete context.verticalVisibility;
+    // CAVOK should not propagate if anything other than wind changes
+    if (forecast.clouds.length ||
+        forecast.verticalVisibility ||
+        forecast.weatherConditions.length ||
+        forecast.visibility)
+        delete context.cavok;
     forecast = {
         ...context,
         ...forecast,
@@ -2865,4 +3012,4 @@ function parse(rawReport, options, parser, datesHydrator) {
     }
 }
 
-export { CloudQuantity, CloudType, CommandExecutionError, Descriptive, Direction, DistanceUnit, Intensity, InvalidWeatherStatementError, ParseError, Phenomenon, RemarkType, RunwayInfoTrend, RunwayInfoUnit, SpeedUnit, TimeIndicator, TimestampOutOfBoundsError, UnexpectedParseError, ValueIndicator, WeatherChangeType, getCompositeForecastForDate, isWeatherConditionValid, parseMetar, parseTAF, parseTAFAsForecast };
+export { CloudQuantity, CloudType, CommandExecutionError, Descriptive, Direction, DistanceUnit, IcingIntensity, Intensity, InvalidWeatherStatementError, ParseError, Phenomenon, RemarkType, RunwayInfoTrend, RunwayInfoUnit, SpeedUnit, TimeIndicator, TimestampOutOfBoundsError, TurbulenceIntensity, UnexpectedParseError, ValueIndicator, WeatherChangeType, getCompositeForecastForDate, isWeatherConditionValid, parseMetar, parseTAF, parseTAFAsForecast };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metar-taf-parser",
-  "version": "7.0.0",
+  "version": "7.1.1",
   "description": "Parse METAR and TAF reports",
   "homepage": "https://aeharding.github.io/metar-taf-parser",
   "keywords": [