@glion/util-timestamp 0.26.0 → 0.27.0

package/dist/index.js

@@ -1,47 +1,210 @@
-//#region src/precision.ts
+//#region src/format.ts
+const MINUTES_PER_HOUR$1 = 60;
+function pad(value, width) {
+	return String(value).padStart(width, "0");
+}
+function formatOffset(offset) {
+	const sign = offset < 0 ? "-" : "+";
+	const magnitude = Math.abs(offset);
+	return `${sign}${pad(Math.floor(magnitude / MINUTES_PER_HOUR$1), 2)}${pad(magnitude % MINUTES_PER_HOUR$1, 2)}`;
+}
+function writeTime(time) {
+	let text = "";
+	if (time.hour !== void 0) text += pad(time.hour, 2);
+	if (time.minute !== void 0) text += pad(time.minute, 2);
+	if (time.second !== void 0) text += pad(time.second, 2);
+	if (time.fraction !== void 0) text += `.${time.fraction}`;
+	if (time.offset !== void 0) text += formatOffset(time.offset);
+	return text;
+}
+function writeDate(date) {
+	let text = pad(date.year, 4);
+	if (date.month !== void 0) text += pad(date.month, 2);
+	if (date.day !== void 0) text += pad(date.day, 2);
+	return text;
+}
 /**
-* HL7v2 timestamp precision levels.
+* Writes a DT as HL7v2 text, `YYYY[MM[DD]]`, with the fields `date` has.
 *
-* Controls how much of the timestamp is included when formatting.
-* Precision is progressive — higher precision includes all lower levels.
+* @example
+*   ```ts
+*   formatDT({ year: 2026, month: 3, precision: "month" }); // "202603"
+*   ```;
+*/
+function formatDT(date) {
+	return writeDate(date);
+}
+/**
+* Writes a TM as HL7v2 text, `HH[MM[SS[.S[S[S[S]]]]]][+/-ZZZZ]`, with the
+* fields `time` has. An `offset` of `0` is written `+0000`.
 *
-* | Precision     | Format                | Example               |
-* | ------------- | --------------------- | --------------------- |
-* | `Year`        | `YYYY`                | `2026`                |
-* | `Month`       | `YYYYMM`              | `202603`              |
-* | `Day`         | `YYYYMMDD`            | `20260307`            |
-* | `Hour`        | `YYYYMMDDHH`          | `2026030714`          |
-* | `Minute`      | `YYYYMMDDHHmm`        | `202603071430`        |
-* | `Second`      | `YYYYMMDDHHmmss`      | `20260307143000`      |
-* | `Millisecond` | `YYYYMMDDHHmmss.SSSS` | `20260307143000.1234` |
+* @example
+*   ```ts
+*   formatTM({ hour: 14, minute: 30, offset: -300, precision: "minute" }); // "1430-0500"
+*   ```;
 */
-const Precision = {
-	Year: "year",
-	Month: "month",
-	Day: "day",
-	Hour: "hour",
-	Minute: "minute",
-	Second: "second",
-	Millisecond: "millisecond"
-};
+function formatTM(time) {
+	return writeTime(time);
+}
+/**
+* Writes a DTM as HL7v2 text, `YYYY[MM[DD[HH[MM[SS[.S[S[S[S]]]]]]]]][+/-ZZZZ]`,
+* with the fields `dateTime` has. An `offset` of `0` is written `+0000`.
+*
+* @example
+*   ```ts
+*   formatDTM({ year: 2026, month: 3, day: 7, hour: 14, precision: "hour" }); // "2026030714"
+*   ```;
+*/
+function formatDTM(dateTime) {
+	return `${writeDate(dateTime)}${writeTime(dateTime)}`;
+}
 //#endregion
