metar-taf-parser 1.2.0 → 2.0.0

package/dist/command/remark.js

@@ -1,762 +1,90 @@
 "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 _CeilingHeightCommand_regex, _CeilingSecondLocationCommand_regex, _HailSizeCommand_regex, _HourlyMaximumMinimumTemperatureCommand_regex, _HourlyMaximumTemperatureCommand_regex, _HourlyMinimumTemperatureCommand_regex, _HourlyPrecipitationAmountCommand_regex, _HourlyPressureCommand_regex, _HourlyTemperatureDewPointCommand_regex, _IceAccretionCommand_regex, _ObscurationCommand_regex, _PrecipitationAmount24HourCommand_regex, _PrecipitationAmount36HourCommand_regex, _PrecipitationBegEndCommand_regex, _PrevailingVisibilityCommand_regex, _SeaLevelPressureCommand_regex, _SecondLocationVisibilityCommand_regex, _SectorVisibilityCommand_regex, _SmallHailSizeCommand_regex, _SnowDepthCommand_regex, _SnowIncreaseCommand_regex, _SnowPelletsCommand_regex, _SunshineDurationCommand_regex, _SurfaceVisibilityCommand_regex, _ThunderStormLocationCommand_regex, _ThunderStormLocationMovingCommand_regex, _TornadicActivityBegCommand_regex, _TornadicActivityBegEndCommand_regex, _TornadicActivityEndCommand_regex, _TowerVisibilityCommand_regex, _VariableSkyCommand_regex, _VariableSkyHeightCommand_regex, _VirgaDirectionCommand_regex, _WaterEquivalentSnowCommand_regex, _WindPeakCommand_regex, _WindShiftCommand_regex, _WindShiftFropaCommand_regex;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemarkCommandSupplier = exports.DefaultCommand = exports.WindShiftFropaCommand = exports.WindShiftCommand = exports.WindPeakCommand = exports.WaterEquivalentSnowCommand = exports.VirgaDirectionCommand = exports.VariableSkyHeightCommand = exports.VariableSkyCommand = exports.TowerVisibilityCommand = exports.TornadicActivityEndCommand = exports.TornadicActivityBegEndCommand = exports.TornadicActivityBegCommand = exports.ThunderStormLocationMovingCommand = exports.ThunderStormLocationCommand = exports.SurfaceVisibilityCommand = exports.SunshineDurationCommand = exports.SnowPelletsCommand = exports.SnowIncreaseCommand = exports.SnowDepthCommand = exports.SmallHailSizeCommand = exports.SectorVisibilityCommand = exports.SecondLocationVisibilityCommand = exports.SeaLevelPressureCommand = exports.PrevailingVisibilityCommand = exports.PrecipitationBegEndCommand = exports.PrecipitationAmount36HourCommand = exports.PrecipitationAmount24HourCommand = exports.ObscurationCommand = exports.IceAccretionCommand = exports.HourlyTemperatureDewPointCommand = exports.HourlyPressureCommand = exports.HourlyPrecipitationAmountCommand = exports.HourlyMinimumTemperatureCommand = exports.HourlyMaximumTemperatureCommand = exports.HourlyMaximumMinimumTemperatureCommand = exports.HailSizeCommand = exports.CeilingSecondLocationCommand = exports.CeilingHeightCommand = exports.Command = void 0;
