@rivetjs/cdk 0.0.0-stage → 0.1.0-alpha.1

package/date/queries.js

@@ -0,0 +1,303 @@
+// Ported from @internationalized/date src/queries.ts (react-spectrum), Apache-2.0, © Adobe.
+// Changes: .ts import specifiers, type-only imports, override modifiers, strict-mode index types.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import {} from "./types.js";
+import { CalendarDate, CalendarDateTime, ZonedDateTime } from "./CalendarDate.js";
+import { fromAbsolute, toAbsolute, toCalendar, toCalendarDate } from "./conversion.js";
+import { weekStartData } from "./weekStartData.js";
+/** Returns whether the given dates occur on the same day, regardless of the time or calendar system. */
+export function isSameDay(a, b) {
+    b = toCalendar(b, a.calendar);
+    return a.era === b.era && a.year === b.year && a.month === b.month && a.day === b.day;
+}
+/**
+ * Returns whether the given dates occur in the same month, using the calendar system of the first
+ * date.
+ */
+export function isSameMonth(a, b) {
+    b = toCalendar(b, a.calendar);
+    // In the Japanese calendar, months can span multiple eras/years, so only compare the first of the month.
+    a = startOfMonth(a);
+    b = startOfMonth(b);
+    return a.era === b.era && a.year === b.year && a.month === b.month;
+}
+/**
+ * Returns whether the given dates occur in the same year, using the calendar system of the first
+ * date.
+ */
+export function isSameYear(a, b) {
+    b = toCalendar(b, a.calendar);
+    a = startOfYear(a);
+    b = startOfYear(b);
+    return a.era === b.era && a.year === b.year;
+}
+/** Returns whether the given dates occur on the same day, and are of the same calendar system. */
+export function isEqualDay(a, b) {
+    return isEqualCalendar(a.calendar, b.calendar) && isSameDay(a, b);
+}
+/** Returns whether the given dates occur in the same month, and are of the same calendar system. */
+export function isEqualMonth(a, b) {
+    return isEqualCalendar(a.calendar, b.calendar) && isSameMonth(a, b);
+}
+/** Returns whether the given dates occur in the same year, and are of the same calendar system. */
+export function isEqualYear(a, b) {
+    return isEqualCalendar(a.calendar, b.calendar) && isSameYear(a, b);
+}
+/** Returns whether two calendars are the same. */
+export function isEqualCalendar(a, b) {
+    return a.isEqual?.(b) ?? b.isEqual?.(a) ?? a.identifier === b.identifier;
+}
+/** Returns whether the date is today in the given time zone. */
+export function isToday(date, timeZone) {
+    return isSameDay(date, today(timeZone));
+}
+const DAY_MAP = {
+    sun: 0,
+    mon: 1,
+    tue: 2,
+    wed: 3,
+    thu: 4,
+    fri: 5,
+    sat: 6
+};
+/**
+ * Returns the day of week for the given date and locale. Days are numbered from zero to six,
+ * where zero is the first day of the week in the given locale. For example, in the United States,
+ * the first day of the week is Sunday, but in France it is Monday.
+ */
+export function getDayOfWeek(date, locale, firstDayOfWeek) {
+    let julian = date.calendar.toJulianDay(date);
+    // If julian is negative, then julian % 7 will be negative, so we adjust
+    // accordingly.  Julian day 0 is Monday.
+    let weekStart = firstDayOfWeek ? DAY_MAP[firstDayOfWeek] : getWeekStart(locale);
+    let dayOfWeek = Math.ceil(julian + 1 - weekStart) % 7;
+    if (dayOfWeek < 0) {
+        dayOfWeek += 7;
+    }
+    return dayOfWeek;
+}
+/** Returns the current time in the given time zone. */
+export function now(timeZone) {
+    return fromAbsolute(Date.now(), timeZone);
+}
+/** Returns today's date in the given time zone. */
+export function today(timeZone) {
+    return toCalendarDate(now(timeZone));
+}
+export function compareDate(a, b) {
+    return a.calendar.toJulianDay(a) - b.calendar.toJulianDay(b);
+}
+export function compareTime(a, b) {
+    return timeToMs(a) - timeToMs(b);
+}
+function timeToMs(a) {
+    return a.hour * 60 * 60 * 1000 + a.minute * 60 * 1000 + a.second * 1000 + a.millisecond;
+}
+/**
+ * Returns the number of hours in the given date and time zone.
+ * Usually this is 24, but it could be 23 or 25 if the date is on a daylight saving transition.
+ */
+export function getHoursInDay(a, timeZone) {
+    let ms = toAbsolute(a, timeZone);
+    let tomorrow = a.add({ days: 1 });
+    let tomorrowMs = toAbsolute(tomorrow, timeZone);
+    return (tomorrowMs - ms) / 3600000;
+}
+let localTimeZone = null;
+let localTimeZoneOverride = false;
+/** Returns the time zone identifier for the current user. */
+export function getLocalTimeZone() {
+    if (localTimeZone == null) {
+        localTimeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    return localTimeZone;
+}
+/** Sets the time zone identifier for the current user. */
+export function setLocalTimeZone(timeZone) {
+    localTimeZoneOverride = true;
+    localTimeZone = timeZone;
+}
+/** Resets the time zone identifier for the current user. */
+export function resetLocalTimeZone() {
+    localTimeZoneOverride = false;
+    localTimeZone = null;
+}
+/** Returns whether the local time zone has been explicitly overridden via `setLocalTimeZone`. */
+export function isLocalTimeZoneOverridden() {
+    return localTimeZoneOverride;
+}
+export function startOfMonth(date) {
+    // Use `subtract` instead of `set` so we don't get constrained in an era.
+    return date.subtract({ days: date.day - 1 });
+}
+export function endOfMonth(date) {
+    return date.add({ days: date.calendar.getDaysInMonth(date) - date.day });
+}
+export function startOfYear(date) {
+    return startOfMonth(date.subtract({ months: date.month - 1 }));
+}
+export function endOfYear(date) {
+    return endOfMonth(date.add({ months: date.calendar.getMonthsInYear(date) - date.month }));
+}
+export function getMinimumMonthInYear(date) {
+    if (date.calendar.getMinimumMonthInYear) {
+        return date.calendar.getMinimumMonthInYear(date);
+    }
+    return 1;
+}
+export function getMinimumDayInMonth(date) {
+    if (date.calendar.getMinimumDayInMonth) {
+        return date.calendar.getMinimumDayInMonth(date);
+    }
+    return 1;
+}
+export function startOfWeek(date, locale, firstDayOfWeek) {
+    let dayOfWeek = getDayOfWeek(date, locale, firstDayOfWeek);
+    return date.subtract({ days: dayOfWeek });
+}
+export function endOfWeek(date, locale, firstDayOfWeek) {
+    return startOfWeek(date, locale, firstDayOfWeek).add({ days: 6 });
+}
+const cachedRegions = new Map();
+const cachedWeekInfo = new Map();
+function getRegion(locale) {
+    // If the Intl.Locale API is available, use it to get the region for the locale.
+    // @ts-ignore
+    if (Intl.Locale) {
+        // Constructing an Intl.Locale is expensive, so cache the result.
+        let region = cachedRegions.get(locale);
+        if (!region) {
+            // @ts-ignore
+            region = new Intl.Locale(locale).maximize().region;
+            if (region) {
+                cachedRegions.set(locale, region);
+            }
+        }
+        return region;
+    }
+    // If not, just try splitting the string.
+    // If the second part of the locale string is 'u',
+    // then this is a unicode extension, so ignore it.
+    // Otherwise, it should be the region.
+    let part = locale.split('-')[1];
+    return part === 'u' ? undefined : part;
+}
+function getWeekStart(locale) {
+    // TODO: use Intl.Locale for this once browsers support the weekInfo property
+    // https://github.com/tc39/proposal-intl-locale-info
+    let weekInfo = cachedWeekInfo.get(locale);
+    if (!weekInfo) {
+        if (Intl.Locale) {
+            // @ts-ignore
+            let localeInst = new Intl.Locale(locale);
+            if ('getWeekInfo' in localeInst) {
+                weekInfo = localeInst.getWeekInfo();
+                if (weekInfo) {
+                    cachedWeekInfo.set(locale, weekInfo);
+                    return weekInfo.firstDay;
+                }
+            }
+        }
+        let region = getRegion(locale);
+        if (locale.includes('-fw-')) {
+            // pull the value for the attribute fw from strings such as en-US-u-ca-iso8601-fw-tue or en-US-u-ca-iso8601-fw-mon-nu-thai
+            // where the fw attribute could be followed by another unicode locale extension or not
+            let day = locale.split('-fw-')[1].split('-')[0];
+            if (day === 'mon') {
+                weekInfo = { firstDay: 1 };
+            }
+            else if (day === 'tue') {
+                weekInfo = { firstDay: 2 };
+            }
+            else if (day === 'wed') {
+                weekInfo = { firstDay: 3 };
+            }
+            else if (day === 'thu') {
+                weekInfo = { firstDay: 4 };
+            }
+            else if (day === 'fri') {
+                weekInfo = { firstDay: 5 };
+            }
+            else if (day === 'sat') {
+                weekInfo = { firstDay: 6 };
+            }
+            else {
+                weekInfo = { firstDay: 0 };
+            }
+        }
+        else if (locale.includes('-ca-iso8601')) {
+            weekInfo = { firstDay: 1 };
+        }
+        else {
+            weekInfo = { firstDay: region ? weekStartData[region] || 0 : 0 };
+        }
+        cachedWeekInfo.set(locale, weekInfo);
+    }
+    return weekInfo.firstDay;
+}
+/** Returns the number of weeks in the given month and locale. */
+export function getWeeksInMonth(date, locale, firstDayOfWeek) {
+    let days = date.calendar.getDaysInMonth(date);
+    return Math.ceil((getDayOfWeek(startOfMonth(date), locale, firstDayOfWeek) + days) / 7);
+}
+export function minDate(a, b) {
+    if (a && b) {
+        return a.compare(b) <= 0 ? a : b;
+    }
+    return a || b;
+}
+/** Returns the greater of the two provider dates. */
+export function maxDate(a, b) {
+    if (a && b) {
+        return a.compare(b) >= 0 ? a : b;
+    }
+    return a || b;
+}
+const WEEKEND_DATA = {
+    AF: [4, 5],
+    AE: [5, 6],
+    BH: [5, 6],
+    DZ: [5, 6],
+    EG: [5, 6],
+    IL: [5, 6],
+    IQ: [5, 6],
+    IR: [5, 5],
+    JO: [5, 6],
+    KW: [5, 6],
+    LY: [5, 6],
+    OM: [5, 6],
+    QA: [5, 6],
+    SA: [5, 6],
+    SD: [5, 6],
+    SY: [5, 6],
+    YE: [5, 6]
+};
+/** Returns whether the given date is on a weekend in the given locale. */
+export function isWeekend(date, locale) {
+    let julian = date.calendar.toJulianDay(date);
+    // If julian is negative, then julian % 7 will be negative, so we adjust
+    // accordingly.  Julian day 0 is Monday.
+    let dayOfWeek = Math.ceil(julian + 1) % 7;
+    if (dayOfWeek < 0) {
+        dayOfWeek += 7;
+    }
+    let region = getRegion(locale);
+    // Use Intl.Locale for this once weekInfo is supported.
+    // https://github.com/tc39/proposal-intl-locale-info
+    let [start, end] = WEEKEND_DATA[region] || [6, 0];
+    return dayOfWeek === start || dayOfWeek === end;
+}
+/** Returns whether the given date is on a weekday in the given locale. */
+export function isWeekday(date, locale) {
+    return !isWeekend(date, locale);
+}

package/date/serialize.d.ts

@@ -0,0 +1,18 @@
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+import type { Calendar, CalendarIdentifier } from "./types.js";
+export type AnyDateValue = CalendarDate | CalendarDateTime | ZonedDateTime;
+export type AnyTimeValue = Time | CalendarDateTime | ZonedDateTime;
+/** A serialized date / time value (see module comment). */
+export type DateValueString = string;
+/** The value as a string that `parseDateValue` turns back into an equal value (same class + calendar). */
+export declare function stringifyDateValue(value: AnyDateValue | Time): DateValueString;
+export declare function stringifyDateValue(value: AnyDateValue | Time | null | undefined): DateValueString | null;
+/**
+ * Parse a `stringifyDateValue` string (or a plain ISO 8601 date / date-time / zoned date-time /
+ * time). Results are cached (values are immutable). `calendars` creates the annotated calendar
+ * system (default: `createCalendar`).
+ */
+export declare function parseDateValue(text: DateValueString, calendars?: (id: CalendarIdentifier) => Calendar): AnyDateValue | Time;
+export declare function parseDateValue(text: DateValueString | null | undefined, calendars?: (id: CalendarIdentifier) => Calendar): AnyDateValue | Time | null;
+/** Accept a value or its string form (component props), return the string form. */
+export declare function toDateValueString(value: AnyDateValue | Time | DateValueString | null | undefined): DateValueString | null;

package/date/serialize.js

@@ -0,0 +1,55 @@
+// Rivet addition (not part of @internationalized/date): date values as strings, so widget state
+// stays plain JSON for resumability (the resume format refuses class instances). The string is the
+// value's ISO 8601 form (`toString()`, always proleptic Gregorian) plus an RFC 9557 calendar
+// annotation (`[u-ca=japanese]`) when the value is not Gregorian, so it parses back to the same
+// class in the same calendar system:
+//   CalendarDate      2026-10-04                       2026-10-04[u-ca=hebrew]
+//   CalendarDateTime  2026-10-04T09:30:00
+//   ZonedDateTime     2026-10-04T09:30:00+03:00[Europe/Kyiv]
+//   Time              09:30:00
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+import { createCalendar } from "./createCalendar.js";
+import { toCalendar } from "./conversion.js";
+import { parseDate, parseDateTime, parseTime, parseZonedDateTime } from "./string.js";
+const CALENDAR_ANNOTATION = /\[u-ca=([a-z0-9-]+)\]$/;
+const cache = new Map();
+export function stringifyDateValue(value) {
+    if (value == null)
+        return null;
+    const text = value.toString();
+    return "calendar" in value && value.calendar.identifier !== "gregory" ? text + "[u-ca=" + value.calendar.identifier + "]" : text;
+}
+export function parseDateValue(text, calendars) {
+    if (text == null || text === "")
+        return null;
+    const hit = calendars ? undefined : cache.get(text);
+    if (hit)
+        return hit;
+    let body = text, calendar = null;
+    const annotation = CALENDAR_ANNOTATION.exec(text);
+    if (annotation) {
+        calendar = annotation[1];
+        body = text.slice(0, annotation.index);
+    }
+    let value;
+    if (body.includes("["))
+        value = parseZonedDateTime(body);
+    else if (body.includes("T"))
+        value = parseDateTime(body);
+    else if (/^\d{2}:/.test(body))
+        value = parseTime(body);
+    else
+        value = parseDate(body);
+    if (calendar && calendar !== "gregory" && !(value instanceof Time))
+        value = toCalendar(value, (calendars ?? createCalendar)(calendar));
+    if (!calendars) {
+        if (cache.size > 512)
+            cache.clear();
+        cache.set(text, value);
+    }
+    return value;
+}
+/** Accept a value or its string form (component props), return the string form. */
+export function toDateValueString(value) {
+    return value == null ? null : typeof value === "string" ? value : stringifyDateValue(value);
+}

package/date/string.d.ts

@@ -0,0 +1,36 @@
+import { type AnyDateTime, type DateTimeDuration, type Disambiguation } from './types.js';
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from './CalendarDate.js';
+/** Parses an ISO 8601 time string. */
+export declare function parseTime(value: string): Time;
+/** Parses an ISO 8601 date string, with no time components. */
+export declare function parseDate(value: string): CalendarDate;
+/** Parses an ISO 8601 date and time string, with no time zone. */
+export declare function parseDateTime(value: string): CalendarDateTime;
+/**
+ * Parses an ISO 8601 date and time string with a time zone extension and optional UTC offset (e.g.
+ * "2021-11-07T00:45[America/Los_Angeles]" or "2021-11-07T00:45-07:00[America/Los_Angeles]").
+ * Ambiguous times due to daylight saving time transitions are resolved according to the
+ * `disambiguation` parameter.
+ */
+export declare function parseZonedDateTime(value: string, disambiguation?: Disambiguation): ZonedDateTime;
+/**
+ * Parses an ISO 8601 date and time string with a UTC offset (e.g. "2021-11-07T07:45:00Z"
+ * or "2021-11-07T07:45:00-07:00"). The result is converted to the provided time zone.
+ */
+export declare function parseAbsolute(value: string, timeZone: string): ZonedDateTime;
+/**
+ * Parses an ISO 8601 date and time string with a UTC offset (e.g. "2021-11-07T07:45:00Z"
+ * or "2021-11-07T07:45:00-07:00"). The result is converted to the user's local time zone.
+ */
+export declare function parseAbsoluteToLocal(value: string): ZonedDateTime;
+export declare function timeToString(time: Time): string;
+export declare function dateToString(date: CalendarDate): string;
+export declare function dateTimeToString(date: AnyDateTime): string;
+export declare function zonedDateTimeToString(date: ZonedDateTime): string;
+/**
+ * Parses an ISO 8601 duration string (e.g. "P3Y6M6W4DT12H30M5S").
+ *
+ * @param value An ISO 8601 duration string.
+ * @returns A DateTimeDuration object.
+ */
+export declare function parseDuration(value: string): Required<DateTimeDuration>;

package/date/string.js

@@ -0,0 +1,223 @@
+// Ported from @internationalized/date src/string.ts (react-spectrum), Apache-2.0, © Adobe.
+// Changes: .ts import specifiers, type-only imports, override modifiers, strict-mode index types.
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import {} from "./types.js";
+import { CalendarDate, CalendarDateTime, Time, ZonedDateTime } from "./CalendarDate.js";
+import { epochFromDate, fromAbsolute, possibleAbsolutes, toAbsolute, toCalendar, toCalendarDateTime, toTimeZone } from "./conversion.js";
+import { getLocalTimeZone } from "./queries.js";
+import { GregorianCalendar } from "./calendars/GregorianCalendar.js";
+import {} from "./utils.js";
+const TIME_RE = /^(\d{2})(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?$/;
+const DATE_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})$/;
+const DATE_TIME_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?$/;
+const ZONED_DATE_TIME_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:([+-]\d{2})(?::?(\d{2}))?(?::?(\d{2}))?)?\[(.*?)\]$/;
+const ABSOLUTE_RE = /^([+-]\d{6}|\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:(?:([+-]\d{2})(?::?(\d{2}))?)|Z)$/;
+const DATE_TIME_DURATION_RE = /^((?<negative>-)|\+)?P((?<years>\d*)Y)?((?<months>\d*)M)?((?<weeks>\d*)W)?((?<days>\d*)D)?((?<time>T)((?<hours>\d*[.,]?\d{1,9})H)?((?<minutes>\d*[.,]?\d{1,9})M)?((?<seconds>\d*[.,]?\d{1,9})S)?)?$/;
+const requiredDurationTimeGroups = ['hours', 'minutes', 'seconds'];
+const requiredDurationGroups = ['years', 'months', 'weeks', 'days', ...requiredDurationTimeGroups];
+/** Parses an ISO 8601 time string. */
+export function parseTime(value) {
+    let m = value.match(TIME_RE);
+    if (!m) {
+        throw new Error('Invalid ISO 8601 time string: ' + value);
+    }
+    return new Time(parseNumber(m[1], 0, 23), m[2] ? parseNumber(m[2], 0, 59) : 0, m[3] ? parseNumber(m[3], 0, 59) : 0, m[4] ? parseNumber(m[4], 0, Infinity) * 1000 : 0);
+}
+/** Parses an ISO 8601 date string, with no time components. */
+export function parseDate(value) {
+    let m = value.match(DATE_RE);
+    if (!m) {
+        if (ABSOLUTE_RE.test(value)) {
+            throw new Error(`Invalid ISO 8601 date string: ${value}. Use parseAbsolute() instead.`);
+        }
+        throw new Error('Invalid ISO 8601 date string: ' + value);
+    }
+    let date = new CalendarDate(parseNumber(m[1], 0, 9999), parseNumber(m[2], 1, 12), 1);
+    date.day = parseNumber(m[3], 1, date.calendar.getDaysInMonth(date));
+    return date;
+}
+/** Parses an ISO 8601 date and time string, with no time zone. */
+export function parseDateTime(value) {
+    let m = value.match(DATE_TIME_RE);
+    if (!m) {
+        if (ABSOLUTE_RE.test(value)) {
+            throw new Error(`Invalid ISO 8601 date time string: ${value}. Use parseAbsolute() instead.`);
+        }
+        throw new Error('Invalid ISO 8601 date time string: ' + value);
+    }
+    let year = parseNumber(m[1], -9999, 9999);
+    let era = year < 1 ? 'BC' : 'AD';
+    let date = new CalendarDateTime(era, year < 1 ? -year + 1 : year, parseNumber(m[2], 1, 12), 1, m[4] ? parseNumber(m[4], 0, 23) : 0, m[5] ? parseNumber(m[5], 0, 59) : 0, m[6] ? parseNumber(m[6], 0, 59) : 0, m[7] ? parseNumber(m[7], 0, Infinity) * 1000 : 0);
+    date.day = parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
+    return date;
+}
+/**
+ * Parses an ISO 8601 date and time string with a time zone extension and optional UTC offset (e.g.
+ * "2021-11-07T00:45[America/Los_Angeles]" or "2021-11-07T00:45-07:00[America/Los_Angeles]").
+ * Ambiguous times due to daylight saving time transitions are resolved according to the
+ * `disambiguation` parameter.
+ */
+export function parseZonedDateTime(value, disambiguation) {
+    let m = value.match(ZONED_DATE_TIME_RE);
+    if (!m) {
+        throw new Error('Invalid ISO 8601 date time string: ' + value);
+    }
+    let year = parseNumber(m[1], -9999, 9999);
+    let era = year < 1 ? 'BC' : 'AD';
+    let date = new ZonedDateTime(era, year < 1 ? -year + 1 : year, parseNumber(m[2], 1, 12), 1, m[11], 0, m[4] ? parseNumber(m[4], 0, 23) : 0, m[5] ? parseNumber(m[5], 0, 59) : 0, m[6] ? parseNumber(m[6], 0, 59) : 0, m[7] ? parseNumber(m[7], 0, Infinity) * 1000 : 0);
+    date.day = parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
+    let plainDateTime = toCalendarDateTime(date);
+    let ms;
+    if (m[8]) {
+        let hourOffset = parseNumber(m[8], -23, 23);
+        date.offset =
+            Math.sign(hourOffset) *
+                (Math.abs(hourOffset) * 60 * 60 * 1000 +
+                    parseNumber(m[9] ?? '0', 0, 59) * 60 * 1000 +
+                    parseNumber(m[10] ?? '0', 0, 59) * 1000);
+        ms = epochFromDate(date) - date.offset;
+        // Validate offset against parsed date.
+        let absolutes = possibleAbsolutes(plainDateTime, date.timeZone);
+        if (!absolutes.includes(ms)) {
+            throw new Error(`Offset ${offsetToString(date.offset)} is invalid for ${dateTimeToString(date)} in ${date.timeZone}`);
+        }
+    }
+    else {
+        // Convert to absolute and back to fix invalid times due to DST.
+        ms = toAbsolute(toCalendarDateTime(plainDateTime), date.timeZone, disambiguation);
+    }
+    return fromAbsolute(ms, date.timeZone);
+}
+/**
+ * Parses an ISO 8601 date and time string with a UTC offset (e.g. "2021-11-07T07:45:00Z"
+ * or "2021-11-07T07:45:00-07:00"). The result is converted to the provided time zone.
+ */
+export function parseAbsolute(value, timeZone) {
+    let m = value.match(ABSOLUTE_RE);
+    if (!m) {
+        throw new Error('Invalid ISO 8601 date time string: ' + value);
+    }
+    let year = parseNumber(m[1], -9999, 9999);
+    let era = year < 1 ? 'BC' : 'AD';
+    let date = new ZonedDateTime(era, year < 1 ? -year + 1 : year, parseNumber(m[2], 1, 12), 1, timeZone, 0, m[4] ? parseNumber(m[4], 0, 23) : 0, m[5] ? parseNumber(m[5], 0, 59) : 0, m[6] ? parseNumber(m[6], 0, 59) : 0, m[7] ? parseNumber(m[7], 0, Infinity) * 1000 : 0);
+    date.day = parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
+    if (m[8]) {
+        date.offset =
+            parseNumber(m[8], -23, 23) * 60 * 60 * 1000 + parseNumber(m[9] ?? '0', 0, 59) * 60 * 1000;
+    }
+    return toTimeZone(date, timeZone);
+}
+/**
+ * Parses an ISO 8601 date and time string with a UTC offset (e.g. "2021-11-07T07:45:00Z"
+ * or "2021-11-07T07:45:00-07:00"). The result is converted to the user's local time zone.
+ */
+export function parseAbsoluteToLocal(value) {
+    return parseAbsolute(value, getLocalTimeZone());
+}
+function parseNumber(value, min, max) {
+    let val = Number(value);
+    if (val < min || val > max) {
+        throw new RangeError(`Value out of range: ${min} <= ${val} <= ${max}`);
+    }
+    return val;
+}
+export function timeToString(time) {
+    return `${String(time.hour).padStart(2, '0')}:${String(time.minute).padStart(2, '0')}:${String(time.second).padStart(2, '0')}${time.millisecond ? String(time.millisecond / 1000).slice(1) : ''}`;
+}
+export function dateToString(date) {
+    let gregorianDate = toCalendar(date, new GregorianCalendar());
+    let year;
+    if (gregorianDate.era === 'BC') {
+        year =
+            gregorianDate.year === 1
+                ? '0000'
+                : '-' + String(Math.abs(1 - gregorianDate.year)).padStart(6, '00');
+    }
+    else {
+        year = String(gregorianDate.year).padStart(4, '0');
+    }
+    return `${year}-${String(gregorianDate.month).padStart(2, '0')}-${String(gregorianDate.day).padStart(2, '0')}`;
+}
+export function dateTimeToString(date) {
+    // @ts-ignore
+    return `${dateToString(date)}T${timeToString(date)}`;
+}
+function offsetToString(offset) {
+    let sign = Math.sign(offset) < 0 ? '-' : '+';
+    offset = Math.abs(offset);
+    let offsetHours = Math.floor(offset / (60 * 60 * 1000));
+    let offsetMinutes = Math.floor((offset % (60 * 60 * 1000)) / (60 * 1000));
+    let offsetSeconds = Math.floor(((offset % (60 * 60 * 1000)) % (60 * 1000)) / 1000);
+    let stringOffset = `${sign}${String(offsetHours).padStart(2, '0')}:${String(offsetMinutes).padStart(2, '0')}`;
+    if (offsetSeconds !== 0) {
+        stringOffset += `:${String(offsetSeconds).padStart(2, '0')}`;
+    }
+    return stringOffset;
+}
+export function zonedDateTimeToString(date) {
+    return `${dateTimeToString(date)}${offsetToString(date.offset)}[${date.timeZone}]`;
+}
+/**
+ * Parses an ISO 8601 duration string (e.g. "P3Y6M6W4DT12H30M5S").
+ *
+ * @param value An ISO 8601 duration string.
+ * @returns A DateTimeDuration object.
+ */
+export function parseDuration(value) {
+    const match = value.match(DATE_TIME_DURATION_RE);
+    if (!match) {
+        throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
+    }
+    const parseDurationGroup = (group, isNegative) => {
+        if (!group) {
+            return 0;
+        }
+        try {
+            const sign = isNegative ? -1 : 1;
+            return sign * Number(group.replace(',', '.'));
+        }
+        catch {
+            throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
+        }
+    };
+    const isNegative = !!match.groups?.negative;
+    const hasRequiredGroups = requiredDurationGroups.some(group => match.groups?.[group]);
+    if (!hasRequiredGroups) {
+        throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
+    }
+    const durationStringIncludesTime = match.groups?.time;
+    if (durationStringIncludesTime) {
+        const hasRequiredDurationTimeGroups = requiredDurationTimeGroups.some(group => match.groups?.[group]);
+        if (!hasRequiredDurationTimeGroups) {
+            throw new Error(`Invalid ISO 8601 Duration string: ${value}`);
+        }
+    }
+    const duration = {
+        years: parseDurationGroup(match.groups?.years, isNegative),
+        months: parseDurationGroup(match.groups?.months, isNegative),
+        weeks: parseDurationGroup(match.groups?.weeks, isNegative),
+        days: parseDurationGroup(match.groups?.days, isNegative),
+        hours: parseDurationGroup(match.groups?.hours, isNegative),
+        minutes: parseDurationGroup(match.groups?.minutes, isNegative),
+        seconds: parseDurationGroup(match.groups?.seconds, isNegative)
+    };
+    if (duration.hours !== undefined &&
+        duration.hours % 1 !== 0 &&
+        (duration.minutes || duration.seconds)) {
+        throw new Error(`Invalid ISO 8601 Duration string: ${value} - only the smallest unit can be fractional`);
+    }
+    if (duration.minutes !== undefined && duration.minutes % 1 !== 0 && duration.seconds) {
+        throw new Error(`Invalid ISO 8601 Duration string: ${value} - only the smallest unit can be fractional`);
+    }
+    return duration;
+}