chrono-node 2.7.9 → 2.8.1

package/src/locales/en/refiners/ENExtractYearSuffixRefiner.ts

@@ -10,17 +10,18 @@ export default class ENExtractYearSuffixRefiner implements Refiner {
             if (!result.start.isDateWithUnknownYear()) {
                 return;
             }
-
             const suffix = context.text.substring(result.index + result.text.length);
             const match = YEAR_SUFFIX_PATTERN.exec(suffix);
             if (!match) {
                 return;
             }
-
+            // If the suffix match is just a short number, e.g. "14/4 90", don't assume it year.
+            if (match[0].trim().length <= 3) {
+                return;
+            }
             context.debug(() => {
                 console.log(`Extracting year: '${match[0]}' into : ${result}`);
             });
-
             const year = parseYear(match[YEAR_GROUP]);
             if (result.end != null) {
                 result.end.assign("year", year);
@@ -28,7 +29,6 @@ export default class ENExtractYearSuffixRefiner implements Refiner {
             result.start.assign("year", year);
             result.text += match[0];
         });
-
         return results;
     }
 }

package/src/locales/ja/constants.ts

@@ -1,3 +1,28 @@
+export const NUMBER = {
+    "零": 0,
+    "〇": 0,
+    "一": 1,
+    "二": 2,
+    "三": 3,
+    "四": 4,
+    "五": 5,
+    "六": 6,
+    "七": 7,
+    "八": 8,
+    "九": 9,
+    "十": 10,
+};
+
+export const WEEKDAY_OFFSET = {
+    "日": 0,
+    "月": 1,
+    "火": 2,
+    "水": 3,
+    "木": 4,
+    "金": 5,
+    "土": 6,
+};
+
 /**
  * to-hankaku.js
  * convert to ascii code strings.
@@ -22,3 +47,18 @@ export function toHankaku(text) {
 function alphaNum(token) {
     return String.fromCharCode(token.charCodeAt(0) - 65248);
 }
+
+export function jaStringToNumber(text: string) {
+    let number = 0;
+
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === "十") {
+            number = number === 0 ? NUMBER[char] : number * NUMBER[char];
+        } else {
+            number += NUMBER[char];
+        }
+    }
+
+    return number;
+}

package/src/locales/ja/index.ts

@@ -7,17 +7,25 @@
 import JPStandardParser from "./parsers/JPStandardParser";
 import JPMergeDateRangeRefiner from "./refiners/JPMergeDateRangeRefiner";
 import JPCasualDateParser from "./parsers/JPCasualDateParser";
+import JPWeekdayParser from "./parsers/JPWeekdayParser";
+import JPSlashDateFormatParser from "./parsers/JPSlashDateFormatParser";
+import JPTimeExpressionParser from "./parsers/JPTimeExpressionParser";
+import JPMergeDateTimeRefiner from "./refiners/JPMergeDateTimeRefiner";
 
 import { Chrono, Configuration, Parser, Refiner } from "../../chrono";
 import { ParsingResult, ParsingComponents, ReferenceWithTimezone } from "../../results";
 import { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday } from "../../types";
+import JPMergeWeekdayComponentRefiner from "./refiners/JPMergeWeekdayComponentRefiner";
+import JPWeekdayWithParenthesesParser from "./parsers/JPWeekdayWithParenthesesParser";
+import { includeCommonConfiguration } from "../../configurations";
+import MergeWeekdayComponentRefiner from "../../common/refiners/MergeWeekdayComponentRefiner";
 
 export { Chrono, Parser, Refiner, ParsingResult, ParsingComponents, ReferenceWithTimezone };
 export { Component, ParsedResult, ParsingOption, ParsingReference, Meridiem, Weekday };
 
 // Shortcuts
 export const casual = new Chrono(createCasualConfiguration());
-export const strict = new Chrono(createConfiguration());
+export const strict = new Chrono(createConfiguration(true));
 
 export function parse(text: string, ref?: ParsingReference | Date, option?: ParsingOption): ParsedResult[] {
     return casual.parse(text, ref, option);
@@ -31,7 +39,7 @@ export function parseDate(text: string, ref?: ParsingReference | Date, option?:
  * @ignore (to be documented later)
  */
 export function createCasualConfiguration(): Configuration {
-    const option = createConfiguration();
+    const option = createConfiguration(false);
     option.parsers.unshift(new JPCasualDateParser());
     return option;
 }
