metar-taf-parser 1.2.0 → 2.0.0

package/dist/command/remark/CeilingSecondLocationCommand.js

@@ -0,0 +1,40 @@
+"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 _CeilingSecondLocationCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CeilingSecondLocationCommand = void 0;
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class CeilingSecondLocationCommand extends Command_1.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;
+        const location = matches[2];
+        const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Ceiling.Second.Location", this.locale), height, location);
+        remark.push({
+            type: remark_1.RemarkType.CeilingSecondLocation,
+            description,
+            raw: matches[0],
+            height,
+            location,
+        });
+        return [code.replace(__classPrivateFieldGet(this, _CeilingSecondLocationCommand_regex, "f"), "").trim(), remark];
+    }
+}
+exports.CeilingSecondLocationCommand = CeilingSecondLocationCommand;
+_CeilingSecondLocationCommand_regex = new WeakMap();

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

@@ -0,0 +1,8 @@
+import { Locale } from "../../commons/i18n";
+import { Remark } from "../remark";
+export declare abstract class Command {
+    protected locale: Locale;
+    constructor(locale: Locale);
+    abstract canParse(code: string): boolean;
+    abstract execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/Command.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Command = void 0;
+class Command {
+    constructor(locale) {
+        this.locale = locale;
+    }
+}
+exports.Command = Command;

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

@@ -0,0 +1,11 @@
+import { IBaseRemark, Remark, RemarkType } from "../remark";
+import { Command } from "./Command";
+declare type DefaultRemarkTypes = RemarkType.AO1 | RemarkType.AO2 | RemarkType.PRESFR | RemarkType.PRESRR | RemarkType.TORNADO | RemarkType.FUNNELCLOUD | RemarkType.WATERSPOUT | RemarkType.VIRGA;
+export interface IDefaultCommandRemark extends IBaseRemark {
+    type: DefaultRemarkTypes;
+}
+export declare class DefaultCommand extends Command {
+    canParse(): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}
+export {};

package/dist/command/remark/DefaultCommand.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultCommand = void 0;
+const helpers_1 = require("../../helpers/helpers");
+const i18n_1 = require("../../commons/i18n");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class DefaultCommand extends Command_1.Command {
+    canParse() {
+        return true;
+    }
+    execute(code, remark) {
+        const rmkSplit = (0, helpers_1.pySplit)(code, " ", 1);
+        const rem = (0, i18n_1._)(`Remark.${rmkSplit[0]}`, this.locale);
+        if (remark_1.RemarkType[rmkSplit[0]]) {
+            remark.push({
+                type: rmkSplit[0],
+                description: rem,
+                raw: rmkSplit[0],
+            });
+        }
+        else {
+            const lastRemark = remark[remark.length - 1];
+            if ((lastRemark === null || lastRemark === void 0 ? void 0 : lastRemark.type) === remark_1.RemarkType.Unknown) {
+                // Merge with last unknown value
+                lastRemark.raw = `${lastRemark.raw} ${rmkSplit[0]}`;
+            }
+            else {
+                remark.push({
+                    type: remark_1.RemarkType.Unknown,
+                    raw: rmkSplit[0],
+                });
+            }
+        }
+        return [rmkSplit.length === 1 ? "" : rmkSplit[1], remark];
+    }
+}
+exports.DefaultCommand = DefaultCommand;

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

@@ -0,0 +1,11 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IHailSizeRemark extends IBaseRemark {
+    type: RemarkType.HailSize;
+    size: string;
+}
+export declare class HailSizeCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/HailSizeCommand.js

@@ -0,0 +1,37 @@
+"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 _HailSizeCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HailSizeCommand = void 0;
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class HailSizeCommand extends Command_1.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");
+        const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Hail.0", this.locale), matches[1]);
+        remark.push({
+            type: remark_1.RemarkType.HailSize,
+            description,
+            raw: matches[0],
+            size: matches[1],
+        });
+        return [code.replace(__classPrivateFieldGet(this, _HailSizeCommand_regex, "f"), "").trim(), remark];
+    }
+}
+exports.HailSizeCommand = HailSizeCommand;
+_HailSizeCommand_regex = new WeakMap();

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

@@ -0,0 +1,18 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IHourlyMaximumMinimumTemperatureRemark extends IBaseRemark {
+    type: RemarkType.HourlyMaximumMinimumTemperature;
+    /**
+     * Maximum temperature in C
+     */
+    max: number;
+    /**
+     * Minimum temperature in C
+     */
+    min: number;
+}
+export declare class HourlyMaximumMinimumTemperatureCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/HourlyMaximumMinimumTemperatureCommand.js

