@northguild/gmt 1.18.0 → 1.20.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

@@ -1,11 +1,13 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 export declare const ENGLISH_WEEKDAY_NAMES: readonly ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
 export declare const ENGLISH_MONTH_NAMES: readonly ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
 /**
  * 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/epochDay.d.ts

@@ -0,0 +1,41 @@
+import type { Temporal } from "./temporal.js";
+/** Days in an ISO week. */
+export declare const ISO_WEEKDAYS = 7;
+/**
+ * TC39 `ISODateWithinLimits`: -271821-04-19 and +275760-09-13, counted in days from 1970-01-01,
+ * are the first and last dates a PlainDate holds.
+ */
+export declare const MIN_EPOCH_DAY = -100000001;
+export declare const MAX_EPOCH_DAY = 100000000;
+/**
+ * Days from 1970-01-01 to an ISO date, in the proleptic Gregorian calendar of ECMA-262 §21.4.1
+ * that Temporal's ISO calendar extends. Years run from March so the leap day ends each one.
+ */
+export declare function epochDayOf(year: number, month: number, day: number): number;
+/** The ISO year, month and day `epochDay` days from 1970-01-01 — `epochDayOf` inverted. */
+export declare function isoFieldsOf(epochDay: number): [number, number, number];
+/** `Temporal.PlainDate#toString` for an ISO date: the format `mergeCalendars` returns its holidays in. */
+export declare function isoDateString(epochDay: number): string;
+/**
+ * Days from 1970-01-01 to `date`, an ISO-calendar date. Any other calendar throws a
+ * `RangeError`, which callers turn into their sentinel: its year, month and day are not ISO
+ * fields, so the arithmetic below would silently walk from the wrong day.
+ */
+export declare function epochDayOfDate(date: Temporal.PlainDate): number;
+/**
+ * ISO weekday of an epoch day, Monday 1 to Sunday 7. Follows ECMA-262 `WeekDay` (day 0, 1970-01-01,
+ * is a Thursday) renumbered as Temporal's `ISODayOfWeek` does, Sunday 7 rather than 0.
+ */
+export declare function isoWeekdayOf(epochDay: number): number;
+/** Index of the first element of `days` (sorted ascending) that is >= `epochDay`. */
+export declare function lowerBound(days: Int32Array, epochDay: number): number;
+/** Members of `days` (sorted ascending) within [from, to]; 0 when from > to. */
+export declare function countWithin(days: Int32Array, from: number, to: number): number;
+/** True when `epochDay` is a member of `days` (sorted ascending). */
+export declare function hasEpochDay(days: Int32Array, epochDay: number): boolean;
+/**
+ * `days` ascending with repeats removed. Returns `days` itself when it is already strictly
+ * ascending, so a list written in date order costs one pass and no copy; otherwise sorts a copy
+ * numerically.
+ */
+export declare function sortedUnique(days: Int32Array): Int32Array;

package/dist/internal/epochDay.js

