chrono-node 2.6.2 → 2.6.3

package/src/common/refiners/AbstractMergeDateRangeRefiner.ts

@@ -16,13 +16,13 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
         if (!fromResult.start.isOnlyWeekdayComponent() && !toResult.start.isOnlyWeekdayComponent()) {
             toResult.start.getCertainComponents().forEach((key) => {
                 if (!fromResult.start.isCertain(key)) {
-                    fromResult.start.assign(key, toResult.start.get(key));
+                    fromResult.start.imply(key, toResult.start.get(key));
                 }
             });
 
             fromResult.start.getCertainComponents().forEach((key) => {
                 if (!toResult.start.isCertain(key)) {
-                    toResult.start.assign(key, fromResult.start.get(key));
+                    toResult.start.imply(key, fromResult.start.get(key));
                 }
             });
         }
@@ -30,17 +30,22 @@ export default abstract class AbstractMergeDateRangeRefiner extends MergingRefin
         if (fromResult.start.date().getTime() > toResult.start.date().getTime()) {
             let fromMoment = fromResult.start.dayjs();
             let toMoment = toResult.start.dayjs();
-
-            if (fromResult.start.isOnlyWeekdayComponent() && fromMoment.add(-7, "days").isBefore(toMoment)) {
+            if (toResult.start.isOnlyWeekdayComponent() && toMoment.add(7, "days").isAfter(fromMoment)) {
+                toMoment = toMoment.add(7, "days");
+                toResult.start.imply("day", toMoment.date());
+                toResult.start.imply("month", toMoment.month() + 1);
+                toResult.start.imply("year", toMoment.year());
+            } else if (fromResult.start.isOnlyWeekdayComponent() && fromMoment.add(-7, "days").isBefore(toMoment)) {
                 fromMoment = fromMoment.add(-7, "days");
                 fromResult.start.imply("day", fromMoment.date());
                 fromResult.start.imply("month", fromMoment.month() + 1);
                 fromResult.start.imply("year", fromMoment.year());
-            } else if (toResult.start.isOnlyWeekdayComponent() && toMoment.add(7, "days").isAfter(fromMoment)) {
-                toMoment = toMoment.add(7, "days");
-                toResult.start.imply("day", toMoment.date());
-                toResult.start.imply("month", toMoment.month() + 1);
+            } else if (toResult.start.isDateWithUnknownYear() && toMoment.add(1, "years").isAfter(fromMoment)) {
+                toMoment = toMoment.add(1, "years");
                 toResult.start.imply("year", toMoment.year());
+            } else if (fromResult.start.isDateWithUnknownYear() && fromMoment.add(-1, "years").isBefore(toMoment)) {
+                fromMoment = fromMoment.add(-1, "years");
+                fromResult.start.imply("year", fromMoment.year());
             } else {
                 [toResult, fromResult] = [fromResult, toResult];
             }

package/src/common/refiners/ExtractTimezoneAbbrRefiner.ts

@@ -1,208 +1,13 @@
 // Map ABBR -> Offset in minute
 import { ParsingContext, Refiner } from "../../chrono";
+import { TimezoneAbbrMap } from "../../index";
 import { ParsingResult } from "../../results";
+import { toTimezoneOffset } from "../../timezone";
 
 const TIMEZONE_NAME_PATTERN = new RegExp("^\\s*,?\\s*\\(?([A-Z]{2,4})\\)?(?=\\W|$)", "i");
-const DEFAULT_TIMEZONE_ABBR_MAP = {
-    ACDT: 630,
-    ACST: 570,
-    ADT: -180,
-    AEDT: 660,
-    AEST: 600,
-    AFT: 270,
-    AKDT: -480,
-    AKST: -540,
-    ALMT: 360,
-    AMST: -180,
-    AMT: -240,
-    ANAST: 720,
-    ANAT: 720,
-    AQTT: 300,
-    ART: -180,
-    AST: -240,
-    AWDT: 540,
-    AWST: 480,
-    AZOST: 0,
-    AZOT: -60,
-    AZST: 300,
-    AZT: 240,
-    BNT: 480,
-    BOT: -240,
-    BRST: -120,
-    BRT: -180,
-    BST: 60,
-    BTT: 360,
-    CAST: 480,
-    CAT: 120,
-    CCT: 390,
-    CDT: -300,
-    CEST: 120,
-    CET: 60,
-    CHADT: 825,
-    CHAST: 765,
-    CKT: -600,
-    CLST: -180,
-    CLT: -240,
-    COT: -300,
-    CST: -360,
-    CVT: -60,
-    CXT: 420,
-    ChST: 600,
-    DAVT: 420,
-    EASST: -300,
-    EAST: -360,
-    EAT: 180,
-    ECT: -300,
-    EDT: -240,
-    EEST: 180,
-    EET: 120,
-    EGST: 0,
-    EGT: -60,
-    EST: -300,
-    ET: -300,
-    FJST: 780,
-    FJT: 720,
-    FKST: -180,
-    FKT: -240,
-    FNT: -120,
-    GALT: -360,
-    GAMT: -540,
-    GET: 240,
-    GFT: -180,
-    GILT: 720,
-    GMT: 0,
-    GST: 240,
-    GYT: -240,
-    HAA: -180,
-    HAC: -300,
-    HADT: -540,
-    HAE: -240,
-    HAP: -420,
-    HAR: -360,
-    HAST: -600,
-    HAT: -90,
-    HAY: -480,
-    HKT: 480,
-    HLV: -210,
-    HNA: -240,
-    HNC: -360,
-    HNE: -300,
-    HNP: -480,
-    HNR: -420,
-    HNT: -150,
-    HNY: -540,
-    HOVT: 420,
-    ICT: 420,
-    IDT: 180,
-    IOT: 360,
-    IRDT: 270,
-    IRKST: 540,
-    IRKT: 540,
-    IRST: 210,
-    IST: 330,
-    JST: 540,
-    KGT: 360,
-    KRAST: 480,
-    KRAT: 480,
-    KST: 540,
-    KUYT: 240,
-    LHDT: 660,
-    LHST: 630,
-    LINT: 840,
-    MAGST: 720,
-    MAGT: 720,
-    MART: -510,
-    MAWT: 300,
-    MDT: -360,
-    MESZ: 120,
-    MEZ: 60,
-    MHT: 720,
-    MMT: 390,
-    MSD: 240,
-    MSK: 240,
-    MST: -420,
-    MUT: 240,
-    MVT: 300,
-    MYT: 480,
-    NCT: 660,
-    NDT: -90,
-    NFT: 690,
-    NOVST: 420,
-    NOVT: 360,
-    NPT: 345,
-    NST: -150,
-    NUT: -660,
-    NZDT: 780,
-    NZST: 720,
-    OMSST: 420,
-    OMST: 420,
-    PDT: -420,
-    PET: -300,
-    PETST: 720,
-    PETT: 720,
-    PGT: 600,
-    PHOT: 780,
-    PHT: 480,
-    PKT: 300,
-    PMDT: -120,
-    PMST: -180,
-    PONT: 660,
-    PST: -480,
-    PT: -480,
-    PWT: 540,
-    PYST: -180,
-    PYT: -240,
-    RET: 240,
-    SAMT: 240,
-    SAST: 120,
-    SBT: 660,
-    SCT: 240,
-    SGT: 480,
-    SRT: -180,
-    SST: -660,
-    TAHT: -600,
-    TFT: 300,
-    TJT: 300,
-    TKT: 780,
-    TLT: 540,
-    TMT: 300,
-    TVT: 720,
-    ULAT: 480,
-    UTC: 0,
-    UYST: -120,
-    UYT: -180,
-    UZT: 300,
-    VET: -210,
-    VLAST: 660,
-    VLAT: 660,
-    VUT: 660,
-    WAST: 120,
-    WAT: 60,
-    WEST: 60,
-    WESZ: 60,
-    WET: 0,
-    WEZ: 0,
-    WFT: 720,
-    WGST: -120,
-    WGT: -180,
-    WIB: 420,
-    WIT: 540,
-    WITA: 480,
-    WST: 780,
-    WT: 0,
-    YAKST: 600,
-    YAKT: 600,
-    YAPT: 600,
-    YEKST: 360,
-    YEKT: 360,
-};
 
 export default class ExtractTimezoneAbbrRefiner implements Refiner {
-    private readonly timezone: { string: number };
-
-    constructor(timezoneOverrides?: { string: number }) {
-        this.timezone = { ...DEFAULT_TIMEZONE_ABBR_MAP, ...timezoneOverrides };
-    }
+    constructor(private readonly timezoneOverrides?: TimezoneAbbrMap) {}
 
     refine(context: ParsingContext, results: ParsingResult[]): ParsingResult[] {
         const timezoneOverrides = context.option.timezones ?? {};
@@ -215,11 +20,12 @@ export default class ExtractTimezoneAbbrRefiner implements Refiner {
             }
 
             const timezoneAbbr = match[1].toUpperCase();
-            const extractedTimezoneOffset = timezoneOverrides[timezoneAbbr] ?? this.timezone[timezoneAbbr] ?? null;
-            if (extractedTimezoneOffset === null) {
+            const refDate = result.start.date() ?? result.refDate ?? new Date();
+            const tzOverrides = { ...this.timezoneOverrides, ...timezoneOverrides };
+            const extractedTimezoneOffset = toTimezoneOffset(timezoneAbbr, refDate, tzOverrides);
+            if (extractedTimezoneOffset == null) {
                 return;
             }
-
             context.debug(() => {
                 console.log(
                     `Extracting timezone: '${timezoneAbbr}' into: ${extractedTimezoneOffset} for: ${result.start}`

package/src/common/refiners/ForwardDateRefiner.ts

@@ -30,22 +30,6 @@ export default class ForwardDateRefiner implements Refiner {
                 }
             }
 
-            if (result.start.isOnlyDayMonthComponent() && refMoment.isAfter(result.start.dayjs())) {
-                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
-                    result.start.imply("year", result.start.get("year") + 1);
-                    context.debug(() => {
-                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
-                    });
-
-                    if (result.end && !result.end.isCertain("year")) {
-                        result.end.imply("year", result.end.get("year") + 1);
-                        context.debug(() => {
-                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
-                        });
-                    }
-                }
-            }
-
             if (result.start.isOnlyWeekdayComponent() && refMoment.isAfter(result.start.dayjs())) {
                 if (refMoment.day() >= result.start.get("weekday")) {
                     refMoment = refMoment.day(result.start.get("weekday") + 7);
@@ -76,6 +60,24 @@ export default class ForwardDateRefiner implements Refiner {
                     });
                 }
             }
+
+            // In case where we know the month, but not which year (e.g. "in December", "25th December"),
+            // try move to another year
+            if (result.start.isDateWithUnknownYear() && refMoment.isAfter(result.start.dayjs())) {
+                for (let i = 0; i < 3 && refMoment.isAfter(result.start.dayjs()); i++) {
+                    result.start.imply("year", result.start.get("year") + 1);
+                    context.debug(() => {
+                        console.log(`Forward yearly adjusted for ${result} (${result.start})`);
+                    });
+
+                    if (result.end && !result.end.isCertain("year")) {
+                        result.end.imply("year", result.end.get("year") + 1);
+                        context.debug(() => {
+                            console.log(`Forward yearly adjusted for ${result} (${result.end})`);
+                        });
+                    }
+                }
+            }
         });
 
         return results;

package/src/configurations.ts

@@ -12,10 +12,12 @@ export function includeCommonConfiguration(configuration: Configuration, strictM
     configuration.parsers.unshift(new ISOFormatParser());
 
     configuration.refiners.unshift(new MergeWeekdayComponentRefiner());
-    configuration.refiners.unshift(new ExtractTimezoneAbbrRefiner());
     configuration.refiners.unshift(new ExtractTimezoneOffsetRefiner());
     configuration.refiners.unshift(new OverlapRemovalRefiner());
 
+    // Unlike ExtractTimezoneOffsetRefiner, this refiner relies on knowing both date and time in cases where the tz
+    // is ambiguous (in terms of DST/non-DST). It therefore needs to be applied as late as possible in the parsing.
+    configuration.refiners.push(new ExtractTimezoneAbbrRefiner());
     configuration.refiners.push(new OverlapRemovalRefiner());
     configuration.refiners.push(new ForwardDateRefiner());
     configuration.refiners.push(new UnlikelyFormatFilter(strictMode));

package/src/index.ts

@@ -13,9 +13,10 @@ export interface ParsingOption {
     forwardDate?: boolean;
 
     /**
-     * Additional timezone keywords for the parsers to recognize
+     * Additional timezone keywords for the parsers to recognize.
+     * Any value provided will override the default handling of that value.
      */
-    timezones?: { [tzKeyword: string]: number };
+    timezones?: TimezoneAbbrMap;
 
     /**
      * Internal debug event handler.
@@ -24,6 +25,34 @@ export interface ParsingOption {
     debug?: DebugHandler | DebugConsume;
 }
 
+/**
+ * Some timezone abbreviations are ambiguous in that they refer to different offsets
+ * depending on the time of year — daylight savings time (DST), or non-DST. This interface
+ * allows defining such timezones
+ */
+export interface AmbiguousTimezoneMap {
+    timezoneOffsetDuringDst: number;
+    timezoneOffsetNonDst: number;
+    /**
+     * Return the start date of DST for the given year.
+     * timezone.ts contains helper methods for common such rules.
+     */
+    dstStart: (year: number) => Date;
+    /**
+     * Return the end date of DST for the given year.
+     * timezone.ts contains helper methods for common such rules.
+     */
+    dstEnd: (year: number) => Date;
+}
+
+/**
+ * A map describing how timezone abbreviations should map to time offsets.
+ * Supports both unambigous mappings abbreviation => offset,
+ * and ambiguous mappings, where the offset will depend on whether the
+ * time in question is during daylight savings time or not.
+ */
+export type TimezoneAbbrMap = { [key: string]: number | AmbiguousTimezoneMap };
+
 export interface ParsingReference {
     /**
      * Reference date. The instant (JavaScript Date object) when the input is written or mention.
@@ -110,6 +139,21 @@ export enum Weekday {
     SATURDAY = 6,
 }
 
+export enum Month {
+    JANUARY = 1,
+    FEBRUARY = 2,
+    MARCH = 3,
+    APRIL = 4,
+    MAY = 5,
+    JUNE = 6,
+    JULY = 7,
+    AUGUST = 8,
+    SEPTEMBER = 9,
+    OCTOBER = 10,
+    NOVEMBER = 11,
+    DECEMBER = 12,
+}
+
 // Export all locales
 import * as de from "./locales/de";
 import * as fr from "./locales/fr";

package/src/locales/en/constants.ts

@@ -134,6 +134,25 @@ export const ORDINAL_WORD_DICTIONARY: { [word: string]: number } = {
     "thirty-first": 31,
 };
 
+export const TIME_UNIT_DICTIONARY_NO_ABBR: { [word: string]: OpUnitType | QUnitType } = {
+    second: "second",
+    seconds: "second",
+    minute: "minute",
+    minutes: "minute",
+    hour: "hour",
+    hours: "hour",
+    day: "d",
+    days: "d",
+    week: "week",
+    weeks: "week",
+    month: "month",
+    months: "month",
+    quarter: "quarter",
+    quarters: "quarter",
+    year: "year",
+    years: "year",
+};
+
 export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } = {
     s: "second",
     sec: "second",
@@ -167,6 +186,9 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     yr: "year",
     year: "year",
     years: "year",
+    // Also, merge the entries from the full-name dictionary.
+    // We leave the duplicated entries for readability.
+    ...TIME_UNIT_DICTIONARY_NO_ABBR,
 };
 
 //-----------------------------
@@ -238,7 +260,15 @@ export function parseYear(match: string): number {
 const SINGLE_TIME_UNIT_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(TIME_UNIT_DICTIONARY)})`;
 const SINGLE_TIME_UNIT_REGEX = new RegExp(SINGLE_TIME_UNIT_PATTERN, "i");
 
+const SINGLE_TIME_UNIT_NO_ABBR_PATTERN = `(${NUMBER_PATTERN})\\s{0,3}(${matchAnyPattern(
+    TIME_UNIT_DICTIONARY_NO_ABBR
+)})`;
+
 export const TIME_UNITS_PATTERN = repeatedTimeunitPattern(`(?:(?:about|around)\\s{0,3})?`, SINGLE_TIME_UNIT_PATTERN);
+export const TIME_UNITS_NO_ABBR_PATTERN = repeatedTimeunitPattern(
+    `(?:(?:about|around)\\s{0,3})?`,
+    SINGLE_TIME_UNIT_NO_ABBR_PATTERN
+);
 
 export function parseTimeUnits(timeunitText): TimeUnits {
     const fragments = {};

package/src/locales/en/index.ts

@@ -82,7 +82,7 @@ export function createConfiguration(strictMode = true, littleEndian = false): Co
         {
             parsers: [
                 new SlashDateFormatParser(littleEndian),
-                new ENTimeUnitWithinFormatParser(),
+                new ENTimeUnitWithinFormatParser(strictMode),
                 new ENMonthNameLittleEndianParser(),
                 new ENMonthNameMiddleEndianParser(),
                 new ENWeekdayParser(),

package/src/locales/en/parsers/ENTimeUnitAgoFormatParser.ts

@@ -1,11 +1,11 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
-const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=(?:\\W|$))`, "i");
-const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}ago(?=(?:\\W|$))`, "i");
+const PATTERN = new RegExp(`(${TIME_UNITS_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
+const STRICT_PATTERN = new RegExp(`(${TIME_UNITS_NO_ABBR_PATTERN})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
 
 export default class ENTimeUnitAgoFormatParser extends AbstractParserWithWordBoundaryChecking {
     constructor(private strictMode: boolean) {

package/src/locales/en/parsers/ENTimeUnitCasualRelativeFormatParser.ts

@@ -1,14 +1,22 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { TIME_UNITS_PATTERN, parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 import { reverseTimeUnits } from "../../../utils/timeunits";
 
 const PATTERN = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_PATTERN})(?=\\W|$)`, "i");
+const PATTERN_NO_ABBR = new RegExp(
+    `(this|last|past|next|after|\\+|-)\\s*(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`,
+    "i"
+);
 
 export default class ENTimeUnitCasualRelativeFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private allowAbbreviations: boolean = true) {
+        super();
+    }
+
     innerPattern(): RegExp {
-        return PATTERN;
+        return this.allowAbbreviations ? PATTERN : PATTERN_NO_ABBR;
     }
 
     innerExtract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {

package/src/locales/en/parsers/ENTimeUnitLaterFormatParser.ts

@@ -1,5 +1,5 @@
 import { ParsingContext } from "../../../chrono";
-import { parseTimeUnits, TIME_UNITS_PATTERN } from "../constants";
+import { parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN, TIME_UNITS_PATTERN } from "../constants";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
@@ -8,7 +8,10 @@ const PATTERN = new RegExp(
     "i"
 );
 
-const STRICT_PATTERN = new RegExp("" + "(" + TIME_UNITS_PATTERN + ")" + "(later|from now)" + "(?=(?:\\W|$))", "i");
+const STRICT_PATTERN = new RegExp(
+    "" + "(" + TIME_UNITS_NO_ABBR_PATTERN + ")" + "(later|from now)" + "(?=(?:\\W|$))",
+    "i"
+);
 const GROUP_NUM_TIMEUNITS = 1;
 
 export default class ENTimeUnitLaterFormatParser extends AbstractParserWithWordBoundaryChecking {

package/src/locales/en/parsers/ENTimeUnitWithinFormatParser.ts

@@ -1,21 +1,34 @@
-import { TIME_UNITS_PATTERN, parseTimeUnits } from "../constants";
+import { TIME_UNITS_PATTERN, parseTimeUnits, TIME_UNITS_NO_ABBR_PATTERN } from "../constants";
 import { ParsingContext } from "../../../chrono";
 import { ParsingComponents } from "../../../results";
 import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
 
+const PATTERN_WITHOUT_PREFIX = new RegExp(
+    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+    "i"
+);
+
 const PATTERN_WITH_PREFIX = new RegExp(
     `(?:within|in|for)\\s*` +
         `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
     "i"
 );
 
-const PATTERN_WITHOUT_PREFIX = new RegExp(
-    `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})(?=\\W|$)`,
+const PATTERN_WITH_PREFIX_STRICT = new RegExp(
+    `(?:within|in|for)\\s*` +
+        `(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${TIME_UNITS_NO_ABBR_PATTERN})(?=\\W|$)`,
     "i"
 );
 
 export default class ENTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    constructor(private strictMode: boolean) {
+        super();
+    }
+
     innerPattern(context: ParsingContext): RegExp {
+        if (this.strictMode) {
+            return PATTERN_WITH_PREFIX_STRICT;
+        }
         return context.option.forwardDate ? PATTERN_WITHOUT_PREFIX : PATTERN_WITH_PREFIX;
     }
 

package/src/locales/ru/constants.ts

@@ -219,6 +219,9 @@ export const TIME_UNIT_DICTIONARY: { [word: string]: OpUnitType | QUnitType } =
     минуток: "minute",
     минутки: "minute",
     минутку: "minute",
+    минуточек: "minute",
+    минуточки: "minute",
+    минуточку: "minute",
     час: "hour",
     часов: "hour",
     часа: "hour",
@@ -284,7 +287,7 @@ export function parseNumberPattern(match: string): number {
 
 export const ORDINAL_NUMBER_PATTERN = `(?:${matchAnyPattern(ORDINAL_WORD_DICTIONARY)}|[0-9]{1,2}(?:го|ого|е|ое)?)`;
 export function parseOrdinalNumberPattern(match: string): number {
-    let num = match.toLowerCase();
+    const num = match.toLowerCase();
     if (ORDINAL_WORD_DICTIONARY[num] !== undefined) {
         return ORDINAL_WORD_DICTIONARY[num];
     }

package/src/results.ts

@@ -16,7 +16,7 @@ export class ReferenceWithTimezone {
             this.instant = input;
         } else {
             this.instant = input.instant ?? new Date();
-            this.timezoneOffset = toTimezoneOffset(input.timezone);
+            this.timezoneOffset = toTimezoneOffset(input.timezone, this.instant);
         }
     }
 
@@ -138,8 +138,8 @@ export class ParsingComponents implements ParsedComponents {
         return this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
     }
 
-    isOnlyDayMonthComponent(): boolean {
-        return this.isCertain("day") && this.isCertain("month") && !this.isCertain("year");
+    isDateWithUnknownYear(): boolean {
+        return this.isCertain("month") && !this.isCertain("year");
     }
 
     isValidDate(): boolean {