@@ -39,9 +47,29 @@ export function createCasualConfiguration(): Configuration {
 /**
  * @ignore (to be documented later)
  */
-export function createConfiguration(): Configuration {
-    return {
-        parsers: [new JPStandardParser()],
-        refiners: [new JPMergeDateRangeRefiner()],
-    };
+export function createConfiguration(strictMode = true): Configuration {
+    const configuration = includeCommonConfiguration(
+        {
+            parsers: [
+                new JPStandardParser(),
+                new JPWeekdayParser(),
+                new JPWeekdayWithParenthesesParser(),
+                new JPSlashDateFormatParser(),
+                new JPTimeExpressionParser(),
+            ],
+            refiners: [
+                new JPMergeWeekdayComponentRefiner(), // Note: should be before JPMergeDateTimeRefiner and JPMergeDateRangeRefiner
+                new JPMergeDateTimeRefiner(),
+                new JPMergeDateRangeRefiner(),
+            ],
+        },
+        strictMode
+    );
+
+    // Note: Remove because it is not used in Japanese grammar
+    configuration.refiners = configuration.refiners.filter(
+        (refiner) => !(refiner instanceof MergeWeekdayComponentRefiner)
+    );
+
+    return configuration;
 }

package/src/locales/ja/parsers/JPSlashDateFormatParser.ts

@@ -0,0 +1,53 @@
+import { Parser, ParsingContext } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { findMostLikelyADYear, findYearClosestToRef } from "../../../calculation/years";
+import { toHankaku } from "../constants";
+
+/**
+ * Date format with slash "/" between numbers. YYYY/MM/DD or MM/DD
+ * Big-endian slash format is used in Japan.
+ * For examples:
+ * - 7/31
+ * - 2020/7/12
+ */
+const PATTERN = new RegExp(
+    "([0-9０-９]{4}[\\/|\\／])?" + "([0-1０-１]{0,1}[0-9０-９]{1})(?:[\\/|\\／]([0-3０-３]{0,1}[0-9０-９]{1}))",
+    "i"
+);
+
+const YEAR_GROUP = 1;
+const MONTH_GROUP = 2;
+const DAY_GROUP = 3;
+
+export default class JPSlashDateFormatParser implements Parser {
+    pattern(): RegExp {
+        return PATTERN;
+    }
+
+    extract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const result = context.createParsingComponents();
+        const month = parseInt(toHankaku(match[MONTH_GROUP]));
+        const day = parseInt(toHankaku(match[DAY_GROUP]));
+        if (month < 1 || month > 12) {
+            return null;
+        }
+
+        if (day < 1 || day > 31) {
+            return null;
+        }
+
+        result.assign("day", day);
+        result.assign("month", month);
+
+        if (match[YEAR_GROUP]) {
+            const rawYearNumber = parseInt(toHankaku(match[YEAR_GROUP]));
+            const year = findMostLikelyADYear(rawYearNumber);
+            result.assign("year", year);
+        } else {
+            const year = findYearClosestToRef(context.reference.instant, day, month);
+            result.imply("year", year);
+        }
+
+        return result;
+    }
+}

package/src/locales/ja/parsers/JPTimeExpressionParser.ts

@@ -0,0 +1,281 @@
+import { ParsingContext } from "../../../chrono";
+import { AbstractParserWithWordBoundaryChecking } from "../../../common/parsers/AbstractParserWithWordBoundary";
+import { Meridiem } from "../../../types";
+import { NUMBER, jaStringToNumber, toHankaku } from "../constants";
+
+const FIRST_REG_PATTERN = new RegExp(
+    "(?:" +
+        "(午前|午後|A.M.|P.M.|AM|PM)" +
+        ")?" +
+        "(?:[\\s,，、]*)" +
+        "(?:([0-9０-９]+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+)(?:\\s*)(?:時|:|：)" +
+        "(?:\\s*)" +
+        "([0-9０-９]+|半|[" +
+        Object.keys(NUMBER).join("") +
+        "]+)?(?:\\s*)(?:分|:|：)?" +
+        "(?:\\s*)" +
+        "([0-9０-９]+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+)?(?:\\s*)(?:秒)?)" +
+        "(?:\\s*(A.M.|P.M.|AM?|PM?))?",
+    "i"
+);
+
+const SECOND_REG_PATTERN = new RegExp(
+    "(?:^\\s*(?:から|\\-|\\–|\\－|\\~|\\〜)\\s*)" +
+        "(?:" +
+        "(午前|午後|A.M.|P.M.|AM|PM)" +
+        ")?" +
+        "(?:[\\s,，、]*)" +
+        "(?:([0-9０-９]+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+)(?:\\s*)(?:時|:|：)" +
+        "(?:\\s*)" +
+        "([0-9０-９]+|半|[" +
+        Object.keys(NUMBER).join("") +
+        "]+)?(?:\\s*)(?:分|:|：)?" +
+        "(?:\\s*)" +
+        "([0-9０-９]+|[" +
+        Object.keys(NUMBER).join("") +
+        "]+)?(?:\\s*)(?:秒)?)" +
+        "(?:\\s*(A.M.|P.M.|AM?|PM?))?",
+    "i"
+);
+
+const AM_PM_HOUR_GROUP_1 = 1;
+const HOUR_GROUP = 2;
+const MINUTE_GROUP = 3;
+const SECOND_GROUP = 4;
+const AM_PM_HOUR_GROUP_2 = 5;
+
+export default class JPTimeExpressionParser extends AbstractParserWithWordBoundaryChecking {
+    innerPattern(): RegExp {
+        return FIRST_REG_PATTERN;
+    }
+
+    innerExtract(context: ParsingContext, match: RegExpMatchArray) {
+        // This pattern can be overlaped Ex. [12] AM, 1[2] AM
+        if (match.index > 0 && context.text[match.index - 1].match(/\w/)) {
+            return null;
+        }
+
+        const result = context.createParsingResult(match.index, match[0]);
+
+        let hour = 0;
+        let minute = 0;
+        let meridiem = -1;
+
+        // ----- Second
+        if (match[SECOND_GROUP]) {
+            let second = parseInt(toHankaku(match[SECOND_GROUP]));
+            if (isNaN(second)) {
+                second = jaStringToNumber(match[SECOND_GROUP]);
+            }
+            if (second >= 60) return null;
+            result.start.assign("second", second);
+        }
+
+        hour = parseInt(toHankaku(match[HOUR_GROUP]));
+        if (isNaN(hour)) {
+            hour = jaStringToNumber(match[HOUR_GROUP]);
+        }
+
+        // ----- Minutes
+        if (match[MINUTE_GROUP]) {
+            if (match[MINUTE_GROUP] === "半") {
+                minute = 30;
+            } else {
+                minute = parseInt(toHankaku(match[MINUTE_GROUP]));
+                if (isNaN(minute)) {
+                    minute = jaStringToNumber(match[MINUTE_GROUP]);
+                }
+            }
+        } else if (hour > 100) {
+            minute = hour % 100;
+            hour = Math.floor(hour / 100);
+        }
+
+        if (minute >= 60) {
+            return null;
+        }
+
+        if (hour > 24) {
+            return null;
+        }
+        if (hour >= 12) {
+            meridiem = Meridiem.PM;
+        }
+
+        // ----- AM & PM
+        if (match[AM_PM_HOUR_GROUP_1]) {
+            if (hour > 12) return null;
+            const AMPMString = match[AM_PM_HOUR_GROUP_1];
+            const FirstAMPMString = AMPMString[0].toLowerCase();
+            if (AMPMString === "午前" || FirstAMPMString === "a") {
+                meridiem = Meridiem.AM;
+                if (hour === 12) hour = 0;
+            } else if (AMPMString === "午後" || FirstAMPMString === "p") {
+                meridiem = Meridiem.PM;
+                if (hour != 12) hour += 12;
+            }
+        } else if (match[AM_PM_HOUR_GROUP_2]) {
+            if (hour > 12) return null;
+            const ampm = match[AM_PM_HOUR_GROUP_2][0].toLowerCase();
+            if (ampm === "a") {
+                meridiem = Meridiem.AM;
+                if (hour === 12) hour = 0;
+            }
+
+            if (ampm === "p") {
+                meridiem = Meridiem.PM;
+                if (hour != 12) hour += 12;
+            }
+        }
+
+        result.start.assign("hour", hour);
+        result.start.assign("minute", minute);
+
+        if (meridiem >= 0) {
+            result.start.assign("meridiem", meridiem);
+        } else {
+            if (hour < 12) {
+                result.start.imply("meridiem", 0);
+            } else {
+                result.start.imply("meridiem", 1);
+            }
+        }
+
+        // =============================================================================================
+        //                  Extracting the 'to' chunk
+        // =============================================================================================
+
+        match = SECOND_REG_PATTERN.exec(context.text.substring(result.index + result.text.length));
+        if (!match) {
+            // Not accept number only result
+            if (result.text.match(/^\d+$/)) {
+                return null;
+            }
+            return result;
+        }
+
+        result.end = context.createParsingComponents();
+
+        hour = 0;
+        minute = 0;
+        meridiem = -1;
+
+        // ----- Second
+        if (match[SECOND_GROUP]) {
+            let second = parseInt(toHankaku(match[SECOND_GROUP]));
+            if (isNaN(second)) {
+                second = jaStringToNumber(match[SECOND_GROUP]);
+            }
+
+            if (second >= 60) return null;
+            result.end.assign("second", second);
+        }
+
+        hour = parseInt(toHankaku(match[HOUR_GROUP]));
+        if (isNaN(hour)) {
+            hour = jaStringToNumber(match[HOUR_GROUP]);
+        }
+
+        // ----- Minutes
+        if (match[MINUTE_GROUP]) {
+            if (match[MINUTE_GROUP] === "半") {
+                minute = 30;
+            } else {
+                minute = parseInt(toHankaku(match[MINUTE_GROUP]));
+                if (isNaN(minute)) {
+                    minute = jaStringToNumber(match[MINUTE_GROUP]);
+                }
+            }
+        } else if (hour > 100) {
+            minute = hour % 100;
+            hour = Math.floor(hour / 100);
+        }
+
+        if (minute >= 60) {
+            return null;
+        }
+
+        if (hour > 24) {
+            return null;
+        }
+        if (hour >= 12) {
+            meridiem = Meridiem.PM;
+        }
+
+        // ----- AM & PM
+        if (match[AM_PM_HOUR_GROUP_1]) {
+            if (hour > 12) return null;
+            const AMPMString = match[AM_PM_HOUR_GROUP_1];
+            const FirstAMPMString = AMPMString[0].toLowerCase();
+            if (AMPMString === "午前" || FirstAMPMString === "a") {
+                meridiem = Meridiem.AM;
+                if (hour === 12) hour = 0;
+            } else if (AMPMString === "午後" || FirstAMPMString === "p") {
+                meridiem = Meridiem.PM;
+                if (hour != 12) hour += 12;
+            }
+
+            if (!result.start.isCertain("meridiem")) {
+                if (meridiem === Meridiem.AM) {
+                    result.start.imply("meridiem", Meridiem.AM);
+
+                    if (result.start.get("hour") === 12) {
+                        result.start.assign("hour", 0);
+                    }
+                } else {
+                    result.start.imply("meridiem", 1);
+
+                    if (result.start.get("hour") != 12) {
+                        result.start.assign("hour", result.start.get("hour") + 12);
+                    }
+                }
+            }
+        } else if (match[AM_PM_HOUR_GROUP_2]) {
+            if (hour > 12) return null;
+            const ampm = match[AM_PM_HOUR_GROUP_2][0].toLowerCase();
+            if (ampm === "a") {
+                meridiem = Meridiem.AM;
+                if (hour === 12) hour = 0;
+            }
+
+            if (ampm === "p") {
+                meridiem = Meridiem.PM;
+                if (hour != 12) hour += 12;
+            }
+        }
+
+        result.text = result.text + match[0];
+        result.end.assign("hour", hour);
+        result.end.assign("minute", minute);
+        if (meridiem >= 0) {
+            result.end.assign("meridiem", meridiem);
+        } else {
+            const startAtPM = result.start.isCertain("meridiem") && result.start.get("hour") > 12;
+            if (startAtPM) {
+                if (result.start.get("hour") - 12 > hour) {
+                    // 10pm - 1 (am)
+                    result.end.imply("meridiem", Meridiem.AM);
+                } else if (hour <= 12) {
+                    result.end.assign("hour", hour + 12);
+                    result.end.assign("meridiem", Meridiem.PM);
+                }
+            } else if (hour > 12) {
+                result.end.imply("meridiem", Meridiem.PM);
+            } else if (hour <= 12) {
+                result.end.imply("meridiem", Meridiem.AM);
+            }
+        }
+
+        if (result.end.date().getTime() < result.start.date().getTime()) {
+            result.end.imply("day", result.end.get("day") + 1);
+        }
+
+        return result;
+    }
+}

package/src/locales/ja/parsers/JPWeekdayParser.ts

@@ -0,0 +1,35 @@
+import { ParsingContext, Parser } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { WEEKDAY_OFFSET } from "../constants";
+import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
+
+const PATTERN = new RegExp(
+    "((?<prefix>前の|次の|今週))?(?<weekday>" + Object.keys(WEEKDAY_OFFSET).join("|") + ")(?:曜日|曜)",
+    "i"
+);
+
+export default class JPWeekdayParser implements Parser {
+    pattern(): RegExp {
+        return PATTERN;
+    }
+
+    extract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match.groups.weekday;
+        const offset = WEEKDAY_OFFSET[dayOfWeek];
+        if (offset === undefined) return null;
+
+        const prefix = match.groups.prefix || "";
+
+        let modifier = null;
+        if (prefix.match(/前の/)) {
+            modifier = "last";
+        } else if (prefix.match(/次の/)) {
+            modifier = "next";
+        } else if (prefix.match(/今週/)) {
+            modifier = "this";
+        }
+        // TODO: handle 先週, 来週. They are different from last and next.
+
+        return createParsingComponentsAtWeekday(context.reference, offset, modifier);
+    }
+}

