@northguild/gmt 1.18.0 → 1.20.0

package/dist/intermodal/validate/isValidX12DateRange.js

@@ -0,0 +1,31 @@
+import { parseX12DateRange } from "../parse/parseX12DateRange.js";
+/**
+ * Return true when `value` is an X12 Date Time Period value (data element 1251) that states a
+ * range between two real calendar dates, in a date range format qualifier (data element 1250).
+ *
+ * ### Format codes
+ * | Code | Mask | The dictionary's definition |
+ * |---|---|---|
+ * | `RD8` | `CCYYMMDD-CCYYMMDD` | "Range of Dates Expressed in Format CCYYMMDD-CCYYMMDD" |
+ * | `RD` | `MMDDCCYY-MMDDCCYY` | "Range of Dates Expressed in Format MMDDCCYY-MMDDCCYY" |
+ *
+ * - True exactly when `parseX12DateRange` returns a range for the same arguments: the validator
+ *   calls the parser, so the two cannot disagree.
+ * - A range is valid with exactly one hyphen: `"2024061520240620"` is false.
+ * - A range whose end precedes its start is false; an end equal to its start is true.
+ * - Checks the calendar as well as the shape: 29 February 2023 in either date is false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidX12DateTimePeriodFormat`. False for a non-string argument.
+ *
+ * @param value The data element 1251 value (e.g. "20240615-20240620")
+ * @param format X12 data element 1250 format qualifier
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12DateRange("20240615-20240620", "RD8") // true
+ * @example isValidX12DateRange("06152024-06202024", "RD") // true
+ * @example isValidX12DateRange("2024061520240620", "RD8") // false (a range is transmitted with its hyphen)
+ * @example isValidX12DateRange("20240620-20240615", "RD8") // false (the end precedes the start)
+ */
+export function isValidX12DateRange(value, format) {
+    return parseX12DateRange(value, format) !== null;
+}

package/dist/intermodal/validate/isValidX12DateTime.d.ts