@@ -0,0 +1,39 @@
+"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 _HourlyMaximumMinimumTemperatureCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HourlyMaximumMinimumTemperatureCommand = void 0;
+const converter_1 = require("../../commons/converter");
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class HourlyMaximumMinimumTemperatureCommand extends Command_1.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");
+        const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Maximum.Minimum.Temperature", this.locale), (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2]).toFixed(1), (0, converter_1.convertTemperatureRemarks)(matches[3], matches[4]).toFixed(1));
+        remark.push({
+            type: remark_1.RemarkType.HourlyMaximumMinimumTemperature,
+            description: description,
+            raw: matches[0],
+            max: (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2]),
+            min: (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();

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

@@ -0,0 +1,14 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IHourlyMaximumTemperatureRemark extends IBaseRemark {
+    type: RemarkType.HourlyMaximumTemperature;
+    /**
+     * Maximum temperature in C
+     */
+    max: number;
+}
+export declare class HourlyMaximumTemperatureCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/HourlyMaximumTemperatureCommand.js

@@ -0,0 +1,38 @@
+"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 _HourlyMaximumTemperatureCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HourlyMaximumTemperatureCommand = void 0;
+const converter_1 = require("../../commons/converter");
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class HourlyMaximumTemperatureCommand extends Command_1.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");
+        const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Maximum.Temperature", this.locale), (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2]).toFixed(1));
+        remark.push({
+            type: remark_1.RemarkType.HourlyMaximumTemperature,
+            description: description,
+            raw: matches[0],
+            max: (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();

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

@@ -0,0 +1,14 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IHourlyMinimumTemperatureRemark extends IBaseRemark {
+    type: RemarkType.HourlyMinimumTemperature;
+    /**
+     * Minimum temperature in C
+     */
+    min: number;
+}
+export declare class HourlyMinimumTemperatureCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/HourlyMinimumTemperatureCommand.js

@@ -0,0 +1,38 @@
+"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 _HourlyMinimumTemperatureCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HourlyMinimumTemperatureCommand = void 0;
+const converter_1 = require("../../commons/converter");
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class HourlyMinimumTemperatureCommand extends Command_1.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");
+        const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Minimum.Temperature", this.locale), (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2]).toFixed(1));
+        remark.push({
+            type: remark_1.RemarkType.HourlyMinimumTemperature,
+            description,
+            raw: matches[0],
+            min: (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();

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

@@ -0,0 +1,14 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IHourlyPrecipitationAmountRemark extends IBaseRemark {
+    type: RemarkType.HourlyPrecipitationAmount;
+    /**
+     * In inches
+     */
+    amount: number;
+}
+export declare class HourlyPrecipitationAmountCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/HourlyPrecipitationAmountCommand.js

@@ -0,0 +1,38 @@
+"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 _HourlyPrecipitationAmountCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HourlyPrecipitationAmountCommand = void 0;
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class HourlyPrecipitationAmountCommand extends Command_1.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");
+        const amount = +matches[1];
+        const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Precipitation.Amount.Hourly", this.locale), amount);
+        remark.push({
+            type: remark_1.RemarkType.HourlyPrecipitationAmount,
+            description,
+            raw: matches[0],
+            amount: amount / 100,
+        });
+        return [code.replace(__classPrivateFieldGet(this, _HourlyPrecipitationAmountCommand_regex, "f"), "").trim(), remark];
+    }
+}
+exports.HourlyPrecipitationAmountCommand = HourlyPrecipitationAmountCommand;
+_HourlyPrecipitationAmountCommand_regex = new WeakMap();

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

@@ -0,0 +1,32 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IHourlyPressureRemark extends IBaseRemark {
+    type: RemarkType.HourlyPressure;
+    /**
+     * https://www.e-education.psu.edu/files/meteo101/image/Section13/metar_decoding1203.html
+     *
+     * | Code Figure |                                     Description                                    |                        Primary Requirement                        |
+     * |:-----------:|:----------------------------------------------------------------------------------:|:-----------------------------------------------------------------:|
+     * |      0      | Increasing, then decreasing.                                                       | Atmospheric pressure now higher than 3 hours ago. (x3 rows below) |
+     * |      1      | Increasing, then steady, or increasing then increasing more slowly.                |                                                                   |
+     * |      2      | Increasing steadily or unsteadily.                                                 |                                                                   |
+     * |      3      | Decreasing or steady, then increasing; or increasing then increasing more rapidly. |                                                                   |
+     * |      0      | Increasing, then decreasing.                                                       | Atmospheric pressure now same as 3 hours ago. (x3 rows below)     |
+     * |      4      | Steady                                                                             |                                                                   |
+     * |      5      | Decreasing then increasing.                                                        |                                                                   |
+     * |      5      | Decreasing, then increasing.                                                       | Atmospheric pressure now lower than 3 hours ago. (x3 rows below)  |
+     * |      6      | Decreasing, then steady, or decreasing then decreasing more slowly.                |                                                                   |
+     * |      7      | Decreasing steadily or unsteadily.                                                 |                                                                   |
+     * |      8      | Steady or increasing, then decreasing; or decreasing then decreasing more rapidly. |                                                                   |
+     */
+    code: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+    /**
+     * In hectopascals
+     */
+    pressureChange: number;
+}
+export declare class HourlyPressureCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/HourlyPressureCommand.js

@@ -0,0 +1,40 @@
+"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 _HourlyPressureCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HourlyPressureCommand = void 0;
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class HourlyPressureCommand extends Command_1.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");
+        const part1 = (0, i18n_1._)(`Remark.Barometer.${+matches[1]}`, this.locale);
+        const part2 = (0, i18n_1.format)((0, i18n_1._)("Remark.Pressure.Tendency", this.locale), +matches[2] / 10);
+        const description = part1 != null && part2 != null ? `${part1} ${part2}` : undefined;
+        remark.push({
+            type: remark_1.RemarkType.HourlyPressure,
+            description,
+            raw: matches[0],
+            code: +matches[1],
+            pressureChange: +matches[2] / 10,
+        });
+        return [code.replace(__classPrivateFieldGet(this, _HourlyPressureCommand_regex, "f"), "").trim(), remark];
+    }
+}
+exports.HourlyPressureCommand = HourlyPressureCommand;
+_HourlyPressureCommand_regex = new WeakMap();

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

@@ -0,0 +1,18 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IHourlyTemperatureDewPointRemark extends IBaseRemark {
+    type: RemarkType.HourlyTemperatureDewPoint;
+    /**
+     * In C
+     */
+    temperature: number;
+    /**
+     * In C
+     */
+    dewPoint?: number;
+}
+export declare class HourlyTemperatureDewPointCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/HourlyTemperatureDewPointCommand.js

@@ -0,0 +1,52 @@
+"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 _HourlyTemperatureDewPointCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HourlyTemperatureDewPointCommand = void 0;
+const converter_1 = require("../../commons/converter");
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class HourlyTemperatureDewPointCommand extends Command_1.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");
+        const temperature = (0, converter_1.convertTemperatureRemarks)(matches[1], matches[2]);
+        if (!matches[3]) {
+            const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Temperature.0", this.locale), temperature.toFixed(1));
+            remark.push({
+                type: remark_1.RemarkType.HourlyTemperatureDewPoint,
+                description,
+                raw: matches[0],
+                temperature,
+            });
+        }
+        else {
+            const dewPoint = (0, converter_1.convertTemperatureRemarks)(matches[4], matches[5]);
+            const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Hourly.Temperature.Dew.Point", this.locale), temperature.toFixed(1), dewPoint.toFixed(1));
+            remark.push({
+                type: remark_1.RemarkType.HourlyTemperatureDewPoint,
+                description,
+                raw: matches[0],
+                temperature,
+                dewPoint,
+            });
+        }
+        return [code.replace(__classPrivateFieldGet(this, _HourlyTemperatureDewPointCommand_regex, "f"), "").trim(), remark];
+    }
+}
+exports.HourlyTemperatureDewPointCommand = HourlyTemperatureDewPointCommand;
+_HourlyTemperatureDewPointCommand_regex = new WeakMap();

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

@@ -0,0 +1,15 @@
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IIceAccretionRemark extends IBaseRemark {
+    type: RemarkType.IceAccretion;
+    /**
+     * In inches
+     */
+    amount: number;
+    periodInHours: number;
+}
+export declare class IceAccretionCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}

package/dist/command/remark/IceAccretionCommand.js

@@ -0,0 +1,38 @@
+"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 _IceAccretionCommand_regex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IceAccretionCommand = void 0;
+const i18n_1 = require("../../commons/i18n");
+const errors_1 = require("../../commons/errors");
+const remark_1 = require("../remark");
+const Command_1 = require("./Command");
+class IceAccretionCommand extends Command_1.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");
+        const description = (0, i18n_1.format)((0, i18n_1._)("Remark.Ice.Accretion.Amount", this.locale), +matches[2], +matches[1]);
+        remark.push({
+            type: remark_1.RemarkType.IceAccretion,
+            description,
+            raw: matches[0],
+            amount: +matches[2] / 100,
+            periodInHours: +matches[1],
+        });
+        return [code.replace(__classPrivateFieldGet(this, _IceAccretionCommand_regex, "f"), "").trim(), remark];
+    }
+}
+exports.IceAccretionCommand = IceAccretionCommand;
+_IceAccretionCommand_regex = new WeakMap();

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

@@ -0,0 +1,14 @@
+import { CloudQuantity, Phenomenon } from "../../model/enum";
+import { IBaseRemark, RemarkType, Remark } from "../remark";
+import { Command } from "./Command";
+export interface IObscurationRemark extends IBaseRemark {
+    type: RemarkType.Obscuration;
+    quantity: CloudQuantity;
+    height: number;
+    phenomenon: Phenomenon;
+}
+export declare class ObscurationCommand extends Command {
+    #private;
+    canParse(code: string): boolean;
+    execute(code: string, remark: Remark[]): [string, Remark[]];
+}