package/src/locales/ja/parsers/JPWeekdayWithParenthesesParser.ts

@@ -0,0 +1,25 @@
+import { ParsingContext, Parser } from "../../../chrono";
+import { ParsingComponents } from "../../../results";
+import { WEEKDAY_OFFSET } from "../constants";
+import { createParsingComponentsAtWeekday } from "../../../common/calculation/weekdays";
+
+const PATTERN = new RegExp("(?:\\(|\\（)(?<weekday>" + Object.keys(WEEKDAY_OFFSET).join("|") + ")(?:\\)|\\）)", "i");
+
+/**
+ * Weekday with parentheses in Japanese
+ * For examples:
+ * - (水)
+ * - （土）
+ */
+export default class JPWeekdayWithParenthesesParser implements Parser {
+    pattern(): RegExp {
+        return PATTERN;
+    }
+
+    extract(context: ParsingContext, match: RegExpMatchArray): ParsingComponents {
+        const dayOfWeek = match.groups.weekday;
+        const offset = WEEKDAY_OFFSET[dayOfWeek];
+        if (offset === undefined) return null;
+        return createParsingComponentsAtWeekday(context.reference, offset);
+    }
+}

package/src/locales/ja/refiners/JPMergeDateRangeRefiner.ts

@@ -3,11 +3,11 @@ import AbstractMergeDateRangeRefiner from "../../../common/refiners/AbstractMerg
 /**
  * Merging before and after results (see. AbstractMergeDateRangeRefiner)
  * This implementation should provide Japanese connecting phases
- * - 水曜日[ー]日曜日
+ * - 2月11日[ー]2月13日
  * - 水曜日[から]日曜日
  */
 export default class JPMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
     patternBetween(): RegExp {
-        return /^\s*(から|ー|-|～|~)\s*$/i;
+        return /^\s*(から|－|ー|-|～|~)\s*$/i;
     }
 }