@@ -0,0 +1,129 @@
+import { isoYearString } from "./isoYearString.js";
+/** Days in an ISO week. */
+export const ISO_WEEKDAYS = 7;
+/**
+ * TC39 `ISODateWithinLimits`: -271821-04-19 and +275760-09-13, counted in days from 1970-01-01,
+ * are the first and last dates a PlainDate holds.
+ */
+export const MIN_EPOCH_DAY = -100_000_001;
+export const MAX_EPOCH_DAY = 100_000_000;
+/** 1970-01-01 was a Thursday, ISO weekday 4. */
+const EPOCH_WEEKDAY_OFFSET = 3;
+/** Days in a 400-year cycle of the proleptic Gregorian calendar. */
+const DAYS_PER_400_YEARS = 146_097;
+/** Days from 0000-03-01, the start of a March-based year, to 1970-01-01. */
+const DAYS_FROM_MARCH_0000_TO_EPOCH = 719_468;
+/**
+ * Days from 1970-01-01 to an ISO date, in the proleptic Gregorian calendar of ECMA-262 §21.4.1
+ * that Temporal's ISO calendar extends. Years run from March so the leap day ends each one.
+ */
+export function epochDayOf(year, month, day) {
+    const marchYear = month <= 2 ? year - 1 : year;
+    const cycle = Math.floor(marchYear / 400);
+    const yearOfCycle = marchYear - cycle * 400;
+    const dayOfYear = Math.floor((153 * ((month + 9) % 12) + 2) / 5) + day - 1;
+    const dayOfCycle = yearOfCycle * 365 +
+        Math.floor(yearOfCycle / 4) -
+        Math.floor(yearOfCycle / 100) +
+        dayOfYear;
+    return (cycle * DAYS_PER_400_YEARS + dayOfCycle - DAYS_FROM_MARCH_0000_TO_EPOCH);
+}
+/** The ISO year, month and day `epochDay` days from 1970-01-01 — `epochDayOf` inverted. */
+export function isoFieldsOf(epochDay) {
+    const shifted = epochDay + DAYS_FROM_MARCH_0000_TO_EPOCH;
+    const cycle = Math.floor(shifted / DAYS_PER_400_YEARS);
+    const dayOfCycle = shifted - cycle * DAYS_PER_400_YEARS;
+    // Remove the leap days of every 4th, 100th and 400th year before dividing into 365-day years.
+    const yearOfCycle = Math.floor((dayOfCycle -
+        Math.floor(dayOfCycle / 1460) +
+        Math.floor(dayOfCycle / 36_524) -
+        Math.floor(dayOfCycle / (DAYS_PER_400_YEARS - 1))) /
+        365);
+    const dayOfYear = dayOfCycle -
+        (365 * yearOfCycle +
+            Math.floor(yearOfCycle / 4) -
+            Math.floor(yearOfCycle / 100));
+    const monthFromMarch = Math.floor((5 * dayOfYear + 2) / 153);
+    const day = dayOfYear - Math.floor((153 * monthFromMarch + 2) / 5) + 1;
+    const month = monthFromMarch < 10 ? monthFromMarch + 3 : monthFromMarch - 9;
+    const year = yearOfCycle + cycle * 400 + (month <= 2 ? 1 : 0);
+    return [year, month, day];
+}
+/** `Temporal.PlainDate#toString` for an ISO date: the format `mergeCalendars` returns its holidays in. */
+export function isoDateString(epochDay) {
+    const [year, month, day] = isoFieldsOf(epochDay);
+    return `${isoYearString(year)}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+/**
+ * Days from 1970-01-01 to `date`, an ISO-calendar date. Any other calendar throws a
+ * `RangeError`, which callers turn into their sentinel: its year, month and day are not ISO
+ * fields, so the arithmetic below would silently walk from the wrong day.
+ */
+export function epochDayOfDate(date) {
+    if (date.calendarId !== "iso8601") {
+        throw new RangeError("business-day walks take an ISO-calendar date");
+    }
+    return epochDayOf(date.year, date.month, date.day);
+}
+/**
+ * ISO weekday of an epoch day, Monday 1 to Sunday 7. Follows ECMA-262 `WeekDay` (day 0, 1970-01-01,
+ * is a Thursday) renumbered as Temporal's `ISODayOfWeek` does, Sunday 7 rather than 0.
+ */
+export function isoWeekdayOf(epochDay) {
+    // `%` keeps the dividend's sign, so a date before 1970 needs the second `+ ISO_WEEKDAYS`.
+    return (((((epochDay + EPOCH_WEEKDAY_OFFSET) % ISO_WEEKDAYS) + ISO_WEEKDAYS) %
+        ISO_WEEKDAYS) +
+        1);
+}
+/** Index of the first element of `days` (sorted ascending) that is >= `epochDay`. */
+export function lowerBound(days, epochDay) {
+    let low = 0;
+    let high = days.length;
+    while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (days[middle] < epochDay) {
+            low = middle + 1;
+        }
+        else {
+            high = middle;
+        }
+    }
+    return low;
+}
+/** Members of `days` (sorted ascending) within [from, to]; 0 when from > to. */
+export function countWithin(days, from, to) {
+    if (from > to) {
+        return 0;
+    }
+    return lowerBound(days, to + 1) - lowerBound(days, from);
+}
+/** True when `epochDay` is a member of `days` (sorted ascending). */
+export function hasEpochDay(days, epochDay) {
+    const index = lowerBound(days, epochDay);
+    return index < days.length && days[index] === epochDay;
+}
+/**
+ * `days` ascending with repeats removed. Returns `days` itself when it is already strictly
+ * ascending, so a list written in date order costs one pass and no copy; otherwise sorts a copy
+ * numerically.
+ */
+export function sortedUnique(days) {
+    let ascending = true;
+    for (let index = 1; index < days.length; index++) {
+        if (days[index] <= days[index - 1]) {
+            ascending = false;
+            break;
+        }
+    }
+    if (ascending) {
+        return days;
+    }
+    const sorted = days.slice().sort();
+    let kept = 0;
+    for (let index = 0; index < sorted.length; index++) {
+        if (index === 0 || sorted[index] !== sorted[index - 1]) {
+            sorted[kept++] = sorted[index];
+        }
+    }
+    return sorted.slice(0, kept);
+}

package/dist/internal/exactDuration.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { NANOSECONDS_PER_DAY, NANOSECONDS_PER_MICROSECOND, NANOSECONDS_PER_MILLISECOND, NANOSECONDS_PER_SECOND, } from "./foreignEpochs.js";
 const NANOSECONDS_PER_HOUR = 3600000000000n;
 const NANOSECONDS_PER_MINUTE = 60000000000n;

package/dist/internal/exactMoment.d.ts

@@ -19,16 +19,16 @@ export type ExactMoment = {
 /**
  * Read an exact moment the way `transitTime` reads a departure, or `null`.
  *
- * - A zoned string (`…-04:00[America/New_York]`) is read through its bracket, which must name a
+ * - A zoned string (`…+09:00[Asia/Tokyo]`) is read through its bracket, which must name a
  *   real zone that agrees with the offset, as `isValidZonedDateTime` requires. An offset written
  *   to the minute agrees when it is the zone's sub-minute offset rounded (TC39
  *   `ToTemporalZonedDateTime`, match-minutes), which is how `writeExactMoment` writes one.
  * - A wall time with a bracket and no offset is read in that zone with the `"compatible"`
  *   disambiguation policy (`context/reference/LOCAL_TIME_RESOLUTION.md`): an **ambiguous** wall
  *   time, a fall-back hour the clock ran through twice, resolves to the **earlier** instant
- *   (`2024-11-03T01:30:00[America/New_York]` is `01:30-04:00`), and a **nonexistent** one, a
+ *   (`2024-10-27T01:30:00[Europe/London]` is `01:30+01:00`), and a **nonexistent** one, a
  *   spring-forward hour the clock skipped, to the **later** instant
- *   (`2024-03-10T02:30:00[America/New_York]` is `03:30-04:00`). A caller that must not guess
+ *   (`2024-03-31T01:30:00[Europe/London]` is `02:30+01:00`). A caller that must not guess
  *   refuses the offset-less form before calling, as `nextDeparture` does.
  * - A string that names a zone the zoned read rejects is `null`; it never falls back to its
  *   offset. That includes a zoned string whose local date is −271821-04-19, which
@@ -42,7 +42,7 @@ export type ExactMoment = {
  *
  * @example readExactMoment("2024-06-15T10:00:00+09:00") // { nanoseconds: 1718413200000000000n, notation: { kind: "offset", offset: "+09:00" } }
  * @example readExactMoment("2024-06-15T10:00:00Z[Not/AZone]") // null
- * @example readExactMoment("2024-03-10T02:30:00[America/New_York]") // { nanoseconds: 1710055800000000000n, notation: { kind: "zone", timeZone: "America/New_York" } } (nonexistent: the later instant, 03:30-04:00)
+ * @example readExactMoment("2024-03-31T01:30:00[Europe/London]") // { nanoseconds: 1711848600000000000n, notation: { kind: "zone", timeZone: "Europe/London" } } (nonexistent: the later instant, 02:30+01:00)
  */
 export declare function readExactMoment(value: unknown): ExactMoment | null;
 /**

package/dist/internal/exactMoment.js

@@ -1,4 +1,4 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import { isValidZonedDateTime } from "../zoned/validate/isValidZonedDateTime.js";
 import { parseInstantNanoseconds } from "./instantNanoseconds.js";
 import { EXTENDED_UTC_OFFSET, TIME_ZONE_ANNOTATION } from "./isoStringBody.js";
@@ -18,16 +18,16 @@ const zoneAnnotation = new RegExp(TIME_ZONE_ANNOTATION);
 /**
  * Read an exact moment the way `transitTime` reads a departure, or `null`.
  *
- * - A zoned string (`…-04:00[America/New_York]`) is read through its bracket, which must name a
+ * - A zoned string (`…+09:00[Asia/Tokyo]`) is read through its bracket, which must name a
  *   real zone that agrees with the offset, as `isValidZonedDateTime` requires. An offset written
  *   to the minute agrees when it is the zone's sub-minute offset rounded (TC39
  *   `ToTemporalZonedDateTime`, match-minutes), which is how `writeExactMoment` writes one.
  * - A wall time with a bracket and no offset is read in that zone with the `"compatible"`
  *   disambiguation policy (`context/reference/LOCAL_TIME_RESOLUTION.md`): an **ambiguous** wall
  *   time, a fall-back hour the clock ran through twice, resolves to the **earlier** instant
- *   (`2024-11-03T01:30:00[America/New_York]` is `01:30-04:00`), and a **nonexistent** one, a
+ *   (`2024-10-27T01:30:00[Europe/London]` is `01:30+01:00`), and a **nonexistent** one, a
  *   spring-forward hour the clock skipped, to the **later** instant
- *   (`2024-03-10T02:30:00[America/New_York]` is `03:30-04:00`). A caller that must not guess
+ *   (`2024-03-31T01:30:00[Europe/London]` is `02:30+01:00`). A caller that must not guess
  *   refuses the offset-less form before calling, as `nextDeparture` does.
  * - A string that names a zone the zoned read rejects is `null`; it never falls back to its
  *   offset. That includes a zoned string whose local date is −271821-04-19, which
@@ -41,7 +41,7 @@ const zoneAnnotation = new RegExp(TIME_ZONE_ANNOTATION);
  *
  * @example readExactMoment("2024-06-15T10:00:00+09:00") // { nanoseconds: 1718413200000000000n, notation: { kind: "offset", offset: "+09:00" } }
  * @example readExactMoment("2024-06-15T10:00:00Z[Not/AZone]") // null
- * @example readExactMoment("2024-03-10T02:30:00[America/New_York]") // { nanoseconds: 1710055800000000000n, notation: { kind: "zone", timeZone: "America/New_York" } } (nonexistent: the later instant, 03:30-04:00)
+ * @example readExactMoment("2024-03-31T01:30:00[Europe/London]") // { nanoseconds: 1711848600000000000n, notation: { kind: "zone", timeZone: "Europe/London" } } (nonexistent: the later instant, 02:30+01:00)
  */
 export function readExactMoment(value) {
     if (typeof value !== "string") {