@@ -0,0 +1,30 @@
+import type { X12DateTimeFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is an X12 Date Time Period value (data element 1251) that states a
+ * real date and time in a date-time format qualifier (data element 1250).
+ *
+ * ### Format codes
+ * | Code | Mask | The dictionary's definition |
+ * |---|---|---|
+ * | `DT` | `CCYYMMDDHHMM` | "Date and Time Expressed in Format CCYYMMDDHHMM" |
+ * | `RTS` | `CCYYMMDDHHMMSS` | "Date and Time Expressed in Format CCYYMMDDHHMMSS" |
+ *
+ * - True exactly when `parseX12DateTime` returns a date-time for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A value is valid only against its code: `"202406151430"` is a `DT` value and not an `RTS`
+ *   one.
+ * - Checks the calendar as well as the shape: 31 June, 29 February 2023, hour 24 and second 60
+ *   are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidX12DateTimePeriodFormat`. False for a non-string argument.
+ *
+ * @param value The data element 1251 value (e.g. "202406151430")
+ * @param format X12 data element 1250 format qualifier
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12DateTime("202406151430", "DT") // true
+ * @example isValidX12DateTime("20240615143045", "RTS") // true
+ * @example isValidX12DateTime("202406151430", "RTS") // false (twelve digits is a DT value)
+ * @example isValidX12DateTime("202406152430", "DT") // false (hour 24)
+ */
+export declare function isValidX12DateTime(value: string, format: X12DateTimeFormat): boolean;

package/dist/intermodal/validate/isValidX12DateTime.js

@@ -0,0 +1,32 @@
+import { parseX12DateTime } from "../parse/parseX12DateTime.js";
+/**
+ * Return true when `value` is an X12 Date Time Period value (data element 1251) that states a
+ * real date and time in a date-time format qualifier (data element 1250).
+ *
+ * ### Format codes
+ * | Code | Mask | The dictionary's definition |
+ * |---|---|---|
+ * | `DT` | `CCYYMMDDHHMM` | "Date and Time Expressed in Format CCYYMMDDHHMM" |
+ * | `RTS` | `CCYYMMDDHHMMSS` | "Date and Time Expressed in Format CCYYMMDDHHMMSS" |
+ *
+ * - True exactly when `parseX12DateTime` returns a date-time for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A value is valid only against its code: `"202406151430"` is a `DT` value and not an `RTS`
+ *   one.
+ * - Checks the calendar as well as the shape: 31 June, 29 February 2023, hour 24 and second 60
+ *   are false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidX12DateTimePeriodFormat`. False for a non-string argument.
+ *
+ * @param value The data element 1251 value (e.g. "202406151430")
+ * @param format X12 data element 1250 format qualifier
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12DateTime("202406151430", "DT") // true
+ * @example isValidX12DateTime("20240615143045", "RTS") // true
+ * @example isValidX12DateTime("202406151430", "RTS") // false (twelve digits is a DT value)
+ * @example isValidX12DateTime("202406152430", "DT") // false (hour 24)
+ */
+export function isValidX12DateTime(value, format) {
+    return parseX12DateTime(value, format) !== "";
+}

package/dist/intermodal/validate/isValidX12DateTimePeriodFormat.d.ts

@@ -0,0 +1,43 @@
+import type { X12DateTimePeriodFormat } from "../../types/edi.js";
+/**
+ * Return true when `format` is an X12 data element 1250 (Date Time Period Format Qualifier) code
+ * that the X12 functions read and write.
+ *
+ * - The 10 supported codes are `D8`, `DB` (a date); `TM`, `TS` (a time); `DT`, `RTS` (a date and
+ *   time); `RD8`, `RD` (a range of dates) and `RDT`, `DTS` (a range of date-times).
+ *   `classifyX12DateTimePeriodFormat` names the kind of a code, and each kind has its own
+ *   parser, formatter and validator. Release 005010, read from
+ *   [Stedi's X12-licensed dictionary](https://www.stedi.com/edi/x12-005010/element/1250); the
+ *   X12 text itself was not reached. The 42-code list is the same in release 008010.
+ * - A code with a two-digit year returns false: `D6`, `TT`, `TR`, `RD6` and `TU`. X12 does not
+ *   say which century `YY` belongs to; read such a value with `parseDateWithPattern` or
+ *   `parseDateTimeWithPattern`, a `yy` pattern and its `yearWindow` option.
+ * - `TC` and `EH` (a day of the year with no whole year), `DDT` and `DTD` (a range with a date on
+ *   one side and a date-time on the other), `RTM` (a range of times with no date) and `UN`
+ *   (Unstructured) return false: none states a value of one kind.
+ * - The other 21 codes of the element return false: the partial values (`CC`, `CY`, `CM`, `CQ`,
+ *   `YM`, `MD`, `DD`, `MM`, `TQ`, `YY`, `MCY`), the ranges of partial values (`DA`, `RD2`, `RD4`,
+ *   `RD5`, `RMD`, `RMY`), `RDM` (`YYMMDD-MMDD`, a range whose end names no year) and the
+ *   month-name forms (`CD`, `KA`, `YMM`).
+ * - `TS`, `TT`, `CD` and `MD` are codes of data element 623 (Time Code) too, with unrelated
+ *   meanings: here `TS` is `HHMMSS`, and `TT`, `CD` and `MD` are not read; there they name the
+ *   Atlantic, Central and Mountain zones. Check a time code with `isValidX12TimeCode`.
+ * - Matching is exact: case and spacing are not normalised.
+ * - Accepts any input type and returns false for non-string values.
+ * - A parser returns its sentinel for a code it does not read and for a bad value alike. Check
+ *   the code here to tell a code GMT does not read apart from a value that does not fit its
+ *   code.
+ *
+ * @param format candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12DateTimePeriodFormat("D8") // true
+ * @example isValidX12DateTimePeriodFormat("RD8") // true
+ * @example isValidX12DateTimePeriodFormat("D6") // false (a two-digit year: not read)
+ * @example isValidX12DateTimePeriodFormat("UN") // false (unstructured: nothing to read)
+ * @example isValidX12DateTimePeriodFormat("d8") // false (case is exact)
+ * @example isValidX12DateTimePeriodFormat("CM") // false (a year and month: a code GMT does not read)
+ * @example isValidX12DateTimePeriodFormat("DTM") // false (a segment name, not a 1250 code)
+ * @example isValidX12DateTimePeriodFormat(null) // false
+ */
+export declare function isValidX12DateTimePeriodFormat(format: unknown): format is X12DateTimePeriodFormat;

package/dist/intermodal/validate/isValidX12DateTimePeriodFormat.js

@@ -0,0 +1,46 @@
+import { X12_DATE_TIME_PERIOD_FORMATS } from "../../internal/index.js";
+/**
+ * Return true when `format` is an X12 data element 1250 (Date Time Period Format Qualifier) code
+ * that the X12 functions read and write.
+ *
+ * - The 10 supported codes are `D8`, `DB` (a date); `TM`, `TS` (a time); `DT`, `RTS` (a date and
+ *   time); `RD8`, `RD` (a range of dates) and `RDT`, `DTS` (a range of date-times).
+ *   `classifyX12DateTimePeriodFormat` names the kind of a code, and each kind has its own
+ *   parser, formatter and validator. Release 005010, read from
+ *   [Stedi's X12-licensed dictionary](https://www.stedi.com/edi/x12-005010/element/1250); the
+ *   X12 text itself was not reached. The 42-code list is the same in release 008010.
+ * - A code with a two-digit year returns false: `D6`, `TT`, `TR`, `RD6` and `TU`. X12 does not
+ *   say which century `YY` belongs to; read such a value with `parseDateWithPattern` or
+ *   `parseDateTimeWithPattern`, a `yy` pattern and its `yearWindow` option.
+ * - `TC` and `EH` (a day of the year with no whole year), `DDT` and `DTD` (a range with a date on
+ *   one side and a date-time on the other), `RTM` (a range of times with no date) and `UN`
+ *   (Unstructured) return false: none states a value of one kind.
+ * - The other 21 codes of the element return false: the partial values (`CC`, `CY`, `CM`, `CQ`,
+ *   `YM`, `MD`, `DD`, `MM`, `TQ`, `YY`, `MCY`), the ranges of partial values (`DA`, `RD2`, `RD4`,
+ *   `RD5`, `RMD`, `RMY`), `RDM` (`YYMMDD-MMDD`, a range whose end names no year) and the
+ *   month-name forms (`CD`, `KA`, `YMM`).
+ * - `TS`, `TT`, `CD` and `MD` are codes of data element 623 (Time Code) too, with unrelated
+ *   meanings: here `TS` is `HHMMSS`, and `TT`, `CD` and `MD` are not read; there they name the
+ *   Atlantic, Central and Mountain zones. Check a time code with `isValidX12TimeCode`.
+ * - Matching is exact: case and spacing are not normalised.
+ * - Accepts any input type and returns false for non-string values.
+ * - A parser returns its sentinel for a code it does not read and for a bad value alike. Check
+ *   the code here to tell a code GMT does not read apart from a value that does not fit its
+ *   code.
+ *
+ * @param format candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12DateTimePeriodFormat("D8") // true
+ * @example isValidX12DateTimePeriodFormat("RD8") // true
+ * @example isValidX12DateTimePeriodFormat("D6") // false (a two-digit year: not read)
+ * @example isValidX12DateTimePeriodFormat("UN") // false (unstructured: nothing to read)
+ * @example isValidX12DateTimePeriodFormat("d8") // false (case is exact)
+ * @example isValidX12DateTimePeriodFormat("CM") // false (a year and month: a code GMT does not read)
+ * @example isValidX12DateTimePeriodFormat("DTM") // false (a segment name, not a 1250 code)
+ * @example isValidX12DateTimePeriodFormat(null) // false
+ */
+export function isValidX12DateTimePeriodFormat(format) {
+    return (typeof format === "string" &&
+        X12_DATE_TIME_PERIOD_FORMATS.includes(format));
+}

package/dist/intermodal/validate/isValidX12DateTimeRange.d.ts

@@ -0,0 +1,31 @@
+import type { X12DateTimeRangeFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is an X12 Date Time Period value (data element 1251) that states a
+ * range between two real local date-times, in a date-time range format qualifier (data element
+ * 1250).
+ *
+ * ### Format codes
+ * | Code | Mask | The dictionary's definition |
+ * |---|---|---|
+ * | `RDT` | `CCYYMMDDHHMM-CCYYMMDDHHMM` | "Range of Date and Time, Expressed in Format CCYYMMDDHHMM-CCYYMMDDHHMM" |
+ * | `DTS` | `CCYYMMDDHHMMSS-CCYYMMDDHHMMSS` | "Range of Date and Time Expressed in Format CCYYMMDDHHMMSS-CCYYMMDDHHMMSS" |
+ *
+ * - True exactly when `parseX12DateTimeRange` returns a range for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A range is valid with exactly one hyphen, and only against its code.
+ * - A range whose end precedes its start is false; an end equal to its start is true.
+ * - Checks the calendar as well as the shape: hour 24, second 60 and 29 February 2023 are
+ *   false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidX12DateTimePeriodFormat`. False for a non-string argument.
+ *
+ * @param value The data element 1251 value (e.g. "202406151430-202406201600")
+ * @param format X12 data element 1250 format qualifier
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12DateTimeRange("202406151430-202406201600", "RDT") // true
+ * @example isValidX12DateTimeRange("20240615143045-20240620160030", "DTS") // true
+ * @example isValidX12DateTimeRange("202406151430202406201600", "RDT") // false (a range is transmitted with its hyphen)
+ * @example isValidX12DateTimeRange("202406151431-202406151430", "RDT") // false (the end precedes the start)
+ */
+export declare function isValidX12DateTimeRange(value: string, format: X12DateTimeRangeFormat): boolean;

package/dist/intermodal/validate/isValidX12DateTimeRange.js

@@ -0,0 +1,33 @@
+import { parseX12DateTimeRange } from "../parse/parseX12DateTimeRange.js";
+/**
+ * Return true when `value` is an X12 Date Time Period value (data element 1251) that states a
+ * range between two real local date-times, in a date-time range format qualifier (data element
+ * 1250).
+ *
+ * ### Format codes
+ * | Code | Mask | The dictionary's definition |
+ * |---|---|---|
+ * | `RDT` | `CCYYMMDDHHMM-CCYYMMDDHHMM` | "Range of Date and Time, Expressed in Format CCYYMMDDHHMM-CCYYMMDDHHMM" |
+ * | `DTS` | `CCYYMMDDHHMMSS-CCYYMMDDHHMMSS` | "Range of Date and Time Expressed in Format CCYYMMDDHHMMSS-CCYYMMDDHHMMSS" |
+ *
+ * - True exactly when `parseX12DateTimeRange` returns a range for the same arguments: the
+ *   validator calls the parser, so the two cannot disagree.
+ * - A range is valid with exactly one hyphen, and only against its code.
+ * - A range whose end precedes its start is false; an end equal to its start is true.
+ * - Checks the calendar as well as the shape: hour 24, second 60 and 29 February 2023 are
+ *   false.
+ * - False for any other code, a code of another kind included; check a code alone with
+ *   `isValidX12DateTimePeriodFormat`. False for a non-string argument.
+ *
+ * @param value The data element 1251 value (e.g. "202406151430-202406201600")
+ * @param format X12 data element 1250 format qualifier
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12DateTimeRange("202406151430-202406201600", "RDT") // true
+ * @example isValidX12DateTimeRange("20240615143045-20240620160030", "DTS") // true
+ * @example isValidX12DateTimeRange("202406151430202406201600", "RDT") // false (a range is transmitted with its hyphen)
+ * @example isValidX12DateTimeRange("202406151431-202406151430", "RDT") // false (the end precedes the start)
+ */
+export function isValidX12DateTimeRange(value, format) {
+    return parseX12DateTimeRange(value, format) !== null;
+}

package/dist/intermodal/validate/isValidX12Time.d.ts

@@ -0,0 +1,38 @@
+import type { X12TimeFormat } from "../../types/edi.js";
+/**
+ * Return true when `value` is an X12 time that states a real time of day: a data element 337
+ * value with no qualifier, or a time that fits the data element 1250 format qualifier it
+ * arrived with.
+ *
+ * ### Forms
+ * | `format` | Digits | Mask | The dictionary's definition |
+ * |---|---|---|---|
+ * | omitted | 4, 6, 7 or 8 | `HHMM`, `HHMMSS`, `HHMMSSD`, `HHMMSSDD` | Element 337: "H = hours (00-23), M = minutes (00-59), S = integer seconds (00-59) … D = tenths (0-9) and DD = hundredths (00-99)" |
+ * | `TM` | 4 | `HHMM` | "Time Expressed in Format HHMM" |
+ * | `TS` | 6 | `HHMMSS` | "Time Expressed in Format HHMMSS" |
+ *
+ * - True exactly when `parseX12Time` returns a time for the same arguments: the validator calls
+ *   the parser, so the two cannot disagree.
+ * - Omit `format` for the time element of a freight segment (`AT7-06`, `G62-04`, `DTM-03`),
+ *   which has no qualifier. Pass it for a time that arrives with one (`DTP-02` and `DTP-03`,
+ *   `DTM-05` and `DTM-06`).
+ * - A qualifier is strict: `"143045"` is false under `TM`, and a 7- or 8-digit value is false
+ *   under either qualifier, although all three are true with none.
+ * - A `format` that is present and is not `TM` or `TS` is false.
+ * - Hour 24, minute 60, second 60 and a value of 5 or 9 digits are false.
+ * - False for a non-string value.
+ *
+ * @param value The time as transmitted (e.g. "1430")
+ * @param format X12 data element 1250 format qualifier the time arrived with; omit it for a data element 337 value
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12Time("1430") // true
+ * @example isValidX12Time("1430", "TM") // true
+ * @example isValidX12Time("143045", "TS") // true
+ * @example isValidX12Time("14300012") // true (hundredths of a second)
+ * @example isValidX12Time("14300012", "TS") // false (no 1250 code holds decimal seconds)
+ * @example isValidX12Time("143045", "TM") // false (six digits is a TS value)
+ * @example isValidX12Time("2430") // false (hour 24)
+ * @example isValidX12Time("14304") // false (five digits is not an element 337 form)
+ */
+export declare function isValidX12Time(value: string, format?: X12TimeFormat): boolean;

package/dist/intermodal/validate/isValidX12Time.js

@@ -0,0 +1,40 @@
+import { parseX12Time } from "../parse/parseX12Time.js";
+/**
+ * Return true when `value` is an X12 time that states a real time of day: a data element 337
+ * value with no qualifier, or a time that fits the data element 1250 format qualifier it
+ * arrived with.
+ *
+ * ### Forms
+ * | `format` | Digits | Mask | The dictionary's definition |
+ * |---|---|---|---|
+ * | omitted | 4, 6, 7 or 8 | `HHMM`, `HHMMSS`, `HHMMSSD`, `HHMMSSDD` | Element 337: "H = hours (00-23), M = minutes (00-59), S = integer seconds (00-59) … D = tenths (0-9) and DD = hundredths (00-99)" |
+ * | `TM` | 4 | `HHMM` | "Time Expressed in Format HHMM" |
+ * | `TS` | 6 | `HHMMSS` | "Time Expressed in Format HHMMSS" |
+ *
+ * - True exactly when `parseX12Time` returns a time for the same arguments: the validator calls
+ *   the parser, so the two cannot disagree.
+ * - Omit `format` for the time element of a freight segment (`AT7-06`, `G62-04`, `DTM-03`),
+ *   which has no qualifier. Pass it for a time that arrives with one (`DTP-02` and `DTP-03`,
+ *   `DTM-05` and `DTM-06`).
+ * - A qualifier is strict: `"143045"` is false under `TM`, and a 7- or 8-digit value is false
+ *   under either qualifier, although all three are true with none.
+ * - A `format` that is present and is not `TM` or `TS` is false.
+ * - Hour 24, minute 60, second 60 and a value of 5 or 9 digits are false.
+ * - False for a non-string value.
+ *
+ * @param value The time as transmitted (e.g. "1430")
+ * @param format X12 data element 1250 format qualifier the time arrived with; omit it for a data element 337 value
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12Time("1430") // true
+ * @example isValidX12Time("1430", "TM") // true
+ * @example isValidX12Time("143045", "TS") // true
+ * @example isValidX12Time("14300012") // true (hundredths of a second)
+ * @example isValidX12Time("14300012", "TS") // false (no 1250 code holds decimal seconds)
+ * @example isValidX12Time("143045", "TM") // false (six digits is a TS value)
+ * @example isValidX12Time("2430") // false (hour 24)
+ * @example isValidX12Time("14304") // false (five digits is not an element 337 form)
+ */
+export function isValidX12Time(value, format) {
+    return parseX12Time(value, format) !== "";
+}

package/dist/intermodal/validate/isValidX12TimeCode.d.ts

@@ -0,0 +1,38 @@
+import type { X12TimeCode } from "../../types/edi.js";
+/**
+ * Return true when `timeCode` is one of the 56 X12 data element 623 time codes, the codes
+ * `x12TimeCodeOffset` and `x12TimeCodeZone` read between them.
+ *
+ * - The codes are `01`–`29`, `GM`, `UT`, `LT` and the named zone codes (`AD`, `AS`, `AT`, `CD`,
+ *   `CS`, `CT`, `ED`, `ES`, `ET`, `HD`, `HS`, `HT`, `MD`, `MS`, `MT`, `ND`, `NS`, `NT`, `PD`,
+ *   `PS`, `PT`, `TD`, `TS`, `TT`), release 008010, read from
+ *   [Stedi's X12-licensed dictionary](https://www.stedi.com/edi/x12-008010/element/623); the X12
+ *   text itself was not reached.
+ * - **The function takes no release, so it accepts the superset.**
+ *   [Release 005010](https://www.stedi.com/edi/x12-005010/element/623) has 51 of the codes:
+ *   `25`–`29` were added in release 006010 and are not valid in an 004010 or 005010 interchange,
+ *   although this returns true for them.
+ * - `TS`, `TT`, `CD` and `MD` are codes of data element 1250 too, with unrelated meanings there.
+ *   True here says the value is a time code; check a format qualifier with
+ *   `isValidX12DateTimePeriodFormat`.
+ * - Membership is by the list, never by shape: `00` and `30` are two digits and are not codes.
+ * - Matching is exact: two characters, upper case, no padding.
+ * - Accepts any input type and returns false for non-string values.
+ * - True exactly when one of `x12TimeCodeOffset` and `x12TimeCodeZone` returns a value: the 31
+ *   codes that state an offset and the 25 that name a zone are the 56. A valid code says the
+ *   value is in the list, not that it carries an offset: `ES` is valid and names a zone.
+ *   `classifyX12TimeCode` says which of the two a code is, and narrows it for that reader.
+ *
+ * @param timeCode candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12TimeCode("ES") // true
+ * @example isValidX12TimeCode("13") // true
+ * @example isValidX12TimeCode("LT") // true
+ * @example isValidX12TimeCode("27") // true (in release 006010 and later)
+ * @example isValidX12TimeCode("et") // false (case is exact)
+ * @example isValidX12TimeCode("30") // false (not a 623 code)
+ * @example isValidX12TimeCode("EST") // false (an abbreviation, not a 623 code)
+ * @example isValidX12TimeCode(null) // false
+ */
+export declare function isValidX12TimeCode(timeCode: unknown): timeCode is X12TimeCode;

package/dist/intermodal/validate/isValidX12TimeCode.js

@@ -0,0 +1,41 @@
+import { X12_TIME_CODES } from "../../internal/index.js";
+/**
+ * Return true when `timeCode` is one of the 56 X12 data element 623 time codes, the codes
+ * `x12TimeCodeOffset` and `x12TimeCodeZone` read between them.
+ *
+ * - The codes are `01`–`29`, `GM`, `UT`, `LT` and the named zone codes (`AD`, `AS`, `AT`, `CD`,
+ *   `CS`, `CT`, `ED`, `ES`, `ET`, `HD`, `HS`, `HT`, `MD`, `MS`, `MT`, `ND`, `NS`, `NT`, `PD`,
+ *   `PS`, `PT`, `TD`, `TS`, `TT`), release 008010, read from
+ *   [Stedi's X12-licensed dictionary](https://www.stedi.com/edi/x12-008010/element/623); the X12
+ *   text itself was not reached.
+ * - **The function takes no release, so it accepts the superset.**
+ *   [Release 005010](https://www.stedi.com/edi/x12-005010/element/623) has 51 of the codes:
+ *   `25`–`29` were added in release 006010 and are not valid in an 004010 or 005010 interchange,
+ *   although this returns true for them.
+ * - `TS`, `TT`, `CD` and `MD` are codes of data element 1250 too, with unrelated meanings there.
+ *   True here says the value is a time code; check a format qualifier with
+ *   `isValidX12DateTimePeriodFormat`.
+ * - Membership is by the list, never by shape: `00` and `30` are two digits and are not codes.
+ * - Matching is exact: two characters, upper case, no padding.
+ * - Accepts any input type and returns false for non-string values.
+ * - True exactly when one of `x12TimeCodeOffset` and `x12TimeCodeZone` returns a value: the 31
+ *   codes that state an offset and the 25 that name a zone are the 56. A valid code says the
+ *   value is in the list, not that it carries an offset: `ES` is valid and names a zone.
+ *   `classifyX12TimeCode` says which of the two a code is, and narrows it for that reader.
+ *
+ * @param timeCode candidate value of any type
+ * @returns boolean indicating validity
+ *
+ * @example isValidX12TimeCode("ES") // true
+ * @example isValidX12TimeCode("13") // true
+ * @example isValidX12TimeCode("LT") // true
+ * @example isValidX12TimeCode("27") // true (in release 006010 and later)
+ * @example isValidX12TimeCode("et") // false (case is exact)
+ * @example isValidX12TimeCode("30") // false (not a 623 code)
+ * @example isValidX12TimeCode("EST") // false (an abbreviation, not a 623 code)
+ * @example isValidX12TimeCode(null) // false
+ */
+export function isValidX12TimeCode(timeCode) {
+    return (typeof timeCode === "string" &&
+        X12_TIME_CODES.includes(timeCode));
+}

package/dist/internal/advanceToWeekday.d.ts

@@ -1,4 +1,4 @@
-import type { Temporal } from "@js-temporal/polyfill";
+import type { Temporal } from "./temporal.js";
 /**
  * Return the PlainDate for the next/previous occurrence of `dayOfWeek` relative to `date`.
  *

package/dist/internal/businessCalendar.d.ts

@@ -1,21 +1,28 @@
-import { Temporal } from "@js-temporal/polyfill";
+import { Temporal } from "./temporal.js";
 import type { BusinessCalendar } from "../types/index.js";
 /**
  * Calendar days a single business-day walk may step before giving up — roughly 547 years, far
  * past any real schedule. A walk that runs out returns the sentinel, never a partial answer.
  */
 export declare const MAX_BUSINESS_DAY_STEPS = 200000;
-/** A `BusinessCalendar` reduced to the two lookups every walk needs. */
+/** A `BusinessCalendar` reduced to the lookups every walk needs. */
 export type ResolvedBusinessCalendar = {
     weekend: Set<number>;
-    holidays: Set<string>;
+    /** Every holiday as an epoch day, sorted ascending, no repeats. */
+    holidays: Int32Array;
+    /** The holidays that fall on a working weekday: the only ones that change a count. */
+    closures: Int32Array;
 };
+/** Shared by every caller without a calendar: its arrays are empty and never mutated. */
 export declare const DEFAULT_BUSINESS_CALENDAR: ResolvedBusinessCalendar;
+/** Empty the holiday memo. Tests only. */
+export declare function clearHolidayMemo(): void;
 /**
- * Reduce a holiday list to its normalised ISO dates, or `null` when it is not an array of ISO
- * PlainDate strings. Shared with `OperatingSchedule.holidays`, which takes the same list.
+ * Reduce a holiday list to its epoch days, sorted ascending without repeats, or `null` when it
+ * is not an array of ISO PlainDate strings. Shared with `OperatingSchedule.holidays`, which
+ * takes the same list.
  */
-export declare function parseHolidays(holidays: unknown): Set<string> | null;
+export declare function parseHolidays(holidays: unknown): Int32Array | null;
 /**
  * Reduce a caller-supplied `BusinessCalendar` to its lookups, or `null` when it is not one.
  *
@@ -28,8 +35,16 @@ export declare function parseBusinessCalendar(calendar: unknown): ResolvedBusine
  * holidays, anything else must be a valid `BusinessCalendar` or this returns `null`.
  */
 export declare function resolveBusinessCalendar(calendar: BusinessCalendar | undefined): ResolvedBusinessCalendar | null;
-/** True when `date` is neither a weekend day nor a holiday in `calendar`. */
+/**
+ * True when `date` is neither a weekend day nor a holiday in `calendar`. `date` must be an
+ * ISO-calendar date: any other calendar throws a `RangeError`. Every caller passes a date it
+ * parsed from an ISO string or took from `toPlainDate()` of a zoned string parsed the same way.
+ */
 export declare function isBusinessDate(date: Temporal.PlainDate, calendar: ResolvedBusinessCalendar): boolean;
+/** True when `epochDay` is neither a weekend day nor a holiday on a working weekday. */
+export declare function isBusinessEpochDay(epochDay: number, calendar: ResolvedBusinessCalendar): boolean;
+/** Business days in [from, to] (epoch days, from <= to); 0 when from > to. */
+export declare function businessDaysWithin(from: number, to: number, calendar: ResolvedBusinessCalendar): number;
 /**
  * The first business day at or beyond `date`, walking in `direction`.
  *
@@ -42,10 +57,11 @@ export declare function businessDateFrom(date: Temporal.PlainDate, direction: 1
  * Step `count` business days from `date` in `direction`, counting only days that are business
  * days in `calendar`.
  *
- * `date` is an ISO-calendar date, as every caller validates. `count` is a non-negative whole
- * number of business days. `date` itself is never counted, so a `count` of 0 returns `date`
- * unchanged even when it is not a business day. Returns `null`
- * when the walk exceeds `MAX_BUSINESS_DAY_STEPS`, and throws a `RangeError` when it passes a
- * Temporal range limit.
+ * `date` is an ISO-calendar date, as every caller validates. `date` itself is never counted, so
+ * a `count` of 0 returns `date` unchanged even when it is not a business day. Returns `null`
+ * when the walk exceeds `MAX_BUSINESS_DAY_STEPS`, and for a `count` that is not a whole number
+ * of days or is negative or NaN: a fractional or infinite `count` still walks first, as the
+ * day-by-day loop did, so it throws the same `RangeError` when it passes a Temporal range limit
+ * before finishing. Throws a `RangeError` when any walk passes a Temporal range limit.
  */
 export declare function stepBusinessDates(date: Temporal.PlainDate, direction: 1 | -1, count: number, calendar: ResolvedBusinessCalendar): Temporal.PlainDate | null;