package/src/locales/ja/refiners/JPMergeDateTimeRefiner.ts

@@ -0,0 +1,7 @@
+import AbstractMergeDateTimeRefiner from "../../../common/refiners/AbstractMergeDateTimeRefiner";
+
+export default class JPMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween(): RegExp {
+        return /^\s*(の)?\s*$/i;
+    }
+}

package/src/locales/ja/refiners/JPMergeWeekdayComponentRefiner.ts

@@ -0,0 +1,30 @@
+import { MergingRefiner } from "../../../../src/common/abstractRefiners";
+import { ParsingResult } from "../../../results";
+
+/**
+ * Merge weekday component into more completed data
+ * - [2014/7/12], [(土)] => [2014/7/12 (土)]
+ * - [7月12日], [土曜日] => [7月12日 土曜日]
+ * The difference between the original MergeWeekdayComponentRefiner and the JP one is the order of date and weekday.
+ */
+export default class JPMergeWeekdayComponentRefiner extends MergingRefiner {
+    mergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): ParsingResult {
+        const newResult = currentResult.clone();
+        newResult.text = currentResult.text + textBetween + nextResult.text;
+
+        newResult.start.assign("weekday", nextResult.start.get("weekday"));
+        if (newResult.end) {
+            newResult.end.assign("weekday", nextResult.start.get("weekday"));
+        }
+
+        return newResult;
+    }
+
+    shouldMergeResults(textBetween: string, currentResult: ParsingResult, nextResult: ParsingResult): boolean {
+        const normalDateThenWeekday =
+            currentResult.start.isCertain("day") &&
+            nextResult.start.isOnlyWeekdayComponent() &&
+            !nextResult.start.isCertain("hour");
+        return normalDateThenWeekday && textBetween.match(/^[,、の]?\s*$/) !== null;
+    }
+}