-const helpers_1 = require("../helpers/helpers");
-const converter_1 = require("../commons/converter");
-const i18n_1 = require("../commons/i18n");
-const errors_1 = require("../commons/errors");
-class Command {
-    constructor(locale) {
-        this.locale = locale;
-    }
-}
-exports.Command = Command;
-class CeilingHeightCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _CeilingHeightCommand_regex.set(this, /^CIG (\d{3})V(\d{3})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _CeilingHeightCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _CeilingHeightCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        const minCeiling = +matches[1] * 100;
-        const maxCeiling = +matches[2] * 100;
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Ceiling.Height", this.locale), minCeiling, maxCeiling));
-        return [code.replace(__classPrivateFieldGet(this, _CeilingHeightCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.CeilingHeightCommand = CeilingHeightCommand;
-_CeilingHeightCommand_regex = new WeakMap();
-class CeilingSecondLocationCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _CeilingSecondLocationCommand_regex.set(this, /^CIG (\d{3}) (\w+)\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _CeilingSecondLocationCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _CeilingSecondLocationCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        const height = +matches[1] * 100;
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Ceiling.Second.Location", this.locale), height, matches[2]));
-        return [code.replace(__classPrivateFieldGet(this, _CeilingSecondLocationCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.CeilingSecondLocationCommand = CeilingSecondLocationCommand;
-_CeilingSecondLocationCommand_regex = new WeakMap();
-class HailSizeCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _HailSizeCommand_regex.set(this, /^GR ((\d\/\d)|((\d) ?(\d\/\d)?))/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _HailSizeCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _HailSizeCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Hail.0", this.locale), matches[1]));
-        return [code.replace(__classPrivateFieldGet(this, _HailSizeCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.HailSizeCommand = HailSizeCommand;
-_HailSizeCommand_regex = new WeakMap();
-class HourlyMaximumMinimumTemperatureCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _HourlyMaximumMinimumTemperatureCommand_regex.set(this, /^4([01])(\d{3})([01])(\d{3})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _HourlyMaximumMinimumTemperatureCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _HourlyMaximumMinimumTemperatureCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Maximum.Minimum.Temperature", this.locale), (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2]), (0, converter_1.convertTemperatureRemarks)(matches[3], matches[4])));
-        return [code.replace(__classPrivateFieldGet(this, _HourlyMaximumMinimumTemperatureCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.HourlyMaximumMinimumTemperatureCommand = HourlyMaximumMinimumTemperatureCommand;
-_HourlyMaximumMinimumTemperatureCommand_regex = new WeakMap();
-class HourlyMaximumTemperatureCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _HourlyMaximumTemperatureCommand_regex.set(this, /^1([01])(\d{3})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _HourlyMaximumTemperatureCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _HourlyMaximumTemperatureCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Maximum.Temperature", this.locale), (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2])));
-        return [code.replace(__classPrivateFieldGet(this, _HourlyMaximumTemperatureCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.HourlyMaximumTemperatureCommand = HourlyMaximumTemperatureCommand;
-_HourlyMaximumTemperatureCommand_regex = new WeakMap();
-class HourlyMinimumTemperatureCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _HourlyMinimumTemperatureCommand_regex.set(this, /^2([01])(\d{3})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _HourlyMinimumTemperatureCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _HourlyMinimumTemperatureCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Minimum.Temperature", this.locale), (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2])));
-        return [code.replace(__classPrivateFieldGet(this, _HourlyMinimumTemperatureCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.HourlyMinimumTemperatureCommand = HourlyMinimumTemperatureCommand;
-_HourlyMinimumTemperatureCommand_regex = new WeakMap();
-class HourlyPrecipitationAmountCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _HourlyPrecipitationAmountCommand_regex.set(this, /^P(\d{4})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _HourlyPrecipitationAmountCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _HourlyPrecipitationAmountCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Precipitation.Amount.Hourly", this.locale), +matches[1]));
-        return [code.replace(__classPrivateFieldGet(this, _HourlyPrecipitationAmountCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.HourlyPrecipitationAmountCommand = HourlyPrecipitationAmountCommand;
-_HourlyPrecipitationAmountCommand_regex = new WeakMap();
-class HourlyPressureCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _HourlyPressureCommand_regex.set(this, /^5(\d)(\d{3})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _HourlyPressureCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _HourlyPressureCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push(`${(0, i18n_1._)(`Remark.Barometer.${+matches[1]}`, this.locale)} ${(0, i18n_1.format)((0, i18n_1._)("Remark.Pressure.Tendency", this.locale), +matches[2] / 10)}`);
-        return [code.replace(__classPrivateFieldGet(this, _HourlyPressureCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.HourlyPressureCommand = HourlyPressureCommand;
-_HourlyPressureCommand_regex = new WeakMap();
-class HourlyTemperatureDewPointCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _HourlyTemperatureDewPointCommand_regex.set(this, /^T([01])(\d{3})(([01])(\d{3}))?/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _HourlyTemperatureDewPointCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _HourlyTemperatureDewPointCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        if (!matches[3]) {
-            remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Temperature.0", this.locale), (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2])));
-        }
-        else {
-            remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Temperature.Dew.Point", this.locale), (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2]), (0, converter_1.convertTemperatureRemarks)(matches[4], matches[5])));
-        }
-        return [code.replace(__classPrivateFieldGet(this, _HourlyTemperatureDewPointCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.HourlyTemperatureDewPointCommand = HourlyTemperatureDewPointCommand;
-_HourlyTemperatureDewPointCommand_regex = new WeakMap();
-class IceAccretionCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _IceAccretionCommand_regex.set(this, /^l(\d)(\d{3})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _IceAccretionCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _IceAccretionCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Ice.Accretion.Amount", this.locale), +matches[2], +matches[1]));
-        return [code.replace(__classPrivateFieldGet(this, _IceAccretionCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.IceAccretionCommand = IceAccretionCommand;
-_IceAccretionCommand_regex = new WeakMap();
-class ObscurationCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _ObscurationCommand_regex.set(this, /^([A-Z]{2}) ([A-Z]{3})(\d{3})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _ObscurationCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _ObscurationCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        const layer = (0, i18n_1._)(`CloudQuantity.${matches[2]}`, this.locale);
-        const height = 100 * +matches[3];
-        const detail = (0, i18n_1._)(`Phenomenon.${matches[1]}`, this.locale);
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Obscuration", this.locale), layer, height, detail));
-        return [code.replace(__classPrivateFieldGet(this, _ObscurationCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.ObscurationCommand = ObscurationCommand;
-_ObscurationCommand_regex = new WeakMap();
-class PrecipitationAmount24HourCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _PrecipitationAmount24HourCommand_regex.set(this, /^7(\d{4})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _PrecipitationAmount24HourCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _PrecipitationAmount24HourCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Precipitation.Amount.24", this.locale), (0, converter_1.convertPrecipitationAmount)(matches[1])));
-        return [code.replace(__classPrivateFieldGet(this, _PrecipitationAmount24HourCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.PrecipitationAmount24HourCommand = PrecipitationAmount24HourCommand;
-_PrecipitationAmount24HourCommand_regex = new WeakMap();
-class PrecipitationAmount36HourCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _PrecipitationAmount36HourCommand_regex.set(this, /^([36])(\d{4})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _PrecipitationAmount36HourCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _PrecipitationAmount36HourCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Precipitation.Amount.3.6", this.locale), matches[1], (0, converter_1.convertPrecipitationAmount)(matches[2])));
-        return [code.replace(__classPrivateFieldGet(this, _PrecipitationAmount36HourCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.PrecipitationAmount36HourCommand = PrecipitationAmount36HourCommand;
-_PrecipitationAmount36HourCommand_regex = new WeakMap();
-class PrecipitationBegEndCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _PrecipitationBegEndCommand_regex.set(this, /^(([A-Z]{2})?([A-Z]{2})B(\d{2})?(\d{2})E(\d{2})?(\d{2}))/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _PrecipitationBegEndCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _PrecipitationBegEndCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Precipitation.Beg.End", this.locale), matches[2] ? (0, i18n_1._)(`Descriptive.${matches[2]}`, this.locale) : "", (0, i18n_1._)(`Phenomenon.${matches[3]}`, this.locale), matches[4] || "", matches[5], matches[6] || "", matches[7]));
-        return [code.replace(__classPrivateFieldGet(this, _PrecipitationBegEndCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.PrecipitationBegEndCommand = PrecipitationBegEndCommand;
-_PrecipitationBegEndCommand_regex = new WeakMap();
-class PrevailingVisibilityCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _PrevailingVisibilityCommand_regex.set(this, /^VIS ((\d)*( )?(\d?\/?\d))V((\d)*( )?(\d?\/?\d))/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _PrevailingVisibilityCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _PrevailingVisibilityCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Variable.Prevailing.Visibility", this.locale), matches[1], matches[5]));
-        return [code.replace(__classPrivateFieldGet(this, _PrevailingVisibilityCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.PrevailingVisibilityCommand = PrevailingVisibilityCommand;
-_PrevailingVisibilityCommand_regex = new WeakMap();
-class SeaLevelPressureCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SeaLevelPressureCommand_regex.set(this, /^SLP(\d{2})(\d)/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SeaLevelPressureCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SeaLevelPressureCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        let pressure = matches[1].startsWith("9") ? "9" : "10";
-        pressure += matches[1] + "." + matches[2];
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Sea.Level.Pressure", this.locale), pressure));
-        return [code.replace(__classPrivateFieldGet(this, _SeaLevelPressureCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SeaLevelPressureCommand = SeaLevelPressureCommand;
-_SeaLevelPressureCommand_regex = new WeakMap();
-class SecondLocationVisibilityCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SecondLocationVisibilityCommand_regex.set(this, /^VIS ((\d)*( )?(\d?\/?\d)) (\w+)/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SecondLocationVisibilityCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SecondLocationVisibilityCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Second.Location.Visibility", this.locale), matches[1], matches[5]));
-        return [code.replace(__classPrivateFieldGet(this, _SecondLocationVisibilityCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SecondLocationVisibilityCommand = SecondLocationVisibilityCommand;
-_SecondLocationVisibilityCommand_regex = new WeakMap();
-class SectorVisibilityCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SectorVisibilityCommand_regex.set(this, /^VIS ([A-Z]{1,2}) ((\d)*( )?(\d?\/?\d))/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SectorVisibilityCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SectorVisibilityCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Sector.Visibility", this.locale), (0, i18n_1._)(`Converter.${matches[1]}`, this.locale), matches[2]));
-        return [code.replace(__classPrivateFieldGet(this, _SectorVisibilityCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SectorVisibilityCommand = SectorVisibilityCommand;
-_SectorVisibilityCommand_regex = new WeakMap();
-class SmallHailSizeCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SmallHailSizeCommand_regex.set(this, /^GR LESS THAN ((\d )?(\d\/\d)?)/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SmallHailSizeCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SmallHailSizeCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Hail.LesserThan", this.locale), matches[1]));
-        return [code.replace(__classPrivateFieldGet(this, _SmallHailSizeCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SmallHailSizeCommand = SmallHailSizeCommand;
-_SmallHailSizeCommand_regex = new WeakMap();
-class SnowDepthCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SnowDepthCommand_regex.set(this, /^4\/(\d{3})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SnowDepthCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SnowDepthCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Snow.Depth", this.locale), +matches[1]));
-        return [code.replace(__classPrivateFieldGet(this, _SnowDepthCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SnowDepthCommand = SnowDepthCommand;
-_SnowDepthCommand_regex = new WeakMap();
-class SnowIncreaseCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SnowIncreaseCommand_regex.set(this, /^SNINCR (\d+)\/(\d+)/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SnowIncreaseCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SnowIncreaseCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Snow.Increasing.Rapidly", this.locale), matches[1], matches[2]));
-        return [code.replace(__classPrivateFieldGet(this, _SnowIncreaseCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SnowIncreaseCommand = SnowIncreaseCommand;
-_SnowIncreaseCommand_regex = new WeakMap();
-class SnowPelletsCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SnowPelletsCommand_regex.set(this, /^GS (LGT|MOD|HVY)/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SnowPelletsCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SnowPelletsCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Snow.Pellets", this.locale), (0, i18n_1._)(`Remark.${matches[1]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _SnowPelletsCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SnowPelletsCommand = SnowPelletsCommand;
-_SnowPelletsCommand_regex = new WeakMap();
-class SunshineDurationCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SunshineDurationCommand_regex.set(this, /^98(\d{3})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SunshineDurationCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SunshineDurationCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Sunshine.Duration", this.locale), +matches[1]));
-        return [code.replace(__classPrivateFieldGet(this, _SunshineDurationCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SunshineDurationCommand = SunshineDurationCommand;
-_SunshineDurationCommand_regex = new WeakMap();
-class SurfaceVisibilityCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _SurfaceVisibilityCommand_regex.set(this, /^SFC VIS ((\d)*( )?(\d?\/?\d))/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _SurfaceVisibilityCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _SurfaceVisibilityCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Surface.Visibility", this.locale), matches[1]));
-        return [code.replace(__classPrivateFieldGet(this, _SurfaceVisibilityCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.SurfaceVisibilityCommand = SurfaceVisibilityCommand;
-_SurfaceVisibilityCommand_regex = new WeakMap();
-class ThunderStormLocationCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _ThunderStormLocationCommand_regex.set(this, /^TS ([A-Z]{2})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _ThunderStormLocationCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _ThunderStormLocationCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Thunderstorm.Location.0", this.locale), (0, i18n_1._)(`Converter.${matches[1]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _ThunderStormLocationCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.ThunderStormLocationCommand = ThunderStormLocationCommand;
-_ThunderStormLocationCommand_regex = new WeakMap();
-class ThunderStormLocationMovingCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _ThunderStormLocationMovingCommand_regex.set(this, /^TS ([A-Z]{2}) MOV ([A-Z]{2})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _ThunderStormLocationMovingCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _ThunderStormLocationMovingCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Thunderstorm.Location.Moving", this.locale), (0, i18n_1._)(`Converter.${matches[1]}`, this.locale), (0, i18n_1._)(`Converter.${matches[2]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _ThunderStormLocationMovingCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.ThunderStormLocationMovingCommand = ThunderStormLocationMovingCommand;
-_ThunderStormLocationMovingCommand_regex = new WeakMap();
-class TornadicActivityBegCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _TornadicActivityBegCommand_regex.set(this, /^(TORNADO|FUNNEL CLOUD|WATERSPOUT) (B(\d{2})?(\d{2}))( (\d+)? ([A-Z]{1,2})?)?/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _TornadicActivityBegCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _TornadicActivityBegCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Tornadic.Activity.Beginning", this.locale), (0, i18n_1._)(`Remark.${matches[1].replace(" ", "")}`, this.locale), matches[3] || "", matches[4], matches[6], (0, i18n_1._)(`Converter.${matches[7]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _TornadicActivityBegCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.TornadicActivityBegCommand = TornadicActivityBegCommand;
-_TornadicActivityBegCommand_regex = new WeakMap();
-class TornadicActivityBegEndCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _TornadicActivityBegEndCommand_regex.set(this, /^(TORNADO|FUNNEL CLOUD|WATERSPOUT) (B(\d{2})?(\d{2}))(E(\d{2})?(\d{2}))( (\d+)? ([A-Z]{1,2})?)?/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _TornadicActivityBegEndCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _TornadicActivityBegEndCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Tornadic.Activity.BegEnd", this.locale), (0, i18n_1._)(`Remark.${matches[1].replace(" ", "")}`, this.locale), matches[3] || "", matches[4], matches[6] || "", matches[7], matches[9], (0, i18n_1._)(`Converter.${matches[10]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _TornadicActivityBegEndCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.TornadicActivityBegEndCommand = TornadicActivityBegEndCommand;
-_TornadicActivityBegEndCommand_regex = new WeakMap();
-class TornadicActivityEndCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _TornadicActivityEndCommand_regex.set(this, /^(TORNADO|FUNNEL CLOUD|WATERSPOUT) (E(\d{2})?(\d{2}))( (\d+)? ([A-Z]{1,2})?)?/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _TornadicActivityEndCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _TornadicActivityEndCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Tornadic.Activity.Ending", this.locale), (0, i18n_1._)(`Remark.${matches[1].replace(" ", "")}`, this.locale), matches[3] || "", matches[4], matches[6], (0, i18n_1._)(`Converter.${matches[7]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _TornadicActivityEndCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.TornadicActivityEndCommand = TornadicActivityEndCommand;
-_TornadicActivityEndCommand_regex = new WeakMap();
-class TowerVisibilityCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _TowerVisibilityCommand_regex.set(this, /^TWR VIS ((\d)*( )?(\d?\/?\d))/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _TowerVisibilityCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _TowerVisibilityCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Tower.Visibility", this.locale), matches[1]));
-        return [code.replace(__classPrivateFieldGet(this, _TowerVisibilityCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.TowerVisibilityCommand = TowerVisibilityCommand;
-_TowerVisibilityCommand_regex = new WeakMap();
-class VariableSkyCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _VariableSkyCommand_regex.set(this, /^([A-Z]{3}) V ([A-Z]{3})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _VariableSkyCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _VariableSkyCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Variable.Sky.Condition.0", this.locale), (0, i18n_1._)(`CloudQuantity.${matches[1]}`, this.locale), (0, i18n_1._)(`CloudQuantity.${matches[2]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _VariableSkyCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.VariableSkyCommand = VariableSkyCommand;
-_VariableSkyCommand_regex = new WeakMap();
-class VariableSkyHeightCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _VariableSkyHeightCommand_regex.set(this, /^([A-Z]{3})(\d{3}) V ([A-Z]{3})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _VariableSkyHeightCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _VariableSkyHeightCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Variable.Sky.Condition.Height", this.locale), 100 * +matches[2], (0, i18n_1._)(`CloudQuantity.${matches[1]}`, this.locale), (0, i18n_1._)(`CloudQuantity.${matches[3]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _VariableSkyHeightCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.VariableSkyHeightCommand = VariableSkyHeightCommand;
-_VariableSkyHeightCommand_regex = new WeakMap();
-class VirgaDirectionCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _VirgaDirectionCommand_regex.set(this, /^VIRGA ([A-Z]{2})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _VirgaDirectionCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _VirgaDirectionCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Virga.Direction", this.locale), (0, i18n_1._)(`Converter.${matches[1]}`, this.locale)));
-        return [code.replace(__classPrivateFieldGet(this, _VirgaDirectionCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.VirgaDirectionCommand = VirgaDirectionCommand;
-_VirgaDirectionCommand_regex = new WeakMap();
-class WaterEquivalentSnowCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _WaterEquivalentSnowCommand_regex.set(this, /^933(\d{3})\b/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _WaterEquivalentSnowCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _WaterEquivalentSnowCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.Water.Equivalent.Snow.Ground", this.locale), +matches[1] / 10));
-        return [code.replace(__classPrivateFieldGet(this, _WaterEquivalentSnowCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.WaterEquivalentSnowCommand = WaterEquivalentSnowCommand;
-_WaterEquivalentSnowCommand_regex = new WeakMap();
-class WindPeakCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _WindPeakCommand_regex.set(this, /^PK WND (\d{3})(\d{2,3})\/(\d{2})?(\d{2})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _WindPeakCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _WindPeakCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.PeakWind", this.locale), matches[1], matches[2], matches[3] || "", matches[4]));
-        return [code.replace(__classPrivateFieldGet(this, _WindPeakCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.WindPeakCommand = WindPeakCommand;
-_WindPeakCommand_regex = new WeakMap();
-class WindShiftCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _WindShiftCommand_regex.set(this, /^WSHFT (\d{2})?(\d{2})/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _WindShiftCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _WindShiftCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.WindShift.0", this.locale), matches[1] || "", matches[2]));
-        return [code.replace(__classPrivateFieldGet(this, _WindShiftCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.WindShiftCommand = WindShiftCommand;
-_WindShiftCommand_regex = new WeakMap();
-class WindShiftFropaCommand extends Command {
-    constructor() {
-        super(...arguments);
-        _WindShiftFropaCommand_regex.set(this, /^WSHFT (\d{2})?(\d{2}) FROPA/);
-    }
-    canParse(code) {
-        return __classPrivateFieldGet(this, _WindShiftFropaCommand_regex, "f").test(code);
-    }
-    execute(code, remark) {
-        const matches = code.match(__classPrivateFieldGet(this, _WindShiftFropaCommand_regex, "f"));
-        if (!matches)
-            throw new errors_1.UnexpectedParseError("Match not found");
-        remark.push((0, i18n_1.format)((0, i18n_1._)("Remark.WindShift.FROPA", this.locale), matches[1] || "", matches[2]));
-        return [code.replace(__classPrivateFieldGet(this, _WindShiftFropaCommand_regex, "f"), "").trim(), remark];
-    }
-}
-exports.WindShiftFropaCommand = WindShiftFropaCommand;
-_WindShiftFropaCommand_regex = new WeakMap();
-class DefaultCommand extends Command {
-    canParse() {
-        return true;
-    }
-    execute(code, remark) {
-        const rmkSplit = (0, helpers_1.pySplit)(code, " ", 1);
-        try {
-            const rem = (0, i18n_1._)(`Remark.${rmkSplit[0]}`, this.locale);
-            remark.push(rem);
-        }
-        catch (error) {
-            if (!(error instanceof errors_1.TranslationError))
-                throw error;
-            remark.push(rmkSplit[0]);
-        }
-        return [rmkSplit.length === 1 ? "" : rmkSplit[1], remark];
-    }
-}
-exports.DefaultCommand = DefaultCommand;
+exports.RemarkType = exports.RemarkCommandSupplier = void 0;
+const CeilingHeightCommand_1 = require("./remark/CeilingHeightCommand");
+const CeilingSecondLocationCommand_1 = require("./remark/CeilingSecondLocationCommand");
+const HailSizeCommand_1 = require("./remark/HailSizeCommand");
+const HourlyMaximumMinimumTemperatureCommand_1 = require("./remark/HourlyMaximumMinimumTemperatureCommand");
+const HourlyMaximumTemperatureCommand_1 = require("./remark/HourlyMaximumTemperatureCommand");
+const HourlyMinimumTemperatureCommand_1 = require("./remark/HourlyMinimumTemperatureCommand");
+const HourlyPrecipitationAmountCommand_1 = require("./remark/HourlyPrecipitationAmountCommand");
+const HourlyPressureCommand_1 = require("./remark/HourlyPressureCommand");
+const HourlyTemperatureDewPointCommand_1 = require("./remark/HourlyTemperatureDewPointCommand");
+const IceAccretionCommand_1 = require("./remark/IceAccretionCommand");
+const ObscurationCommand_1 = require("./remark/ObscurationCommand");
+const PrecipitationAmount24HourCommand_1 = require("./remark/PrecipitationAmount24HourCommand");
+const PrecipitationAmount36HourCommand_1 = require("./remark/PrecipitationAmount36HourCommand");
+const PrecipitationBegEndCommand_1 = require("./remark/PrecipitationBegEndCommand");
+const PrevailingVisibilityCommand_1 = require("./remark/PrevailingVisibilityCommand");
+const SeaLevelPressureCommand_1 = require("./remark/SeaLevelPressureCommand");
+const SecondLocationVisibilityCommand_1 = require("./remark/SecondLocationVisibilityCommand");
+const SectorVisibilityCommand_1 = require("./remark/SectorVisibilityCommand");
+const SmallHailSizeCommand_1 = require("./remark/SmallHailSizeCommand");
+const SnowDepthCommand_1 = require("./remark/SnowDepthCommand");
+const SnowIncreaseCommand_1 = require("./remark/SnowIncreaseCommand");
+const SnowPelletsCommand_1 = require("./remark/SnowPelletsCommand");
+const SunshineDurationCommand_1 = require("./remark/SunshineDurationCommand");
+const SurfaceVisibilityCommand_1 = require("./remark/SurfaceVisibilityCommand");
+const ThunderStormLocationCommand_1 = require("./remark/ThunderStormLocationCommand");
+const ThunderStormLocationMovingCommand_1 = require("./remark/ThunderStormLocationMovingCommand");
+const TornadicActivityBegCommand_1 = require("./remark/TornadicActivityBegCommand");
+const TornadicActivityBegEndCommand_1 = require("./remark/TornadicActivityBegEndCommand");
+const TornadicActivityEndCommand_1 = require("./remark/TornadicActivityEndCommand");
+const TowerVisibilityCommand_1 = require("./remark/TowerVisibilityCommand");
+const VariableSkyCommand_1 = require("./remark/VariableSkyCommand");
+const VariableSkyHeightCommand_1 = require("./remark/VariableSkyHeightCommand");
+const VirgaDirectionCommand_1 = require("./remark/VirgaDirectionCommand");
+const WaterEquivalentSnowCommand_1 = require("./remark/WaterEquivalentSnowCommand");
+const WindPeakCommandCommand_1 = require("./remark/WindPeakCommandCommand");
+const WindShiftCommand_1 = require("./remark/WindShiftCommand");
+const WindShiftFropaCommand_1 = require("./remark/WindShiftFropaCommand");
+const DefaultCommand_1 = require("./remark/DefaultCommand");
+const PrecipitationBegCommand_1 = require("./remark/PrecipitationBegCommand");
+const PrecipitationEndCommand_1 = require("./remark/PrecipitationEndCommand");
 class RemarkCommandSupplier {
     constructor(locale) {
         this.locale = locale;
-        this.defaultCommand = new DefaultCommand(locale);
+        this.defaultCommand = new DefaultCommand_1.DefaultCommand(locale);
         this.commandList = [
-            new WindPeakCommand(locale),
-            new WindShiftFropaCommand(locale),
-            new WindShiftCommand(locale),
-            new TowerVisibilityCommand(locale),
-            new SurfaceVisibilityCommand(locale),
-            new PrevailingVisibilityCommand(locale),
-            new SecondLocationVisibilityCommand(locale),
-            new SectorVisibilityCommand(locale),
-            new TornadicActivityBegEndCommand(locale),
-            new TornadicActivityBegCommand(locale),
-            new TornadicActivityEndCommand(locale),
-            new PrecipitationBegEndCommand(locale),
-            new ThunderStormLocationMovingCommand(locale),
-            new ThunderStormLocationCommand(locale),
-            new SmallHailSizeCommand(locale),
-            new HailSizeCommand(locale),
-            new SnowPelletsCommand(locale),
-            new VirgaDirectionCommand(locale),
-            new CeilingHeightCommand(locale),
-            new ObscurationCommand(locale),
-            new VariableSkyHeightCommand(locale),
-            new VariableSkyCommand(locale),
-            new CeilingSecondLocationCommand(locale),
-            new SeaLevelPressureCommand(locale),
-            new SnowIncreaseCommand(locale),
-            new HourlyMaximumMinimumTemperatureCommand(locale),
-            new HourlyMaximumTemperatureCommand(locale),
-            new HourlyMinimumTemperatureCommand(locale),
-            new HourlyPrecipitationAmountCommand(locale),
-            new HourlyTemperatureDewPointCommand(locale),
-            new HourlyPressureCommand(locale),
-            new IceAccretionCommand(locale),
-            new PrecipitationAmount36HourCommand(locale),
-            new PrecipitationAmount24HourCommand(locale),
-            new SnowDepthCommand(locale),
-            new SunshineDurationCommand(locale),
-            new WaterEquivalentSnowCommand(locale),
+            new WindPeakCommandCommand_1.WindPeakCommand(locale),
+            new WindShiftFropaCommand_1.WindShiftFropaCommand(locale),
+            new WindShiftCommand_1.WindShiftCommand(locale),
+            new TowerVisibilityCommand_1.TowerVisibilityCommand(locale),
+            new SurfaceVisibilityCommand_1.SurfaceVisibilityCommand(locale),
+            new PrevailingVisibilityCommand_1.PrevailingVisibilityCommand(locale),
+            new SecondLocationVisibilityCommand_1.SecondLocationVisibilityCommand(locale),
+            new SectorVisibilityCommand_1.SectorVisibilityCommand(locale),
+            new TornadicActivityBegEndCommand_1.TornadicActivityBegEndCommand(locale),
+            new TornadicActivityBegCommand_1.TornadicActivityBegCommand(locale),
+            new TornadicActivityEndCommand_1.TornadicActivityEndCommand(locale),
+            new PrecipitationBegEndCommand_1.PrecipitationBegEndCommand(locale),
+            new PrecipitationBegCommand_1.PrecipitationBegCommand(locale),
+            new PrecipitationEndCommand_1.PrecipitationEndCommand(locale),
+            new ThunderStormLocationMovingCommand_1.ThunderStormLocationMovingCommand(locale),
+            new ThunderStormLocationCommand_1.ThunderStormLocationCommand(locale),
+            new SmallHailSizeCommand_1.SmallHailSizeCommand(locale),
+            new HailSizeCommand_1.HailSizeCommand(locale),
+            new SnowPelletsCommand_1.SnowPelletsCommand(locale),
+            new VirgaDirectionCommand_1.VirgaDirectionCommand(locale),
+            new CeilingHeightCommand_1.CeilingHeightCommand(locale),
+            new ObscurationCommand_1.ObscurationCommand(locale),
+            new VariableSkyHeightCommand_1.VariableSkyHeightCommand(locale),
+            new VariableSkyCommand_1.VariableSkyCommand(locale),
+            new CeilingSecondLocationCommand_1.CeilingSecondLocationCommand(locale),
+            new SeaLevelPressureCommand_1.SeaLevelPressureCommand(locale),
+            new SnowIncreaseCommand_1.SnowIncreaseCommand(locale),
+            new HourlyMaximumMinimumTemperatureCommand_1.HourlyMaximumMinimumTemperatureCommand(locale),
+            new HourlyMaximumTemperatureCommand_1.HourlyMaximumTemperatureCommand(locale),
+            new HourlyMinimumTemperatureCommand_1.HourlyMinimumTemperatureCommand(locale),
+            new HourlyPrecipitationAmountCommand_1.HourlyPrecipitationAmountCommand(locale),
+            new HourlyTemperatureDewPointCommand_1.HourlyTemperatureDewPointCommand(locale),
+            new HourlyPressureCommand_1.HourlyPressureCommand(locale),
+            new IceAccretionCommand_1.IceAccretionCommand(locale),
+            new PrecipitationAmount36HourCommand_1.PrecipitationAmount36HourCommand(locale),
+            new PrecipitationAmount24HourCommand_1.PrecipitationAmount24HourCommand(locale),
+            new SnowDepthCommand_1.SnowDepthCommand(locale),
+            new SunshineDurationCommand_1.SunshineDurationCommand(locale),
+            new WaterEquivalentSnowCommand_1.WaterEquivalentSnowCommand(locale),
         ];
     }
     get(code) {
@@ -769,3 +97,57 @@ class RemarkCommandSupplier {
     }
 }
 exports.RemarkCommandSupplier = RemarkCommandSupplier;
+var RemarkType;
+(function (RemarkType) {
+    // Unknown processed with default command
+    RemarkType["Unknown"] = "Unknown";
+    // Processed with default command
+    RemarkType["AO1"] = "AO1";
+    RemarkType["AO2"] = "AO2";
+    RemarkType["PRESFR"] = "PRESFR";
+    RemarkType["PRESRR"] = "PRESRR";
+    RemarkType["TORNADO"] = "TORNADO";
+    RemarkType["FUNNELCLOUD"] = "FUNNELCLOUD";
+    RemarkType["WATERSPOUT"] = "WATERSPOUT";
+    RemarkType["VIRGA"] = "VIRGA";
+    // Regular commands below
+    RemarkType["WindPeak"] = "WindPeak";
+    RemarkType["WindShiftFropa"] = "WindShiftFropa";
+    RemarkType["WindShift"] = "WindShift";
+    RemarkType["TowerVisibility"] = "TowerVisibility";
+    RemarkType["SurfaceVisibility"] = "SurfaceVisibility";
+    RemarkType["PrevailingVisibility"] = "PrevailingVisibility";
+    RemarkType["SecondLocationVisibility"] = "SecondLocationVisibility";
+    RemarkType["SectorVisibility"] = "SectorVisibility";
+    RemarkType["TornadicActivityBegEnd"] = "TornadicActivityBegEnd";
+    RemarkType["TornadicActivityBeg"] = "TornadicActivityBeg";
+    RemarkType["TornadicActivityEnd"] = "TornadicActivityEnd";
+    RemarkType["PrecipitationBeg"] = "PrecipitationBeg";
+    RemarkType["PrecipitationBegEnd"] = "PrecipitationBegEnd";
+    RemarkType["PrecipitationEnd"] = "PrecipitationEnd";
+    RemarkType["ThunderStormLocationMoving"] = "ThunderStormLocationMoving";
+    RemarkType["ThunderStormLocation"] = "ThunderStormLocation";
+    RemarkType["SmallHailSize"] = "SmallHailSize";
+    RemarkType["HailSize"] = "HailSize";
+    RemarkType["SnowPellets"] = "SnowPellets";
+    RemarkType["VirgaDirection"] = "VirgaDirection";
+    RemarkType["CeilingHeight"] = "CeilingHeight";
+    RemarkType["Obscuration"] = "Obscuration";
+    RemarkType["VariableSkyHeight"] = "VariableSkyHeight";
+    RemarkType["VariableSky"] = "VariableSky";
+    RemarkType["CeilingSecondLocation"] = "CeilingSecondLocation";
+    RemarkType["SeaLevelPressure"] = "SeaLevelPressure";
+    RemarkType["SnowIncrease"] = "SnowIncrease";
+    RemarkType["HourlyMaximumMinimumTemperature"] = "HourlyMaximumMinimumTemperature";
+    RemarkType["HourlyMaximumTemperature"] = "HourlyMaximumTemperature";
+    RemarkType["HourlyMinimumTemperature"] = "HourlyMinimumTemperature";
+    RemarkType["HourlyPrecipitationAmount"] = "HourlyPrecipitationAmount";
+    RemarkType["HourlyTemperatureDewPoint"] = "HourlyTemperatureDewPoint";
+    RemarkType["HourlyPressure"] = "HourlyPressure";
+    RemarkType["IceAccretion"] = "IceAccretion";
+    RemarkType["PrecipitationAmount36Hour"] = "PrecipitationAmount36Hour";
+    RemarkType["PrecipitationAmount24Hour"] = "PrecipitationAmount24Hour";
+    RemarkType["SnowDepth"] = "SnowDepth";
+    RemarkType["SunshineDuration"] = "SunshineDuration";
+    RemarkType["WaterEquivalentSnow"] = "WaterEquivalentSnow";
+})(RemarkType = exports.RemarkType || (exports.RemarkType = {}));