@northguild/gmt 1.18.0 → 1.19.0

package/dist/internal/ediGrammar.js

@@ -0,0 +1,384 @@
+/** What each half of a value of each kind is: a period of dates is two dates. */
+const VALUE_KIND = {
+    date: "date",
+    time: "time",
+    dateTime: "dateTime",
+    offsetDateTime: "offsetDateTime",
+    datePeriod: "date",
+    dateTimePeriod: "dateTime",
+    dateRange: "date",
+    dateTimeRange: "dateTime",
+};
+/** Hour, 00–23. */
+const HH = "([01][0-9]|2[0-3])";
+/** Minute, 00–59. */
+const MI = "([0-5][0-9])";
+/** The regex source of each part: one capture group, the field's whole range of digits. */
+const FRAGMENT = {
+    // Century and year: four digits.
+    CCYY: "(\\d{4})",
+    // Month, 01–12.
+    MM: "(0[1-9]|1[0-2])",
+    // Day of month, 01–31.
+    DD: "(0[1-9]|[12][0-9]|3[01])",
+    HH,
+    MI,
+    // Second, 00–59. `60` does not match: GMT rejects a leap second, which Temporal would read as 59.
+    SS: "([0-5][0-9])",
+    // Element 337: "D = tenths (0-9)". One digit.
+    SD: "(\\d)",
+    // Element 337: "DD = hundredths (00-99)". Two digits.
+    SDD: "(\\d{2})",
+    // 2379 codes 205 and 208: "Z is plus (+) or minus (-)", then hours and minutes.
+    ZS: "([+-])",
+    ZH: HH,
+    ZM: MI,
+    // 2379 codes 303 and 304: a signed hour `[+-]HH`, 00–23 (Rec 7 ¶12), or the literals `UTC` and
+    // `GMT`. Nothing else is read: no UN/EDIFACT text defines a zone abbreviation, and a sign or a
+    // digit outside a valid signed hour (`+24`, `000`) is a broken offset (GMT rule; see the file
+    // header).
+    ZZZ: "([+-](?:[01][0-9]|2[0-3])|UTC|GMT)",
+};
+/** The `ZHHMM` offset of 2379 codes 205 and 208: sign, hours, minutes. */
+const ZHHMM = ["ZS", "ZH", "ZM"];
+/** The parts' sources joined, anchored, flagless; a period's halves joined by `join`. */
+function grammarOf(layout, join) {
+    const source = (parts) => parts.map((part) => FRAGMENT[part]).join("");
+    const end = layout.end === undefined ? "" : `${join}${source(layout.end)}`;
+    return new RegExp(`^${source(layout.start)}${end}$`);
+}
+/** A grammar table from a layout table, in the layout table's key order. */
+function grammarsOf(layouts, join) {
+    const grammars = {};
+    for (const code of Object.keys(layouts)) {
+        grammars[code] = grammarOf(layouts[code], join);
+    }
+    return grammars;
+}
+/**
+ * The 11 UNTDID 2379 codes GMT reads, in directory order: a date (`102`), a date and time
+ * (`203`, `204`), a date and time with a `ZHHMM` offset (`205`, `208`), a date and time with
+ * three zone characters (`303`, `304`), a time (`401`, `402`) and a period (`718`, `719`).
+ *
+ * Every other 2379 code returns the sentinel; the file header lists the ones cut and why.
+ */
+export const EDIFACT_DTM_FORMATS = [
+    "102",
+    "203",
+    "204",
+    "205",
+    "208",
+    "303",
+    "304",
+    "401",
+    "402",
+    "718",
+    "719",
+];
+/**
+ * UNTDID 2379 code → its kind and its value's parts. Typed kind by kind from the public unions,
+ * so a missing code, and a code filed under a kind its union does not name, both fail typecheck.
+ */
+const EDIFACT_DTM_LAYOUT = {
+    // 102 CCYYMMDD — "Calendar date: C = Century ; Y = Year ; M = Month ; D = Day."
+    "102": { kind: "date", start: ["CCYY", "MM", "DD"] },
+    // 203 CCYYMMDDHHMM — "Calendar date including time with minutes"
+    "203": { kind: "dateTime", start: ["CCYY", "MM", "DD", "HH", "MI"] },
+    // 204 CCYYMMDDHHMMSS — "Calendar date including time with seconds"
+    "204": { kind: "dateTime", start: ["CCYY", "MM", "DD", "HH", "MI", "SS"] },
+    // 205 CCYYMMDDHHMMZHHMM — "Calendar date including time and time zone expressed in hours and minutes."
+    "205": {
+        kind: "offsetDateTime",
+        start: ["CCYY", "MM", "DD", "HH", "MI", ...ZHHMM],
+    },
+    // 208 CCYYMMDDHHMMSSZHHMM — "Calendar date including time with seconds, with Time Zone: … Z = leading plus/minus sign, HHMM = difference to UTC in Hours and Minutes." (D.12A on)
+    "208": {
+        kind: "offsetDateTime",
+        start: ["CCYY", "MM", "DD", "HH", "MI", "SS", ...ZHHMM],
+    },
+    // 303 CCYYMMDDHHMMZZZ — "See 203 plus Z=Time zone."
+    "303": {
+        kind: "offsetDateTime",
+        start: ["CCYY", "MM", "DD", "HH", "MI", "ZZZ"],
+    },
+    // 304 CCYYMMDDHHMMSSZZZ — "See 204 plus Z=Time zone."
+    "304": {
+        kind: "offsetDateTime",
+        start: ["CCYY", "MM", "DD", "HH", "MI", "SS", "ZZZ"],
+    },
+    // 401 HHMM — "Time without seconds: H = Hour; m = Minute."
+    "401": { kind: "time", start: ["HH", "MI"] },
+    // 402 HHMMSS — "Time with seconds: H = Hour; m = Minute; s = Seconds."
+    "402": { kind: "time", start: ["HH", "MI", "SS"] },
+    // 718 CCYYMMDD-CCYYMMDD — "A period of time specified by giving the start date followed by the end date (both including century)."
+    "718": {
+        kind: "datePeriod",
+        start: ["CCYY", "MM", "DD"],
+        end: ["CCYY", "MM", "DD"],
+    },
+    // 719 CCYYMMDDHHMM-CCYYMMDDHHMM — "A period of time which includes the century, year, month, day, hour and minute."
+    "719": {
+        kind: "dateTimePeriod",
+        start: ["CCYY", "MM", "DD", "HH", "MI"],
+        end: ["CCYY", "MM", "DD", "HH", "MI"],
+    },
+};
+/**
+ * UNTDID 2379 code → the anchored, flagless grammar of its value. A period's halves are run
+ * together with nothing between them: every directory read gives a period "without hyphen" (the
+ * file header quotes each entry).
+ */
+export const EDIFACT_DTM_GRAMMAR = grammarsOf(EDIFACT_DTM_LAYOUT, "");
+/**
+ * The 10 X12 1250 codes GMT reads: a date (`D8`, `DB`), a date and time (`DT`, `RTS`), a time
+ * (`TM`, `TS`), a range of dates (`RD8`, `RD`) and a range of date-times (`RDT`, `DTS`).
+ *
+ * The other 32 of the 42 codes return the sentinel; the file header lists the ones cut and why.
+ * `TS` is also a code of data element 623, with an unrelated meaning there.
+ */
+export const X12_DATE_TIME_PERIOD_FORMATS = ["D8", "DB", "DT", "RTS", "TM", "TS", "RD8", "RD", "RDT", "DTS"];
+/**
+ * X12 1250 code → its kind and its value's parts. Typed kind by kind from the public unions, so
+ * a missing code, and a code filed under a kind its union does not name, both fail typecheck.
+ */
+const X12_DATE_TIME_PERIOD_LAYOUT = {
+    // D8 CCYYMMDD — "Date Expressed in Format CCYYMMDD"
+    D8: { kind: "date", start: ["CCYY", "MM", "DD"] },
+    // DB MMDDCCYY — "Date Expressed in Format MMDDCCYY"
+    DB: { kind: "date", start: ["MM", "DD", "CCYY"] },
+    // DT CCYYMMDDHHMM — "Date and Time Expressed in Format CCYYMMDDHHMM"
+    DT: { kind: "dateTime", start: ["CCYY", "MM", "DD", "HH", "MI"] },
+    // RTS CCYYMMDDHHMMSS — "Date and Time Expressed in Format CCYYMMDDHHMMSS" (one date-time despite the R)
+    RTS: { kind: "dateTime", start: ["CCYY", "MM", "DD", "HH", "MI", "SS"] },
+    // TM HHMM — "Time Expressed in Format HHMM"
+    TM: { kind: "time", start: ["HH", "MI"] },
+    // TS HHMMSS — "Time Expressed in Format HHMMSS"
+    TS: { kind: "time", start: ["HH", "MI", "SS"] },
+    // RD8 CCYYMMDD-CCYYMMDD — "Range of Dates Expressed in Format CCYYMMDD-CCYYMMDD"
+    RD8: {
+        kind: "dateRange",
+        start: ["CCYY", "MM", "DD"],
+        end: ["CCYY", "MM", "DD"],
+    },
+    // RD MMDDCCYY-MMDDCCYY — "Range of Dates Expressed in Format MMDDCCYY-MMDDCCYY"
+    RD: {
+        kind: "dateRange",
+        start: ["MM", "DD", "CCYY"],
+        end: ["MM", "DD", "CCYY"],
+    },
+    // RDT CCYYMMDDHHMM-CCYYMMDDHHMM — "Range of Date and Time, Expressed in Format CCYYMMDDHHMM-CCYYMMDDHHMM"
+    RDT: {
+        kind: "dateTimeRange",
+        start: ["CCYY", "MM", "DD", "HH", "MI"],
+        end: ["CCYY", "MM", "DD", "HH", "MI"],
+    },
+    // DTS CCYYMMDDHHMMSS-CCYYMMDDHHMMSS — "Range of Date and Time Expressed in Format CCYYMMDDHHMMSS-CCYYMMDDHHMMSS" (a range despite having no R)
+    DTS: {
+        kind: "dateTimeRange",
+        start: ["CCYY", "MM", "DD", "HH", "MI", "SS"],
+        end: ["CCYY", "MM", "DD", "HH", "MI", "SS"],
+    },
+};
+/**
+ * X12 1250 code → the anchored, flagless grammar of its value. A range's halves are joined by
+ * exactly one hyphen, the one X12 transmits.
+ */
+export const X12_DATE_TIME_PERIOD_GRAMMAR = grammarsOf(X12_DATE_TIME_PERIOD_LAYOUT, "-");
+/**
+ * X12 data element 337 (Time), the time element of `AT7`, `G62` and `DTM-03`: "Time expressed in
+ * 24-hour clock time as follows: HHMM, or HHMMSS, or HHMMSSD, or HHMMSSDD, where H = hours
+ * (00-23), M = minutes (00-59), S = integer seconds (00-59) and DD = decimal seconds; decimal
+ * seconds are expressed as follows: D = tenths (0-9) and DD = hundredths (00-99)", length 4 to 8
+ * (release 005010, https://www.stedi.com/edi/x12-005010/element/337).
+ *
+ * Mask → its parts, keyed by the element's own four masks in the order the definition gives
+ * them. Not a 1250 table: the element has no format qualifier, its four- and six-digit forms
+ * coincide with `TM` and `TS`, and no 1250 code holds decimal seconds. Typed from the public
+ * union, so a missing form fails typecheck.
+ */
+export const X12_TIME_ELEMENT_LAYOUT = {
+    // HHMM — "H = hours (00-23), M = minutes (00-59)"
+    HHMM: { kind: "time", start: ["HH", "MI"] },
+    // HHMMSS — "S = integer seconds (00-59)"
+    HHMMSS: { kind: "time", start: ["HH", "MI", "SS"] },
+    // HHMMSSD — "D = tenths (0-9)"
+    HHMMSSD: { kind: "time", start: ["HH", "MI", "SS", "SD"] },
+    // HHMMSSDD — "DD = hundredths (00-99)"
+    HHMMSSDD: { kind: "time", start: ["HH", "MI", "SS", "SDD"] },
+};
+/**
+ * The four forms of X12 data element 337, shortest first: the layout table's own keys, so the
+ * list cannot name a form the table lacks.
+ */
+export const X12_TIME_ELEMENT_FORMS = Object.keys(X12_TIME_ELEMENT_LAYOUT);
+/**
+ * Element 337 form → the anchored, flagless grammar of its value. The four masks have four
+ * lengths (4, 6, 7 and 8 digits), so a value fits one form or none, and the reader needs no
+ * qualifier to tell them apart.
+ */
+export const X12_TIME_ELEMENT_GRAMMAR = grammarsOf(X12_TIME_ELEMENT_LAYOUT, "");
+/**
+ * The milliseconds one unit of each decimal-seconds part is worth: a tenth of a second is 100
+ * and a hundredth is 10. The reader multiplies by it and the writer divides by it, so the two
+ * agree on what `D` and `DD` mean.
+ */
+export const MILLISECONDS_PER_DECIMAL_SECOND = { SD: 100, SDD: 10 };
+/**
+ * Look a form of X12 data element 337 up by its mask, for the writer
+ * (`writeX12TimeElement`), whose caller names the form. The reader (`readX12Time`) is given no
+ * form: it tries the grammar of each form in the same table.
+ *
+ * - Matching is exact and by own key, so `"__proto__"`, `" HHMM"` and `"hhmm"` are not forms.
+ * - Null for a data element 1250 code (`TM`, `TS`): a qualifier is not a mask.
+ * - Null for a non-string argument.
+ *
+ * @param form the element's mask: `HHMM`, `HHMMSS`, `HHMMSSD` or `HHMMSSDD`
+ * @returns the form's parts in mask order, as a single time, or null
+ *
+ * @example x12TimeElementLayoutOf("HHMMSSDD") // { kind: "time", start: ["HH", "MI", "SS", "SDD"] }
+ * @example x12TimeElementLayoutOf("TS") // null (a 1250 code, not a mask)
+ * @example x12TimeElementLayoutOf("__proto__") // null
+ */
+export function x12TimeElementLayoutOf(form) {
+    return typeof form === "string" &&
+        Object.hasOwn(X12_TIME_ELEMENT_LAYOUT, form)
+        ? X12_TIME_ELEMENT_LAYOUT[form]
+        : null;
+}
+/**
+ * The 56 X12 623 codes, release 008010, in dictionary order: `01`–`12` (UTC+1 … UTC+12), `13`–`24`
+ * (UTC−12 … UTC−1, descending), `25`–`29` (the half-hour offsets, added in release 006010), then
+ * the 27 letter codes. Release 005010 has the 51 codes other than `25`–`29`. Membership is by
+ * this list, never by shape. `TS`, `TT`, `CD` and `MD` are also codes of data element 1250, with
+ * unrelated meanings there.
+ */
+export const X12_TIME_CODES = [
+    // fallow-ignore-next-line code-duplication -- the 56 DE 623 codes as a runtime list; `X12TimeCode` in types/edi.ts is the same enumeration in type position
+    "01",
+    "02",
+    "03",
+    "04",
+    "05",
+    "06",
+    "07",
+    "08",
+    "09",
+    "10",
+    "11",
+    "12",
+    "13",
+    "14",
+    "15",
+    "16",
+    "17",
+    "18",
+    "19",
+    "20",
+    "21",
+    "22",
+    "23",
+    "24",
+    "25",
+    "26",
+    "27",
+    "28",
+    "29",
+    "AD",
+    "AS",
+    "AT",
+    "CD",
+    "CS",
+    "CT",
+    "ED",
+    "ES",
+    "ET",
+    "GM",
+    "HD",
+    "HS",
+    "HT",
+    "LT",
+    "MD",
+    "MS",
+    "MT",
+    "ND",
+    "NS",
+    "NT",
+    "PD",
+    "PS",
+    "PT",
+    "TD",
+    "TS",
+    "TT",
+    "UT",
+];
+const EDI_CODE_TABLES = {
+    edifact: {
+        layouts: EDIFACT_DTM_LAYOUT,
+        grammars: EDIFACT_DTM_GRAMMAR,
+        // UNTDID 2379, every directory read (twelve, from D.93A to D.22B): a period is given
+        // "without hyphen".
+        rangeSeparator: "",
+    },
+    x12: {
+        layouts: X12_DATE_TIME_PERIOD_LAYOUT,
+        grammars: X12_DATE_TIME_PERIOD_GRAMMAR,
+        // X12 1250: each range definition gives the format with its hyphen.
+        rangeSeparator: "-",
+    },
+};
+/**
+ * Look a format code up in its standard's tables: the one lookup the classifier, the reader and
+ * the writer share.
+ *
+ * - Matching is exact and by own key, so `"__proto__"`, `" 102"` and `"d8"` are not codes.
+ * - Null for a code that is not read (`101`, `209`, `D6`, `UN`), like an unknown code.
+ * - Null for a standard that is not `"edifact"` or `"x12"`, and for a non-string argument.
+ *
+ * @param standard which element the code belongs to
+ * @param code the 2379 or 1250 format code
+ * @returns the code's kind, layout, grammar and range separator, or null
+ *
+ * @example ediCodeOf("edifact", "718") // { kind: "datePeriod", valueKind: "date", layout: { kind: "datePeriod", start: ["CCYY", "MM", "DD"], end: [...] }, grammar: /^…$/, rangeSeparator: "" }
+ * @example ediCodeOf("x12", "RD8") // { kind: "dateRange", valueKind: "date", layout: {...}, grammar: /^…$/, rangeSeparator: "-" }
+ * @example ediCodeOf("edifact", "101") // null (a two-digit year: not read)
+ * @example ediCodeOf("edifact", "D8") // null (an X12 code)
+ */
+export function ediCodeOf(standard, code) {
+    if (typeof standard !== "string" || typeof code !== "string") {
+        return null;
+    }
+    if (!Object.hasOwn(EDI_CODE_TABLES, standard)) {
+        return null;
+    }
+    const table = EDI_CODE_TABLES[standard];
+    if (!Object.hasOwn(table.layouts, code)) {
+        return null;
+    }
+    const layout = table.layouts[code];
+    const grammar = table.grammars[code];
+    return {
+        kind: layout.kind,
+        valueKind: VALUE_KIND[layout.kind],
+        layout,
+        grammar,
+        rangeSeparator: table.rangeSeparator,
+    };
+}
+/**
+ * Look a format code up as a code of one kind: null unless the code is in its standard's tables
+ * under exactly that kind. Each public function names its own kind here, so a code of another
+ * kind (`203` given to a date function) is refused before any value is read.
+ *
+ * @param standard which element the code belongs to
+ * @param kind the kind of value the calling function reads or writes
+ * @param code the 2379 or 1250 format code
+ * @returns the code's entry, or null when the code is not one of that kind
+ *
+ * @example ediCodeOfKind("edifact", "date", "102") // { kind: "date", … }
+ * @example ediCodeOfKind("edifact", "date", "203") // null (a date-time code)
+ * @example ediCodeOfKind("x12", "dateRange", "RD8") // { kind: "dateRange", … }
+ */
+export function ediCodeOfKind(standard, kind, code) {
+    const entry = ediCodeOf(standard, code);
+    return entry !== null && entry.kind === kind ? entry : null;
+}