package/src/results.ts

@@ -14,6 +14,7 @@ export class ReferenceWithTimezone {
         input = input ?? new Date();
         if (input instanceof Date) {
             this.instant = input;
+            this.timezoneOffset = null;
         } else {
             this.instant = input.instant ?? new Date();
             this.timezoneOffset = toTimezoneOffset(input.timezone, this.instant);
@@ -25,7 +26,11 @@ export class ReferenceWithTimezone {
      * The output's instant is NOT the reference's instant when the reference's and system's timezone are different.
      */
     getDateWithAdjustedTimezone() {
-        return new Date(this.instant.getTime() + this.getSystemTimezoneAdjustmentMinute(this.instant) * 60000);
+        const date = new Date(this.instant);
+        if (this.timezoneOffset !== null) {
+            date.setMinutes(date.getMinutes() - this.getSystemTimezoneAdjustmentMinute(this.instant));
+        }
+        return date;
     }
 
     /**
@@ -44,6 +49,10 @@ export class ReferenceWithTimezone {
         const targetTimezoneOffset = overrideTimezoneOffset ?? this.timezoneOffset ?? currentTimezoneOffset;
         return currentTimezoneOffset - targetTimezoneOffset;
     }
+
+    getTimezoneOffset(): number {
+        return this.timezoneOffset ?? -this.instant.getTimezoneOffset();
+    }
 }
 
 export class ParsingComponents implements ParsedComponents {
@@ -62,10 +71,10 @@ export class ParsingComponents implements ParsedComponents {
             }
         }
 
-        const refDayJs = dayjs(reference.instant);
-        this.imply("day", refDayJs.date());
-        this.imply("month", refDayJs.month() + 1);
-        this.imply("year", refDayJs.year());
+        const refDayJs = reference.getDateWithAdjustedTimezone();
+        this.imply("day", refDayJs.getDate());
+        this.imply("month", refDayJs.getMonth() + 1);
+        this.imply("year", refDayJs.getFullYear());
         this.imply("hour", 12);
         this.imply("minute", 0);
         this.imply("second", 0);
@@ -166,7 +175,7 @@ export class ParsingComponents implements ParsedComponents {
     }
 
     dayjs() {
-        return dayjs(this.date());
+        return dayjs(this.dateWithoutTimezoneAdjustment());
     }
 
     date(): Date {
@@ -210,7 +219,7 @@ export class ParsingComponents implements ParsedComponents {
         reference: ReferenceWithTimezone,
         fragments: { [c in QUnitType]?: number }
     ): ParsingComponents {
-        let date = dayjs(reference.instant);
+        let date = dayjs(reference.getDateWithAdjustedTimezone());
         for (const key in fragments) {
             date = date.add(fragments[key as QUnitType], key as QUnitType);
         }
@@ -221,14 +230,10 @@ export class ParsingComponents implements ParsedComponents {
             components.addTag("result/relativeDateAndTime");
             assignSimilarTime(components, date);
             assignSimilarDate(components, date);
-            if (reference.timezoneOffset !== null) {
-                components.assign("timezoneOffset", -reference.instant.getTimezoneOffset());
-            }
+            components.assign("timezoneOffset", reference.getTimezoneOffset());
         } else {
             implySimilarTime(components, date);
-            if (reference.timezoneOffset !== null) {
-                components.imply("timezoneOffset", -reference.instant.getTimezoneOffset());
-            }
+            components.imply("timezoneOffset", reference.getTimezoneOffset());
 
             if (fragments["d"]) {
                 components.assign("day", date.date());