-//#region src/timestamp.ts
-const PAD2_TABLE = Array.from({ length: 100 }, (_, i) => i < 10 ? `0${i}` : `${i}`);
-function pad2(n) {
-	return PAD2_TABLE[n] ?? String(n);
+//#region src/scan.ts
+const ZERO = 48;
+const NINE = 57;
+const DOT = 46;
+const PLUS = 43;
+const MINUS = 45;
+const MAX_FRACTION_DIGITS = 4;
+const OFFSET_DIGITS = 4;
+const MINUTES_PER_HOUR = 60;
+const MAX_MONTH = 12;
+const MAX_HOUR = 23;
+const MAX_MINUTE = 59;
+const MAX_SECOND = 59;
+const MAX_OFFSET_HOURS = 14;
+function countDigits(value, start) {
+	let end = start;
+	for (;;) {
+		const code = value.codePointAt(end);
+		if (code === void 0 || code < ZERO || code > NINE) return end - start;
+		end += 1;
+	}
+}
+/**
+* The number written by `count` characters of `value` from `start`, which
+* MUST all be ASCII digits.
+*/
+function numberAt(value, start, count) {
+	let result = 0;
+	for (let index = start; index < start + count; index += 1) result = result * 10 + ((value.codePointAt(index) ?? ZERO) - ZERO);
+	return result;
+}
+function readOffset(value, start) {
+	if (!(countDigits(value, start + 1) === OFFSET_DIGITS && value.length === start + 1 + OFFSET_DIGITS)) return;
+	const hours = numberAt(value, start + 1, 2);
+	const minutes = numberAt(value, start + 3, 2);
+	const magnitude = hours * MINUTES_PER_HOUR + minutes;
+	const isWest = value.codePointAt(start) === MINUS && magnitude !== 0;
+	return {
+		hours,
+		minutes,
+		text: value.slice(start),
+		total: isWest ? -magnitude : magnitude
+	};
+}
+/**
+* The layout of `value`, or `undefined` when it is not digits, optionally
+* followed by `.` and 1 to 4 digits, optionally followed by `+` or `-` and 4
+* digits.
+*/
+function readLayout(value) {
+	const digits = countDigits(value, 0);
+	let end = digits;
+	let fraction;
+	if (value.codePointAt(end) === DOT) {
+		const count = countDigits(value, end + 1);
+		if (count === 0 || count > MAX_FRACTION_DIGITS) return;
+		fraction = value.slice(end + 1, end + 1 + count);
+		end += 1 + count;
+	}
+	let offset;
+	const sign = value.codePointAt(end);
+	if (sign === PLUS || sign === MINUS) {
+		offset = readOffset(value, end);
+		if (offset === void 0) return;
+		end = value.length;
+	}
+	return end === value.length ? {
+		digits,
+		fraction,
+		offset
+	} : void 0;
+}
+/** Whether `year` is a leap year in the Gregorian calendar. */
+function isLeapYear(year) {
+	return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;
+}
+/** The number of days in `month` (1 to 12) of `year`. */
+function daysInMonth(year, month) {
+	switch (month) {
+		case 2: return isLeapYear(year) ? 29 : 28;
+		case 4:
+		case 6:
+		case 9:
+		case 11: return 30;
+		default: return 31;
+	}
+}
+/**
+* The issue with a date's month or day, or `undefined` when it is a calendar
+* date.
+*/
+function checkDate(year, month, day) {
+	if (month === void 0) return;
+	if (month < 1 || month > MAX_MONTH) return {
+		code: "month-out-of-range",
+		month
+	};
+	if (day === void 0) return;
+	const days = daysInMonth(year, month);
+	if (day < 1 || day > days) return {
+		code: "day-out-of-range",
+		day,
+		daysInMonth: days,
+		month,
+		year
+	};
+}
+/** The issue with a time's fields, or `undefined` when each is in range. */
+function checkTime(hour, minute, second) {
+	if (hour !== void 0 && hour > MAX_HOUR) return {
+		code: "hour-out-of-range",
+		hour
+	};
+	if (minute !== void 0 && minute > MAX_MINUTE) return {
+		code: "minute-out-of-range",
+		minute
+	};
+	if (second !== void 0 && second > MAX_SECOND) return {
+		code: "second-out-of-range",
+		second
+	};
+}
+/** The issue with an offset, or `undefined` when it is at most `±1459`. */
+function checkOffset(offset) {
+	return offset !== void 0 && (offset.hours > MAX_OFFSET_HOURS || offset.minutes > MAX_MINUTE) ? {
+		code: "offset-out-of-range",
+		offset: offset.text
+	} : void 0;
 }
-const PRECISION_INDEX = new Map([
-	["year", 0],
-	["month", 1],
-	["day", 2],
-	["hour", 3],
-	["minute", 4],
-	["second", 5],
-	["millisecond", 6]
+//#endregion
+//#region src/parse.ts
+const INVALID_FORMAT = {
+	issue: { code: "invalid-format" },
+	success: false
+};
+const DT_PRECISION = new Map([
+	[4, "year"],
+	[6, "month"],
+	[8, "day"]
+]);
+const TM_PRECISION = new Map([
+	[2, "hour"],
+	[4, "minute"],
+	[6, "second"]
 ]);
-/** Minimum precision index that supports a timezone offset (hour = 3). */
-const MIN_TIMEZONE_PRECISION = 3;
-const PRECISION_BY_LENGTH = new Map([
+const DTM_PRECISION = new Map([
 	[4, "year"],
 	[6, "month"],
 	[8, "day"],
@@ -49,277 +212,155 @@ const PRECISION_BY_LENGTH = new Map([
 	[12, "minute"],
 	[14, "second"]
 ]);
-function formatOffset(offsetMinutes) {
-	const sign = offsetMinutes <= 0 ? "+" : "-";
-	const abs = Math.abs(offsetMinutes);
-	const hours = Math.floor(abs / 60);
-	const minutes = abs % 60;
-	return `${sign}${pad2(hours)}${pad2(minutes)}`;
-}
-/** Get the code point at offset, returning 0 for out-of-bounds. */
-function code(s, offset) {
-	return s.codePointAt(offset) ?? 0;
-}
-/** Extract a 2-digit number from a string at the given offset. */
-function digits2(s, offset) {
-	return (code(s, offset) - 48) * 10 + (code(s, offset + 1) - 48);
-}
-/** Extract a 4-digit number from a string at the given offset. */
-function digits4(s, offset) {
-	return (code(s, offset) - 48) * 1e3 + (code(s, offset + 1) - 48) * 100 + (code(s, offset + 2) - 48) * 10 + (code(s, offset + 3) - 48);
+const DATE_DIGITS = 8;
+/** The date fields of the first `digits` digits of `value`. */
+function readDate(value, digits) {
+	const date = { year: numberAt(value, 0, 4) };
+	if (digits >= 6) date.month = numberAt(value, 4, 2);
+	if (digits >= 8) date.day = numberAt(value, 6, 2);
+	return date;
 }
-/** Check if a character at the given offset is an ASCII digit. */
-function isDigit(s, offset) {
-	const cp = code(s, offset);
-	return cp >= 48 && cp <= 57;
-}
-function validateDigits(value, end) {
-	for (let i = 0; i < end; i += 1) if (!isDigit(value, i)) return false;
-	return true;
+/** The time fields of `digits` digits of `value` from `start`. */
+function readTime(value, start, digits) {
+	const time = {};
+	if (digits >= 2) time.hour = numberAt(value, start, 2);
+	if (digits >= 4) time.minute = numberAt(value, start + 2, 2);
+	if (digits >= 6) time.second = numberAt(value, start + 4, 2);
+	return time;
 }
 /**
-* An immutable HL7v2 timestamp value with precision tracking.
-*
-* Represents the HL7v2 TS (Time Stamp) data type:
-* `YYYY[MM[DD[HH[MM[SS[.S[S[S[S]]]]]]]]][+/-ZZZZ]`
+* Parses an HL7v2 DT (Date) value, `YYYY[MM[DD]]`.
 *
-* Tracks precision so that round-tripping is lossless:
-* `Timestamp.parse("20260307").toString()` returns `"20260307"`, not
-* `"20260307000000"`.
+* Fails with `invalid-format` when the value does not follow the format, and
+* with `month-out-of-range` or `day-out-of-range` when it is not a calendar
+* date, such as `20250229`. Never throws.
 *
-* Performance characteristics (optimized for high-throughput streaming):
+* @example
+*   ```ts
+*   parseDT("202603");
+*   // { success: true, data: { year: 2026, month: 3, precision: "month" } }
+*   ```;
+*/
+function parseDT(value) {
+	const layout = readLayout(value);
+	const precision = DT_PRECISION.get(layout?.digits ?? 0);
+	const datePartsOnly = layout?.fraction === void 0 && layout?.offset === void 0;
+	if (!layout || precision === void 0 || !datePartsOnly) return INVALID_FORMAT;
+	const date = readDate(value, layout.digits);
+	const issue = checkDate(date.year, date.month, date.day);
+	if (issue) return {
+		issue,
+		success: false
+	};
+	return {
+		data: {
+			...date,
+			precision
+		},
+		success: true
+	};
+}
+/**
+* Parses an HL7v2 TM (Time) value, `HH[MM[SS[.S[S[S[S]]]]]][+/-ZZZZ]`.
 *
-* - `toString()`: Direct string concatenation, no intermediate arrays
-* - `parse()`: Manual character extraction, no regex or match arrays
-* - Constant-time precision lookups via Map
-* - Pre-computed pad table eliminates padStart overhead
+* Fails with `invalid-format` when the value does not follow the format, and
+* with `hour-out-of-range`, `minute-out-of-range`, `second-out-of-range`, or
+* `offset-out-of-range` when a field is out of range. Never throws.
 *
 * @example
-*   ```typescript
-*   // From a Date
-*   Timestamp.from(new Date(), { precision: "day" }).toString(); // "20260307"
+*   ```ts
+*   parseTM("1430-0500");
+*   // { success: true, data: { hour: 14, minute: 30, offset: -300, precision: "minute" } }
+*   ```;
+*/
+function parseTM(value) {
+	const layout = readLayout(value);
+	const precision = TM_PRECISION.get(layout?.digits ?? 0);
+	const fractionAllowed = layout?.fraction === void 0 || precision === "second";
+	if (!layout || precision === void 0 || !fractionAllowed) return INVALID_FORMAT;
+	const { hour = 0, minute, second } = readTime(value, 0, layout.digits);
+	const issue = checkTime(hour, minute, second) ?? checkOffset(layout.offset);
+	if (issue) return {
+		issue,
+		success: false
+	};
+	const data = {
+		hour,
+		precision
+	};
+	if (minute !== void 0) data.minute = minute;
+	if (second !== void 0) data.second = second;
+	if (layout.fraction !== void 0) data.fraction = layout.fraction;
+	if (layout.offset !== void 0) data.offset = layout.offset.total;
+	return {
+		data,
+		success: true
+	};
+}
+/**
+* Parses an HL7v2 DTM (Date/Time) value,
+* `YYYY[MM[DD[HH[MM[SS[.S[S[S[S]]]]]]]]][+/-ZZZZ]`. Also parses TS.1.
 *
-*   // Parse an HL7v2 string (timezone is applied to the Date)
-*   const ts = Timestamp.parse("20260307143000-0500");
-*   ts.precision; // "second"
-*   ts.toDate(); // Date representing 2026-03-07T19:30:00Z
+* Fails with `invalid-format` when the value does not follow the format, and
+* with the issue of the first field out of range otherwise, such as
+* `day-out-of-range` for `20250229`. The date is checked as written, before
+* any offset applies. Never throws.
 *
-*   // Current time
-*   Timestamp.now().toString(); // "20260307143045"
+* @example
+*   ```ts
+*   parseDTM("20260307143045-0500");
+*   // { success: true, data: { year: 2026, month: 3, day: 7, hour: 14,
+*   //   minute: 30, second: 45, offset: -300, precision: "second" } }
 *   ```;
 */
-var Timestamp = class Timestamp {
-	#date;
-	precision;
-	/**
-	* Timezone offset in minutes (getTimezoneOffset convention).
-	* Set when the timestamp carries timezone information — either from parsing
-	* a string with a +/-ZZZZ suffix, or from creating via from()/now() with
-	* timezone: true.
-	*
-	* When set, toString() uses UTC getters + this offset to derive the local
-	* time components, ensuring correct formatting regardless of server timezone.
-	* When undefined, toString() uses local getters (no timezone suffix).
-	*/
-	#offset;
-	/** Raw fractional seconds string from parsing, for lossless round-trip. */
-	#fractionalRaw;
-	constructor(date, precision, offset, fractionalRaw) {
-		this.#date = date;
-		this.precision = precision;
-		this.#offset = offset;
-		this.#fractionalRaw = fractionalRaw;
-	}
-	/**
-	* Create a Timestamp from a JavaScript Date.
-	*
-	* @param date - A valid Date object
-	* @param options - Precision and timezone options
-	* @throws {TypeError} If the Date is invalid
-	*/
-	static from(date, options) {
-		if (Number.isNaN(date.getTime())) throw new TypeError("Invalid Date provided to Timestamp.from");
-		const precision = options?.precision ?? "second";
-		const precisionIndex = PRECISION_INDEX.get(precision) ?? 5;
-		const includeTimezone = (options?.timezone ?? false) && precisionIndex >= MIN_TIMEZONE_PRECISION;
-		const copy = new Date(date);
-		return new Timestamp(copy, precision, includeTimezone ? copy.getTimezoneOffset() : void 0);
-	}
-	/**
-	* Parse an HL7v2 timestamp string into a Timestamp.
-	*
-	* Uses manual character-based extraction instead of regex to avoid
-	* match array allocation and Number() conversions. In benchmarks this
-	* is ~2-3x faster than regex-based parsing for the common case.
-	*
-	* @param value - An HL7v2 TS-formatted string
-	* @throws {TypeError} If the string is not a valid HL7v2 timestamp
-	*/
-	static parse(value) {
-		const len = value.length;
-		if (len < 4) throw new TypeError(`Invalid HL7v2 timestamp: "${value}"`);
-		let coreEnd = len;
-		let dotPos = -1;
-		let tzPos = -1;
-		for (let i = 0; i < len; i += 1) {
-			const ch = value.codePointAt(i);
-			if (ch === 46) {
-				dotPos = i;
-				coreEnd = i;
-				break;
-			}
-			if ((ch === 43 || ch === 45) && i >= 4) {
-				tzPos = i;
-				coreEnd = i;
-				break;
-			}
-		}
-		if (dotPos >= 0) for (let i = dotPos + 1; i < len; i += 1) {
-			const ch = value.codePointAt(i);
-			if (ch === 43 || ch === 45) {
-				tzPos = i;
-				break;
-			}
-		}
-		if (coreEnd < 4 || coreEnd > 14 || coreEnd % 2 !== 0) throw new TypeError(`Invalid HL7v2 timestamp: "${value}"`);
-		if (!validateDigits(value, coreEnd)) throw new TypeError(`Invalid HL7v2 timestamp: "${value}"`);
-		const year = digits4(value, 0);
-		const month = coreEnd >= 6 ? digits2(value, 4) - 1 : 0;
-		const day = coreEnd >= 8 ? digits2(value, 6) : 1;
-		const hour = coreEnd >= 10 ? digits2(value, 8) : 0;
-		const minute = coreEnd >= 12 ? digits2(value, 10) : 0;
-		const second = coreEnd >= 14 ? digits2(value, 12) : 0;
-		let ms = 0;
-		let fractionalRaw;
-		if (dotPos >= 0) {
-			const fracEnd = tzPos >= 0 ? tzPos : len;
-			fractionalRaw = value.slice(dotPos, fracEnd);
-			const fracDigits = fracEnd - dotPos - 1;
-			if (fracDigits < 1 || fracDigits > 4) throw new TypeError(`Invalid HL7v2 timestamp: "${value}"`);
-			for (let i = dotPos + 1; i < fracEnd; i += 1) if (!isDigit(value, i)) throw new TypeError(`Invalid HL7v2 timestamp: "${value}"`);
-			const d0 = fracDigits >= 1 ? code(value, dotPos + 1) - 48 : 0;
-			const d1 = fracDigits >= 2 ? code(value, dotPos + 2) - 48 : 0;
-			const d2 = fracDigits >= 3 ? code(value, dotPos + 3) - 48 : 0;
-			ms = d0 * 100 + d1 * 10 + d2;
-		}
-		let parsedOffset = 0;
-		const hasTimezone = tzPos >= 0;
-		if (hasTimezone) {
-			if (len - tzPos !== 5) throw new TypeError(`Invalid HL7v2 timestamp: "${value}"`);
-			for (let i = tzPos + 1; i < len; i += 1) if (!isDigit(value, i)) throw new TypeError(`Invalid HL7v2 timestamp: "${value}"`);
-			const tzSign = value.codePointAt(tzPos) === 43 ? -1 : 1;
-			const tzHours = digits2(value, tzPos + 1);
-			const tzMinutes = digits2(value, tzPos + 3);
-			parsedOffset = tzSign * (tzHours * 60 + tzMinutes) || 0;
-		}
-		const precision = fractionalRaw ? "millisecond" : PRECISION_BY_LENGTH.get(coreEnd) ?? "year";
-		let date;
-		if (hasTimezone) {
-			const utcMs = Date.UTC(year, month, day, hour, minute, second, ms) + parsedOffset * 6e4;
-			date = new Date(utcMs);
-			if (year < 100) date.setUTCFullYear(year);
-		} else {
-			date = new Date(year, month, day, hour, minute, second, ms);
-			date.setFullYear(year);
-		}
-		return new Timestamp(date, precision, hasTimezone ? parsedOffset : void 0, fractionalRaw);
-	}
-	/**
-	* Create a Timestamp for the current time.
-	*
-	* Performance: Skips the defensive Date copy in from() since we own the
-	* Date object — it was just created and no external reference exists.
-	*
-	* @param options - Precision and timezone options
-	*/
-	static now(options) {
-		const date = /* @__PURE__ */ new Date();
-		const precision = options?.precision ?? "second";
-		const precisionIndex = PRECISION_INDEX.get(precision) ?? 5;
-		return new Timestamp(date, precision, (options?.timezone ?? false) && precisionIndex >= MIN_TIMEZONE_PRECISION ? date.getTimezoneOffset() : void 0);
-	}
-	/**
-	* Return a copy of the underlying Date object.
-	*/
-	toDate() {
-		return new Date(this.#date);
-	}
-	/**
-	* Format as an HL7v2 timestamp string, respecting the precision level.
-	*
-	* Performance: Uses direct string concatenation instead of array.join().
-	* V8 optimizes template literal concatenation into a single allocation,
-	* while the array approach required: 1 array + 6 strings + slice + join
-	* = ~9 allocations per call. This approach: 1 string concatenation.
-	*/
-	toString() {
-		const d = this.#date;
-		let yyyy;
-		let mm;
-		let dd;
-		let hh;
-		let min;
-		let ss;
-		if (this.#offset === void 0) {
-			const y = d.getFullYear();
-			yyyy = y >= 1e3 ? String(y) : String(y).padStart(4, "0");
-			mm = pad2(d.getMonth() + 1);
-			dd = pad2(d.getDate());
-			hh = pad2(d.getHours());
-			min = pad2(d.getMinutes());
-			ss = pad2(d.getSeconds());
-		} else {
-			const local = /* @__PURE__ */ new Date(d.getTime() - this.#offset * 6e4);
-			const y = local.getUTCFullYear();
-			yyyy = y >= 1e3 ? String(y) : String(y).padStart(4, "0");
-			mm = pad2(local.getUTCMonth() + 1);
-			dd = pad2(local.getUTCDate());
-			hh = pad2(local.getUTCHours());
-			min = pad2(local.getUTCMinutes());
-			ss = pad2(local.getUTCSeconds());
-		}
-		let result;
-		switch (this.precision) {
-			case "year":
-				result = yyyy;
-				break;
-			case "month":
-				result = `${yyyy}${mm}`;
-				break;
-			case "day":
-				result = `${yyyy}${mm}${dd}`;
-				break;
-			case "hour":
-				result = `${yyyy}${mm}${dd}${hh}`;
-				break;
-			case "minute":
-				result = `${yyyy}${mm}${dd}${hh}${min}`;
-				break;
-			case "second":
-				result = `${yyyy}${mm}${dd}${hh}${min}${ss}`;
-				break;
-			case "millisecond": {
-				const base = `${yyyy}${mm}${dd}${hh}${min}${ss}`;
-				if (this.#fractionalRaw) result = `${base}${this.#fractionalRaw}`;
-				else {
-					const msVal = d.getMilliseconds();
-					if (msVal === 0) result = `${base}.0`;
-					else if (msVal % 100 === 0) result = `${base}.${msVal / 100}`;
-					else if (msVal % 10 === 0) result = `${base}.${pad2(msVal / 10)}`;
-					else result = `${base}.${String(msVal).padStart(3, "0")}`;
-				}
-				break;
-			}
-			default: {
-				const _exhaustive = this.precision;
-				throw new TypeError(`Unknown precision: ${_exhaustive}`);
-			}
-		}
-		if (this.#offset !== void 0) result += formatOffset(this.#offset);
-		return result;
-	}
+function parseDTM(value) {
+	const layout = readLayout(value);
+	const precision = DTM_PRECISION.get(layout?.digits ?? 0);
+	const fractionAllowed = layout?.fraction === void 0 || precision === "second";
+	if (!layout || precision === void 0 || !fractionAllowed) return INVALID_FORMAT;
+	const date = readDate(value, layout.digits);
+	const time = readTime(value, DATE_DIGITS, layout.digits - DATE_DIGITS);
+	const issue = checkDate(date.year, date.month, date.day) ?? checkTime(time.hour, time.minute, time.second) ?? checkOffset(layout.offset);
+	if (issue) return {
+		issue,
+		success: false
+	};
+	const data = {
+		...date,
+		...time,
+		precision
+	};
+	if (layout.fraction !== void 0) data.fraction = layout.fraction;
+	if (layout.offset !== void 0) data.offset = layout.offset.total;
+	return {
+		data,
+		success: true
+	};
+}
+//#endregion
+//#region src/precision.ts
+/**
+* How much of a date and time an HL7v2 value gives, from the year down to the
+* second. Digits after the second are carried by `fraction`.
+*
+* | Precision | DTM written as   | Example          |
+* | --------- | ---------------- | ---------------- |
+* | `year`    | `YYYY`           | `2026`           |
+* | `month`   | `YYYYMM`         | `202603`         |
+* | `day`     | `YYYYMMDD`       | `20260307`       |
+* | `hour`    | `YYYYMMDDHH`     | `2026030714`     |
+* | `minute`  | `YYYYMMDDHHMM`   | `202603071430`   |
+* | `second`  | `YYYYMMDDHHMMSS` | `20260307143045` |
+*/
+const Precision = {
+	Year: "year",
+	Month: "month",
+	Day: "day",
+	Hour: "hour",
+	Minute: "minute",
+	Second: "second"
 };
 //#endregion
-export { Precision, Timestamp };
+export { Precision, formatDT, formatDTM, formatTM, parseDT, parseDTM, parseTM };
 
 //# sourceMappingURL=index.js.map