package/dist/internal/englishCalendarNames.d.ts

@@ -5,7 +5,9 @@ export declare const ENGLISH_MONTH_NAMES: readonly ["Jan", "Feb", "Mar", "Apr",
  * The `Mon, 15 Jul 2024 12:00:00` stem RFC 5322 date-time and RFC 9110 IMF-fixdate share: English
  * day and month names, zero-padded fields, read from the date-time's own wall clock.
  *
- * @param zdt the date-time; the caller has already rejected a year outside 0-9999
+ * @param zdt the date-time; the caller has already rejected a year its grammar cannot hold: a
+ *   negative one for RFC 5322 (`year = 4*DIGIT`, so five digits are written in full), and any
+ *   outside 0000–9999 for RFC 9110 (`year = 4DIGIT`)
  * @returns the stem, without a zone or `GMT` suffix
  * @example englishDateTimeStem(Temporal.ZonedDateTime.from("2024-07-15T12:00:05+00:00[UTC]")) // "Mon, 15 Jul 2024 12:00:05"
  * @example englishDateTimeStem(Temporal.ZonedDateTime.from("0099-01-03T04:05:06+00:00[UTC]")) // "Sat, 03 Jan 0099 04:05:06"

package/dist/internal/englishCalendarNames.js

@@ -32,7 +32,9 @@ export const ENGLISH_MONTH_NAMES = [
  * The `Mon, 15 Jul 2024 12:00:00` stem RFC 5322 date-time and RFC 9110 IMF-fixdate share: English
  * day and month names, zero-padded fields, read from the date-time's own wall clock.
  *
- * @param zdt the date-time; the caller has already rejected a year outside 0-9999
+ * @param zdt the date-time; the caller has already rejected a year its grammar cannot hold: a
+ *   negative one for RFC 5322 (`year = 4*DIGIT`, so five digits are written in full), and any
+ *   outside 0000–9999 for RFC 9110 (`year = 4DIGIT`)
  * @returns the stem, without a zone or `GMT` suffix
  * @example englishDateTimeStem(Temporal.ZonedDateTime.from("2024-07-15T12:00:05+00:00[UTC]")) // "Mon, 15 Jul 2024 12:00:05"
  * @example englishDateTimeStem(Temporal.ZonedDateTime.from("0099-01-03T04:05:06+00:00[UTC]")) // "Sat, 03 Jan 0099 04:05:06"

package/dist/internal/freeTimeLedger.d.ts

@@ -13,6 +13,11 @@ export declare const MAX_WALKED_DAYS = 10000;
  * are counted against, `null` when every local day after expiry is charged.
  */
 export type FreeTimeTerms = {
+    /**
+     * The counting zone as the caller wrote it: a time zone identifier or a stored UTC offset
+     * (`±HH:MM[:SS]`), so always readable by `zoneFrame`. The walk's zoned values are placed with
+     * `frameZoned` and turned back with `frameInstant`.
+     */
     timeZone: string;
     firstDay: "eventDay" | "nextDay";
     calendar: ResolvedBusinessCalendar | null;

package/dist/internal/freeTimeLedger.js

@@ -1,8 +1,9 @@
 import { Temporal } from "@js-temporal/polyfill";
-import { isValidTimeZone } from "../zoned/validate/isValidTimeZone.js";
 import { isBusinessDate, parseBusinessCalendar, } from "./businessCalendar.js";
 import { isObject } from "./isObject.js";
 import { nextZonedBucketStart, zonedUnitStart } from "./zonedBucket.js";
+import { zoneFrame } from "./zoneFrame.js";
+import { certainlyTouchesMoreBuckets } from "./zoneBucketCap.js";
 /**
  * Local days a free-time walk may visit before giving up: the same cap as `bucketRange`. A
  * valid business calendar leaves at least one working day a week, so a working-day count needs
@@ -34,7 +35,7 @@ function readFreeTimeTerms(options, readChargeBasis = false) {
     if (firstDay !== "eventDay" && firstDay !== "nextDay") {
         return null;
     }
-    if (typeof timeZone !== "string" || !isValidTimeZone(timeZone)) {
+    if (typeof timeZone !== "string" || zoneFrame(timeZone) === null) {
         return null;
     }
     const needsCalendar = basis === "working" || (readChargeBasis && chargeBasis === "working");
@@ -209,6 +210,14 @@ export function walkFreeTime(clockStart, freeDays, terms, clockEnd) {
     let expiresAt = null;
     let expiryPending = false;
     let skipEventDay = terms.firstDay === "nextDay";
+    // A dwell that certainly touches more local days than the walk may visit ends it with the
+    // sentinel anyway: the walk needs one visit for every day the dwell touches, and one more to
+    // pass it. Deciding that from the span skips a 10,000-day walk. When it is not certain, the walk
+    // runs as before, so no answer changes.
+    if (clockEnd !== undefined &&
+        certainlyTouchesMoreBuckets(clockStart, clockEnd, "day", MAX_WALKED_DAYS)) {
+        return null;
+    }
     let day = localDayOf(clockStart);
     if (day === null) {
         return null;

package/dist/internal/index.d.ts

@@ -15,6 +15,7 @@ export { isValidEpochNanoseconds, MAX_EPOCH_NANOSECOND_DIGITS, } from "./epochNa
 export { dateCycleFieldBounds } from "./dateCycleFieldBounds.js";
 export { timeCycleFieldBounds } from "./timeCycleFieldBounds.js";
 export { durationUntilString } from "./durationUntilString.js";
+export { EDIFACT_DTM_FORMATS, X12_DATE_TIME_PERIOD_FORMATS, X12_TIME_CODES, } from "./ediGrammar.js";
 export { exactDurationNanoseconds, nonNegativeExactDurationNanoseconds, } from "./exactDuration.js";
 export { type ExactMoment, readExactMoment, writeExactMoment, } from "./exactMoment.js";
 export { formatDateInCalendar } from "./formatDateInCalendar.js";
@@ -45,9 +46,10 @@ export { plainDateAdd } from "./plainDateAdd.js";
 export { parsePunctualityTolerance, punctualityOf } from "./punctuality.js";
 export { plainDateUntil } from "./plainDateUntil.js";
 export { resolveDateTimeUnit } from "./resolveDateTimeUnit.js";
+export { readDurationUnits } from "./readDurationUnits.js";
+export { DATE_FIELDS, DATE_TIME_FIELDS, readSetFields, TIME_FIELDS, } from "./readSetFields.js";
 export { resolveDurationUnit } from "./resolveDurationUnit.js";
 export { resolveOverflow } from "./resolveOverflow.js";
-export { resolveRelativeRounding } from "./resolveRelativeRounding.js";
 export { parseUnixEpochInterval, parseUnixEpochIntervalList, parseUnixEpochIntervalPair, parseUnixEpochValue, } from "./unixEpochValue.js";
 export { tileByUnit } from "./splitStep.js";
 export { parseTimestampEvents } from "./timestampEvents.js";
@@ -56,5 +58,6 @@ export { countZonedLocalDates } from "./zonedLocalDates.js";
 export { zonedDateTimeFrom } from "./zonedWallClock.js";
 export { wallClockAtOffset } from "./wallClockAtOffset.js";
 export { durationCompare, durationRound, durationTotal, isCalendarDifferenceAcrossZones, plainUntilWithRounding, zonedUntil, } from "./zonedWallClockDifference.js";
-export { addToZoned, addToZonedDisambiguated, plainToZoned, roundZonedDateTime, subtractFromZoned, withZonedFields, zonedHoursInDay, zonedNextTransition, zonedPreviousTransition, zonedStartOfDay, } from "./zonedWallClockOperations.js";
+export { addToZoned, addToZonedDisambiguated, plainToZoned, roundZonedDateTime, subtractFromZoned, withZonedFields, zonedHoursInDay, zonedNextTransition, zonedStartOfDay, } from "./zonedWallClockOperations.js";
 export { zonelessCalendarDate } from "./zonelessCalendarDate.js";
+export { frameInstant, frameOffset, frameWallClock, frameZoned, instantOfWallClock, normalizeZoneFrame, zoneFrame, } from "./zoneFrame.js";

package/dist/internal/index.js

@@ -15,6 +15,11 @@ export { isValidEpochNanoseconds, MAX_EPOCH_NANOSECOND_DIGITS, } from "./epochNa
 export { dateCycleFieldBounds } from "./dateCycleFieldBounds.js";
 export { timeCycleFieldBounds } from "./timeCycleFieldBounds.js";
 export { durationUntilString } from "./durationUntilString.js";
+// The EDI readers (./ediDateTimeFields) and writers (./ediDateTimeWriter) are deliberately not
+// re-exported here: they import `instant/convert/toOffsetInstant`, which reads this barrel at
+// module top level, so a barrel entry would close a cycle. Import each from its own file
+// ("../../internal/ediDateTimeFields", "../../internal/ediDateTimeWriter").
+export { EDIFACT_DTM_FORMATS, X12_DATE_TIME_PERIOD_FORMATS, X12_TIME_CODES, } from "./ediGrammar.js";
 export { exactDurationNanoseconds, nonNegativeExactDurationNanoseconds, } from "./exactDuration.js";
 export { readExactMoment, writeExactMoment, } from "./exactMoment.js";
 export { formatDateInCalendar } from "./formatDateInCalendar.js";
@@ -45,9 +50,10 @@ export { plainDateAdd } from "./plainDateAdd.js";
 export { parsePunctualityTolerance, punctualityOf } from "./punctuality.js";
 export { plainDateUntil } from "./plainDateUntil.js";
 export { resolveDateTimeUnit } from "./resolveDateTimeUnit.js";
+export { readDurationUnits } from "./readDurationUnits.js";
+export { DATE_FIELDS, DATE_TIME_FIELDS, readSetFields, TIME_FIELDS, } from "./readSetFields.js";
 export { resolveDurationUnit } from "./resolveDurationUnit.js";
 export { resolveOverflow } from "./resolveOverflow.js";
-export { resolveRelativeRounding } from "./resolveRelativeRounding.js";
 export { parseUnixEpochInterval, parseUnixEpochIntervalList, parseUnixEpochIntervalPair, parseUnixEpochValue, } from "./unixEpochValue.js";
 export { tileByUnit } from "./splitStep.js";
 export { parseTimestampEvents } from "./timestampEvents.js";
@@ -56,5 +62,6 @@ export { countZonedLocalDates } from "./zonedLocalDates.js";
 export { zonedDateTimeFrom } from "./zonedWallClock.js";
 export { wallClockAtOffset } from "./wallClockAtOffset.js";
 export { durationCompare, durationRound, durationTotal, isCalendarDifferenceAcrossZones, plainUntilWithRounding, zonedUntil, } from "./zonedWallClockDifference.js";
-export { addToZoned, addToZonedDisambiguated, plainToZoned, roundZonedDateTime, subtractFromZoned, withZonedFields, zonedHoursInDay, zonedNextTransition, zonedPreviousTransition, zonedStartOfDay, } from "./zonedWallClockOperations.js";
+export { addToZoned, addToZonedDisambiguated, plainToZoned, roundZonedDateTime, subtractFromZoned, withZonedFields, zonedHoursInDay, zonedNextTransition, zonedStartOfDay, } from "./zonedWallClockOperations.js";
 export { zonelessCalendarDate } from "./zonelessCalendarDate.js";
+export { frameInstant, frameOffset, frameWallClock, frameZoned, instantOfWallClock, normalizeZoneFrame, zoneFrame, } from "./zoneFrame.js";

package/dist/internal/intervalNanoseconds.js

@@ -1,4 +1,5 @@
 import { parseInstantNanoseconds } from "./instantNanoseconds.js";
+import { isObject } from "./isObject.js";
 /**
  * Parse a candidate `Interval` to epoch nanoseconds, or `null` when it is not one.
  *
@@ -13,7 +14,7 @@ import { parseInstantNanoseconds } from "./instantNanoseconds.js";
  * @example parseIntervalNanoseconds({ start: "1970-01-01T00:00:01Z", end: "1970-01-01T00:00:00Z" }) // null — inverted
  */
 export function parseIntervalNanoseconds(value) {
-    if (typeof value !== "object" || value === null) {
+    if (!isObject(value)) {
         return null;
     }
     const { start: startText, end: endText } = value;

package/dist/internal/isObject.d.ts

@@ -1,18 +1,25 @@
 /**
- * Type guard for a non-null object (arrays included), the shape an options bag or a props
- * object must have before it is destructured. A default parameter covers only `undefined`, so a
- * `null` or primitive argument reaches the destructure and throws `TypeError` without this check.
+ * Type guard for an ECMAScript Object (ECMA-262 §6.1.7): a non-null object, arrays included, or a
+ * function. It is the shape an options bag, a property bag or a props object must have before it
+ * is destructured. A default parameter covers only `undefined`, so a `null` or primitive argument
+ * reaches the destructure and throws `TypeError` without this check.
+ *
+ * A function is an Object, so it is accepted wherever Temporal and ECMA-402 accept one:
+ * GetOptionsObject returns any Object, and the polyfill reads
+ * `Object.assign(() => 0, { largestUnit: "hours" })` as `{ largestUnit: "hours" }`. Checking
+ * `typeof value === "object"` alone wrongly refused it.
  *
  * @param value candidate
  * @example isObject({ smallestUnit: "day" }) // true
+ * @example isObject(Object.assign(() => 0, { smallestUnit: "day" })) // true
  * @example isObject(null) // false
  * @example isObject("day") // false
- * @returns whether `value` is a non-null object
+ * @returns whether `value` is an Object
  */
 export declare function isObject(value: unknown): value is object;
 /**
  * Whether an `options` argument is acceptable under Temporal GetOptionsObject: omitted
- * (`undefined`, the defaults) or an object. `null`, a string, a number or a boolean is a TypeError
+ * (`undefined`, the defaults) or an Object, a function included. `null`, a string, a number or a boolean is a TypeError
  * there, so a function that takes an options bag returns its sentinel for it rather than silently
  * reading the defaults (e.g. a legacy positional unit string such as `"seconds"`).
  *
@@ -21,6 +28,6 @@ export declare function isObject(value: unknown): value is object;
  * @example isOptionsArgument({ overflow: "reject" }) // true
  * @example isOptionsArgument(null) // false
  * @example isOptionsArgument("seconds") // false
- * @returns whether `options` is `undefined` or a non-null object
+ * @returns whether `options` is `undefined` or an Object
  */
 export declare function isOptionsArgument(options: unknown): boolean;

package/dist/internal/isObject.js

@@ -1,20 +1,27 @@
 /**
- * Type guard for a non-null object (arrays included), the shape an options bag or a props
- * object must have before it is destructured. A default parameter covers only `undefined`, so a
- * `null` or primitive argument reaches the destructure and throws `TypeError` without this check.
+ * Type guard for an ECMAScript Object (ECMA-262 §6.1.7): a non-null object, arrays included, or a
+ * function. It is the shape an options bag, a property bag or a props object must have before it
+ * is destructured. A default parameter covers only `undefined`, so a `null` or primitive argument
+ * reaches the destructure and throws `TypeError` without this check.
+ *
+ * A function is an Object, so it is accepted wherever Temporal and ECMA-402 accept one:
+ * GetOptionsObject returns any Object, and the polyfill reads
+ * `Object.assign(() => 0, { largestUnit: "hours" })` as `{ largestUnit: "hours" }`. Checking
+ * `typeof value === "object"` alone wrongly refused it.
  *
  * @param value candidate
  * @example isObject({ smallestUnit: "day" }) // true
+ * @example isObject(Object.assign(() => 0, { smallestUnit: "day" })) // true
  * @example isObject(null) // false
  * @example isObject("day") // false
- * @returns whether `value` is a non-null object
+ * @returns whether `value` is an Object
  */
 export function isObject(value) {
-    return typeof value === "object" && value !== null;
+    return ((typeof value === "object" && value !== null) || typeof value === "function");
 }
 /**
  * Whether an `options` argument is acceptable under Temporal GetOptionsObject: omitted
- * (`undefined`, the defaults) or an object. `null`, a string, a number or a boolean is a TypeError
+ * (`undefined`, the defaults) or an Object, a function included. `null`, a string, a number or a boolean is a TypeError
  * there, so a function that takes an options bag returns its sentinel for it rather than silently
  * reading the defaults (e.g. a legacy positional unit string such as `"seconds"`).
  *
@@ -23,7 +30,7 @@ export function isObject(value) {
  * @example isOptionsArgument({ overflow: "reject" }) // true
  * @example isOptionsArgument(null) // false
  * @example isOptionsArgument("seconds") // false
- * @returns whether `options` is `undefined` or a non-null object
+ * @returns whether `options` is `undefined` or an Object
  */
 export function isOptionsArgument(options) {
     return options === undefined || isObject(options);

package/dist/internal/isoYearString.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Write an ISO year as Temporal writes it at the head of a date string (TC39 Temporal
+ * `PadISOYear ( y )`, §3.5.10): four digits from 0000 to 9999, otherwise a sign and six digits.
+ *
+ * A year written any other way does not read back. `"10000-01-01"` and `"00-5-01-01"` are not ISO
+ * 8601 or Temporal strings, and `isValidDate` rejects both; `"+010000-01-01"` and
+ * `"-000005-01-01"` are what `Temporal.PlainDate#toString` writes.
+ *
+ * - Every function that returns a year on its own writes it this way.
+ * - Where a Temporal value is at hand, let its own `toString` write the whole date. This is for a
+ *   year on its own, or a date assembled from fields with no Temporal value behind them.
+ *
+ * @param year an ISO year, an integer
+ * @returns the year as `YYYY` or `±YYYYYY`
+ *
+ * @example isoYearString(2024) // "2024"
+ * @example isoYearString(5) // "0005"
+ * @example isoYearString(10000) // "+010000"
+ * @example isoYearString(-5) // "-000005"
+ */
+export declare function isoYearString(year: number): string;