@pritiranjan/hl7v2 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Pritiranjan Swain <priti2chand@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,434 @@
+# hl7v2
+
+> Parse, query, build and re-encode HL7 v2.x messages — zero dependencies, TypeScript native.
+
+[![npm version](https://img.shields.io/npm/v/@pritiranjan/hl7v2.svg)](https://www.npmjs.com/package/@pritiranjan/hl7v2)
+[![CI](https://github.com/hkpritiranjan/hl7v2/actions/workflows/ci.yml/badge.svg)](https://github.com/hkpritiranjan/hl7v2/actions)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+HL7 v2 is the most widely deployed healthcare messaging standard in the world — driving lab orders, ADT admissions, radiology reports, billing workflows, and much more. Yet every existing JavaScript library for it is either unmaintained, poorly typed, or missing key capabilities.
+
+**hl7v2** provides a production-quality TypeScript implementation with:
+
+- **Strict TypeScript** — `exactOptionalPropertyTypes`, `noUncheckedIndexedAccess`, full generics
+- **Round-trip fidelity** — `encode(parse(raw)) === raw`, critical for ACK generation and message forwarding
+- **Zero runtime dependencies** — nothing to audit, nothing to break
+- **1-based HL7 addressing** — `get(msg, 'PID', 5, 1)` maps directly to the HL7 spec's `PID.5.1`
+- **Typed segment helpers** — `new PID(seg, msg.encoding).patientName()` returns `{ family, given, middle, ... }` not a raw string
+- **ESM + CJS** — works in Node.js, Deno, Bun, and bundlers (Webpack, Vite, esbuild)
+
+---
+
+## Table of contents
+
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Supported HL7 versions](#supported-hl7-versions)
+- [API reference](#api-reference)
+  - [parse()](#parse)
+  - [encode()](#encode)
+  - [Query API](#query-api)
+  - [Typed segment helpers](#typed-segment-helpers)
+  - [Escape sequences](#escape-sequences)
+  - [Date / time utilities](#date--time-utilities)
+- [HL7Message structure](#hl7message-structure)
+- [Real-world examples](#real-world-examples)
+- [Contributing](#contributing)
+- [License](#license)
+
+---
+
+## Installation
+
+```bash
+npm install @pritiranjan/hl7v2
+# or
+yarn add @pritiranjan/hl7v2
+# or
+pnpm add @pritiranjan/hl7v2
+```
+
+**Requires Node.js ≥ 18.** No runtime dependencies.
+
+---
+
+## Quick start
+
+```typescript
+import { parse, get, segment, segments, encode } from '@pritiranjan/hl7v2';
+import { PID, OBX } from '@pritiranjan/hl7v2/segments';
+
+const raw = `MSH|^~\\&|LAB|HOSPITAL|EHR|FACILITY|20240315150055||ORU^R01^ORU_R01|MSG001|P|2.5.1
+PID|1||MRN123^^^HOSPITAL^MR||Doe^John^A||19800305|M
+OBX|1|NM|718-7^Hemoglobin^LN||13.5|g/dL|13.5-17.5|N|||F`;
+
+const msg = parse(raw);
+
+// Convenience accessors on the top-level message object
+console.log(msg.version);            // '2.5.1'
+console.log(msg.messageType);        // { type: 'ORU', event: 'R01', structure: 'ORU_R01' }
+console.log(msg.messageControlId);   // 'MSG001'
+console.log(msg.sendingApplication); // 'LAB'
+
+// Generic query API — field numbers follow the HL7 spec directly
+const mrn      = get(msg, 'PID', 3, 1);  // PID.3.1 → 'MRN123'
+const lastName = get(msg, 'PID', 5, 1);  // PID.5.1 → 'Doe'
+const dob      = get(msg, 'PID', 7);     // PID.7   → '19800305'
+
+// Typed segment helpers — IDE-friendly, no field numbers to memorise
+const pid = new PID(segment(msg, 'PID'), msg.encoding);
+const name = pid.patientName();
+// → { family: 'Doe', given: 'John', middle: 'A', suffix: '', prefix: '', degree: '' }
+
+// Iterate multiple OBX results
+const obxList = segments(msg, 'OBX').map(s => new OBX(s, msg.encoding));
+for (const obx of obxList) {
+  console.log(obx.observationIdentifier().description); // 'Hemoglobin'
+  console.log(obx.numericValue());                      // 13.5
+  console.log(obx.units());                             // 'g/dL'
+  console.log(obx.isFinal());                           // true
+  console.log(obx.isCritical());                        // false
+}
+
+// Round-trip encode — byte-identical to the original input
+const reEncoded = encode(msg);
+```
+
+---
+
+## Supported HL7 versions
+
+All HL7 v2.x versions from **v2.1** through **v2.8** are supported. The parser reads the encoding characters from MSH.1/MSH.2 and handles any valid separator configuration, including non-default characters.
+
+Common message types handled: ADT, ORU, ORM, OML, SIU, MDM, DFT, BAR, ACK, QRY, RSP.
+
+---
+
+## API reference
+
+### `parse()`
+
+```typescript
+function parse(raw: string, options?: ParseOptions): HL7Message
+```
+
+Parse an HL7 v2 message string into a structured object.
+
+**Parameters:**
+
+| Parameter | Type | Description |
+|---|---|---|
+| `raw` | `string` | The raw HL7 message. Supports `\r`, `\n`, or `\r\n` segment terminators. |
+| `options.decodeEscapes` | `boolean` | Decode HL7 escape sequences in field values. Default: `false`. |
+
+**Line endings**: `\r` (canonical HL7), `\n` (Unix), and `\r\n` (Windows) are all accepted and normalised internally. The detected line ending is preserved in `msg.lineEnding` and used by `encode()` to restore byte-identical output.
+
+**Throws:**
+- `InvalidHL7Error` — when the input is empty or does not start with `MSH`
+- `HL7ParseError` — when a segment identifier or structure is malformed
+
+```typescript
+import { parse } from '@pritiranjan/hl7v2';
+
+const msg = parse(rawString);
+// msg.version, msg.messageType, msg.segments, ...
+
+// With escape decoding (values become human-readable; NOT safe for re-encoding)
+const decoded = parse(rawString, { decodeEscapes: true });
+```
+
+---
+
+### `encode()`
+
+```typescript
+function encode(msg: HL7Message, options?: EncodeOptions): string
+```
+
+Encode a parsed message back into a raw HL7 string.
+
+**Options:**
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `lineEnding` | `'\r' \| '\n' \| '\r\n'` | `msg.lineEnding` | Segment separator |
+| `trailingNewline` | `boolean` | `false` | Append a line ending after the final segment |
+
+**Round-trip guarantee**: when called on a message parsed with default options (`decodeEscapes` not set to `true`), `encode(parse(raw))` is byte-identical to `raw.trim()`.
+
+```typescript
+import { parse, encode } from '@pritiranjan/hl7v2';
+
+const msg  = parse(rawString);
+const back = encode(msg);              // identical to input
+const crlf = encode(msg, { lineEnding: '\r\n' }); // Windows style
+```
+
+---
+
+### Query API
+
+All field addresses are **1-based**, matching the HL7 specification directly.
+
+#### `segment(msg, id, options?)`
+
+Return the first matching segment. Throws `SegmentNotFoundError` if absent.
+
+```typescript
+import { segment } from '@pritiranjan/hl7v2';
+
+const pid = segment(msg, 'PID');
+
+// Access a specific occurrence when segment repeats (1-based)
+const obx2 = segment(msg, 'OBX', { segmentIndex: 2 });
+```
+
+#### `segments(msg, id)`
+
+Return all matching segments as an array. Returns `[]`, never throws.
+
+```typescript
+import { segments } from '@pritiranjan/hl7v2';
+
+const allOBX = segments(msg, 'OBX');
+```
+
+#### `hasSegment(msg, id)`
+
+```typescript
+import { hasSegment } from '@pritiranjan/hl7v2';
+
+if (hasSegment(msg, 'PV1')) { /* ... */ }
+```
+
+#### `get(msg, segmentId, field, component?, subComponent?, options?)`
+
+Extract a scalar string value. Returns `''` for missing elements — never throws.
+
+```typescript
+import { get } from '@pritiranjan/hl7v2';
+
+get(msg, 'PID', 3)           // PID.3   — patient identifier
+get(msg, 'PID', 5, 1)        // PID.5.1 — family name
+get(msg, 'PID', 5, 2)        // PID.5.2 — given name
+get(msg, 'PID', 11, 5)       // PID.11.5 — postal code
+
+// Decode HL7 escape sequences in the returned value
+get(msg, 'PID', 5, 1, 1, { decode: true })
+
+// Second repetition (1-based)
+get(msg, 'PID', 3, 1, 1, { repetition: 2 })
+```
+
+#### `getFromSegment(seg, msg, field, component?, subComponent?, options?)`
+
+Like `get()` but operates on a pre-fetched `HL7Segment` — useful when iterating repeating segments.
+
+```typescript
+import { segments, getFromSegment } from '@pritiranjan/hl7v2';
+
+for (const obx of segments(msg, 'OBX')) {
+  const value = getFromSegment(obx, msg, 5);   // OBX.5
+  const loinc = getFromSegment(obx, msg, 3, 1); // OBX.3.1 — LOINC code
+}
+```
+
+#### `getRepetitions(msg, segmentId, field, options?)`
+
+Return all repetitions of a field as a `string[][][]` — one entry per repetition preserving the `[component][subComponent]` structure.
+
+```typescript
+import { getRepetitions } from '@pritiranjan/hl7v2';
+
+// PID.3 repeats for multiple patient identifiers
+const ids = getRepetitions(msg, 'PID', 3);
+ids[0]?.[0]?.[0]  // → 'MRN123'      (first identifier value)
+ids[0]?.[3]?.[0]  // → 'HOSPITAL'    (assigning authority, 0-indexed)
+ids[1]?.[0]?.[0]  // → 'SSN456'      (second identifier value)
+```
+
+---
+
+### Typed segment helpers
+
+Import from `hl7v2/segments`. Each class wraps a raw `HL7Segment` and exposes named, documented accessor methods.
+
+```typescript
+import { parse, segment, segments } from '@pritiranjan/hl7v2';
+import { MSH, PID, PV1, OBX } from '@pritiranjan/hl7v2/segments';
+
+const msg = parse(raw);
+
+// MSH — Message Header
+const msh = new MSH(segment(msg, 'MSH'), msg.encoding);
+msh.sendingApplication()           // 'HOSPITAL_ADT'
+msh.messageType()                  // { type: 'ADT', event: 'A01', structure: 'ADT_A01' }
+msh.messageControlId()             // 'MSG000001'
+msh.version()                      // '2.5.1'
+msh.processingId()                 // 'P'
+
+// PID — Patient Identification
+const pid = new PID(segment(msg, 'PID'), msg.encoding);
+pid.patientName()
+// → { family: 'Doe', given: 'John', middle: 'A', suffix: 'Jr', prefix: 'Mr', degree: 'MD' }
+pid.patientIdentifiers()
+// → [{ id: 'MRN123', assigningAuthority: 'HOSPITAL', identifierTypeCode: 'MR' }]
+pid.dateOfBirth()                  // Date | undefined
+pid.sex()                          // 'M' | 'F' | 'O' | 'U' | ...
+pid.address()
+// → { streetAddress: '123 Main St', city: 'Boston', state: 'MA', postalCode: '02101', ... }
+
+// PV1 — Patient Visit
+const pv1 = new PV1(segment(msg, 'PV1'), msg.encoding);
+pv1.patientClass()                 // 'I' (Inpatient)
+pv1.assignedLocation()
+// → { pointOfCare: 'CARDIOLOGY', room: '4A', bed: '101', facility: 'HOSPITAL' }
+pv1.attendingDoctor()
+// → { id: '1234567', family: 'Smith', given: 'Richard', credential: 'MD' }
+pv1.admitDateTime()                // Date | undefined
+
+// OBX — Observation / Lab Result
+const obxList = segments(msg, 'OBX').map(s => new OBX(s, msg.encoding));
+const obx = obxList[0]!;
+obx.observationIdentifier()
+// → { code: '718-7', description: 'Hemoglobin [Mass/volume] in Blood', codingSystem: 'LN' }
+obx.numericValue()                 // 13.5 (only when valueType() === 'NM')
+obx.units()                        // 'g/dL'
+obx.referenceRange()               // '13.5-17.5'
+obx.abnormalFlags()                // ['H'] | ['HH'] | ['N'] | []
+obx.resultStatus()                 // 'F' | 'P' | 'C' | ...
+obx.isFinal()                      // true
+obx.isCritical()                   // false  (true for HH or LL flags)
+```
+
+---
+
+### Escape sequences
+
+```typescript
+import { decodeEscapes, encodeEscapes } from '@pritiranjan/hl7v2';
+import { DEFAULT_ENCODING } from '@pritiranjan/hl7v2';
+
+// Decode HL7 escape sequences to their plain-text equivalents
+decodeEscapes('Dr\\S\\Smith', DEFAULT_ENCODING)   // 'Dr^Smith'
+decodeEscapes('line1\\.br\\line2', DEFAULT_ENCODING) // 'line1\nline2'
+decodeEscapes('\\X48656c6c6f\\', DEFAULT_ENCODING)  // 'Hello'
+
+// Encode a plain string for safe inclusion in an HL7 field
+encodeEscapes('value|with^seps', DEFAULT_ENCODING) // 'value\\F\\with\\S\\seps'
+```
+
+Supported sequences: `\F\`, `\S\`, `\T\`, `\R\`, `\E\`, `\H\`, `\N\`, `\.br\`, `\Xhh...\`.
+
+---
+
+### Date / time utilities
+
+```typescript
+import { parseHL7DateTime, formatHL7DateTime, formatHL7Date } from '@pritiranjan/hl7v2';
+
+// Parse any HL7 date/time format → Date in UTC
+parseHL7DateTime('20240315143022')         // Date: 2024-03-15 14:30:22 UTC
+parseHL7DateTime('20240315143022.456')     // with milliseconds
+parseHL7DateTime('20240315143022+0530')    // with timezone offset → UTC
+parseHL7DateTime('20240315')              // date-only → midnight UTC
+parseHL7DateTime('')                      // → undefined (empty = absent)
+
+// Format a Date to HL7 strings
+formatHL7DateTime(new Date())   // '20240315143022'
+formatHL7Date(new Date())       // '20240315'
+```
+
+---
+
+## HL7Message structure
+
+```typescript
+interface HL7Message {
+  version:              string;        // '2.5.1'
+  messageType:          MessageType;   // { type: 'ADT', event: 'A01', structure: 'ADT_A01' }
+  messageControlId:     string;        // 'MSG000001'
+  timestamp:            Date | undefined;
+  sendingApplication:   string;        // MSH.3
+  sendingFacility:      string;        // MSH.4
+  receivingApplication: string;        // MSH.5
+  receivingFacility:    string;        // MSH.6
+  processingId:         string;        // 'P' | 'D' | 'T'
+  segments:             HL7Segment[];
+  encoding:             EncodingChars;
+  raw:                  string;        // original input, trimmed
+  lineEnding:           '\r' | '\n' | '\r\n';
+}
+
+// A segment field: [repetition][component][subComponent]
+type HL7Field = string[][][];
+```
+
+---
+
+## Real-world examples
+
+### Parse a lab result and alert on critical values
+
+```typescript
+import { parse, segments } from '@pritiranjan/hl7v2';
+import { OBX } from '@pritiranjan/hl7v2/segments';
+
+function findCriticalResults(rawMessage: string) {
+  const msg = parse(rawMessage);
+  return segments(msg, 'OBX')
+    .map(s => new OBX(s, msg.encoding))
+    .filter(obx => obx.isCritical())
+    .map(obx => ({
+      code:        obx.observationIdentifier().code,
+      description: obx.observationIdentifier().description,
+      value:       obx.observationValue(),
+      units:       obx.units(),
+      flag:        obx.primaryAbnormalFlag(),
+    }));
+}
+```
+
+### Build an ACK response
+
+```typescript
+import { parse, encode, get } from '@pritiranjan/hl7v2';
+
+function buildAck(rawMessage: string, ackCode: 'AA' | 'AE' | 'AR'): string {
+  const msg = parse(rawMessage);
+  const now = new Date();
+  const ts  = `${now.getUTCFullYear()}${String(now.getUTCMonth() + 1).padStart(2, '0')}${String(now.getUTCDate()).padStart(2, '0')}`;
+
+  return [
+    `MSH|^~\\&|EHR|FACILITY|${msg.sendingApplication}|${msg.sendingFacility}|${ts}||ACK^${msg.messageType.event}|ACK${msg.messageControlId}|P|${msg.version}`,
+    `MSA|${ackCode}|${msg.messageControlId}`,
+  ].join(msg.lineEnding);
+}
+```
+
+### Extract all patient identifiers
+
+```typescript
+import { parse, getRepetitions } from '@pritiranjan/hl7v2';
+
+function getPatientIds(rawMessage: string) {
+  const msg = parse(rawMessage);
+  return getRepetitions(msg, 'PID', 3).map(rep => ({
+    id:                rep[0]?.[0] ?? '',
+    assigningAuthority: rep[3]?.[0] ?? '',
+    typeCode:          rep[4]?.[0] ?? '',
+  }));
+}
+```
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, coding conventions, and the pull request process.
+
+---
+
+## License
+
+MIT © [Pritiranjan Swain](https://github.com/hkpritiranjan)

package/dist/chunk-Q6NISXHR.js

@@ -0,0 +1,130 @@
+// src/errors.ts
+var HL7ParseError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "HL7ParseError";
+    this.line = options?.line;
+    this.segmentId = options?.segmentId;
+    if (options?.cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+};
+var SegmentNotFoundError = class extends Error {
+  constructor(segmentId) {
+    super(
+      `Segment '${segmentId}' not found in message. Use hasSegment() to check before calling segment(), or segments() to get an empty array when absent.`
+    );
+    this.name = "SegmentNotFoundError";
+    this.segmentId = segmentId;
+  }
+};
+var InvalidHL7Error = class extends Error {
+  constructor(reason) {
+    super(`Input is not a valid HL7 v2 message: ${reason}`);
+    this.name = "InvalidHL7Error";
+  }
+};
+
+// src/datetime.ts
+function parseHL7DateTime(raw) {
+  const s = raw.trim();
+  if (!s) return void 0;
+  if (s.length < 4) {
+    throw new HL7ParseError(`Cannot parse HL7 date/time: "${s}" \u2014 minimum format is YYYY`);
+  }
+  let base = s;
+  let offsetMin = 0;
+  const tzMatch = /([+-])(\d{2})(\d{2})$/.exec(s);
+  if (tzMatch) {
+    const sign = tzMatch[1] === "+" ? 1 : -1;
+    const tzHours = parseInt(tzMatch[2] ?? "0", 10);
+    const tzMins = parseInt(tzMatch[3] ?? "0", 10);
+    offsetMin = sign * (tzHours * 60 + tzMins);
+    base = s.slice(0, s.length - 5);
+  }
+  let fracMs = 0;
+  const dotIdx = base.indexOf(".");
+  if (dotIdx !== -1) {
+    const fracStr = base.slice(dotIdx);
+    fracMs = Math.round(parseFloat(fracStr) * 1e3);
+    base = base.slice(0, dotIdx);
+  }
+  const year = parseInt(base.slice(0, 4), 10);
+  const month = parseInt(base.slice(4, 6) || "01", 10) - 1;
+  const day = parseInt(base.slice(6, 8) || "01", 10);
+  const hour = parseInt(base.slice(8, 10) || "00", 10);
+  const min = parseInt(base.slice(10, 12) || "00", 10);
+  const sec = parseInt(base.slice(12, 14) || "00", 10);
+  if (isNaN(year) || isNaN(month) || isNaN(day)) {
+    throw new HL7ParseError(`Cannot parse HL7 date/time: "${s}"`);
+  }
+  const utcMs = Date.UTC(year, month, day, hour, min, sec, fracMs) - offsetMin * 6e4;
+  const result = new Date(utcMs);
+  if (isNaN(result.getTime())) {
+    throw new HL7ParseError(`Cannot parse HL7 date/time: "${s}"`);
+  }
+  return result;
+}
+function formatHL7DateTime(date) {
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  return pad(date.getUTCFullYear(), 4) + pad(date.getUTCMonth() + 1) + pad(date.getUTCDate()) + pad(date.getUTCHours()) + pad(date.getUTCMinutes()) + pad(date.getUTCSeconds());
+}
+function formatHL7Date(date) {
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  return pad(date.getUTCFullYear(), 4) + pad(date.getUTCMonth() + 1) + pad(date.getUTCDate());
+}
+
+// src/escape.ts
+function escRx(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function decodeEscapes(value, enc) {
+  const esc = enc.escape;
+  if (!value.includes(esc)) return value;
+  const pattern = new RegExp(`${escRx(esc)}([^${escRx(esc)}]*)${escRx(esc)}`, "g");
+  return value.replace(pattern, (match, seq) => {
+    switch (seq) {
+      case "F":
+        return enc.field;
+      case "S":
+        return enc.component;
+      case "T":
+        return enc.subComponent;
+      case "R":
+        return enc.repetition;
+      case "E":
+        return enc.escape;
+      case "H":
+        return "\x1B[1m";
+      case "N":
+        return "\x1B[0m";
+      case ".br":
+        return "\n";
+      default: {
+        if (seq.startsWith("X") && seq.length > 1) {
+          try {
+            const hex = seq.slice(1);
+            const bytes = new Uint8Array(hex.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) ?? []);
+            return new TextDecoder().decode(bytes);
+          } catch {
+            return match;
+          }
+        }
+        return match;
+      }
+    }
+  });
+}
+function encodeEscapes(value, enc) {
+  const esc = enc.escape;
+  return value.replace(new RegExp(escRx(esc), "g"), `${esc}E${esc}`).replace(new RegExp(escRx(enc.field), "g"), `${esc}F${esc}`).replace(new RegExp(escRx(enc.component), "g"), `${esc}S${esc}`).replace(new RegExp(escRx(enc.repetition), "g"), `${esc}R${esc}`).replace(new RegExp(escRx(enc.subComponent), "g"), `${esc}T${esc}`);
+}
+
+export { HL7ParseError, InvalidHL7Error, SegmentNotFoundError, decodeEscapes, encodeEscapes, formatHL7Date, formatHL7DateTime, parseHL7DateTime };
+//# sourceMappingURL=chunk-Q6NISXHR.js.map
+//# sourceMappingURL=chunk-Q6NISXHR.js.map

package/dist/chunk-Q6NISXHR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/datetime.ts","../src/escape.ts"],"names":[],"mappings":"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","file":"chunk-Q6NISXHR.js","sourcesContent":["/**\n * Thrown when an HL7 v2 message string cannot be parsed.\n *\n * The `line` and `segmentId` properties help pinpoint the exact failure location\n * when debugging multi-segment messages from production systems.\n */\nexport class HL7ParseError extends Error {\n  /** 1-based line number in the source string where the error occurred. */\n  readonly line: number | undefined;\n  /** Segment identifier that was being parsed when the error occurred. */\n  readonly segmentId: string | undefined;\n\n  constructor(\n    message: string,\n    options?: { line?: number; segmentId?: string; cause?: unknown },\n  ) {\n    super(message);\n    this.name = 'HL7ParseError';\n    this.line = options?.line;\n    this.segmentId = options?.segmentId;\n    if (options?.cause !== undefined) {\n      Object.defineProperty(this, 'cause', {\n        value: options.cause,\n        writable: true,\n        configurable: true,\n      });\n    }\n  }\n}\n\n/**\n * Thrown when a required segment is not present in the message.\n *\n * @example\n * // Thrown by segment() when the segment is not found\n * const pid = segment(msg, 'PID'); // throws if no PID segment\n */\nexport class SegmentNotFoundError extends Error {\n  readonly segmentId: string;\n\n  constructor(segmentId: string) {\n    super(\n      `Segment '${segmentId}' not found in message. ` +\n        `Use hasSegment() to check before calling segment(), ` +\n        `or segments() to get an empty array when absent.`,\n    );\n    this.name = 'SegmentNotFoundError';\n    this.segmentId = segmentId;\n  }\n}\n\n/**\n * Thrown when an HL7 message cannot be identified as valid HL7 v2.\n * Usually means the input is empty, truncated, or a completely different format.\n */\nexport class InvalidHL7Error extends Error {\n  constructor(reason: string) {\n    super(`Input is not a valid HL7 v2 message: ${reason}`);\n    this.name = 'InvalidHL7Error';\n  }\n}\n","import { HL7ParseError } from './errors.js';\n\n/**\n * Parse an HL7 v2 Date/Time string into a JavaScript `Date`.\n *\n * Supported formats (per HL7 v2 spec section 2.8.21):\n * - `YYYY`\n * - `YYYYMM`\n * - `YYYYMMDD`\n * - `YYYYMMDDHHMM`\n * - `YYYYMMDDHHMMSS`\n * - `YYYYMMDDHHMMSS.S[SSS]`\n * - Any of the above with `+HHMM` or `-HHMM` timezone offset suffix\n *\n * @returns A `Date` object in UTC, or `undefined` if the value is empty.\n * @throws {HL7ParseError} If the string is non-empty but unparseable.\n */\nexport function parseHL7DateTime(raw: string): Date | undefined {\n  const s = raw.trim();\n  if (!s) return undefined;\n\n  // Minimum valid length is 4 (year only)\n  if (s.length < 4) {\n    throw new HL7ParseError(`Cannot parse HL7 date/time: \"${s}\" — minimum format is YYYY`);\n  }\n\n  // Extract optional timezone offset: +HHMM or -HHMM at end\n  let base = s;\n  let offsetMin = 0;\n\n  const tzMatch = /([+-])(\\d{2})(\\d{2})$/.exec(s);\n  if (tzMatch) {\n    const sign = tzMatch[1] === '+' ? 1 : -1;\n    const tzHours = parseInt(tzMatch[2] ?? '0', 10);\n    const tzMins  = parseInt(tzMatch[3] ?? '0', 10);\n    offsetMin = sign * (tzHours * 60 + tzMins);\n    base = s.slice(0, s.length - 5);\n  }\n\n  // Parse fractional seconds: YYYYMMDDHHMMSS.SSSS\n  let fracMs = 0;\n  const dotIdx = base.indexOf('.');\n  if (dotIdx !== -1) {\n    const fracStr = base.slice(dotIdx);\n    fracMs = Math.round(parseFloat(fracStr) * 1000);\n    base = base.slice(0, dotIdx);\n  }\n\n  const year  = parseInt(base.slice(0, 4),  10);\n  const month = parseInt(base.slice(4, 6)  || '01', 10) - 1; // 0-indexed\n  const day   = parseInt(base.slice(6, 8)  || '01', 10);\n  const hour  = parseInt(base.slice(8, 10) || '00', 10);\n  const min   = parseInt(base.slice(10, 12)|| '00', 10);\n  const sec   = parseInt(base.slice(12, 14)|| '00', 10);\n\n  if (isNaN(year) || isNaN(month) || isNaN(day)) {\n    throw new HL7ParseError(`Cannot parse HL7 date/time: \"${s}\"`);\n  }\n\n  // Build UTC epoch, then subtract the timezone offset to normalise to UTC\n  const utcMs = Date.UTC(year, month, day, hour, min, sec, fracMs) - offsetMin * 60_000;\n  const result = new Date(utcMs);\n\n  if (isNaN(result.getTime())) {\n    throw new HL7ParseError(`Cannot parse HL7 date/time: \"${s}\"`);\n  }\n\n  return result;\n}\n\n/**\n * Format a JavaScript `Date` as an HL7 v2 timestamp string in UTC.\n * Output format: `YYYYMMDDHHMMSS`\n */\nexport function formatHL7DateTime(date: Date): string {\n  const pad = (n: number, len = 2): string => String(n).padStart(len, '0');\n  return (\n    pad(date.getUTCFullYear(), 4) +\n    pad(date.getUTCMonth() + 1) +\n    pad(date.getUTCDate()) +\n    pad(date.getUTCHours()) +\n    pad(date.getUTCMinutes()) +\n    pad(date.getUTCSeconds())\n  );\n}\n\n/**\n * Format a JavaScript `Date` as an HL7 v2 date-only string in UTC.\n * Output format: `YYYYMMDD`\n */\nexport function formatHL7Date(date: Date): string {\n  const pad = (n: number, len = 2): string => String(n).padStart(len, '0');\n  return (\n    pad(date.getUTCFullYear(), 4) +\n    pad(date.getUTCMonth() + 1) +\n    pad(date.getUTCDate())\n  );\n}\n","import type { EncodingChars } from './schema.js';\n\n/** Escape a string for use in a regex character class. */\nfunction escRx(s: string): string {\n  return s.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/**\n * Decode HL7 v2 escape sequences within a field value.\n *\n * Handles all standard sequences defined in the HL7 v2.x specification:\n * - `\\F\\`   → field separator\n * - `\\S\\`   → component separator\n * - `\\T\\`   → sub-component separator\n * - `\\R\\`   → repetition separator\n * - `\\E\\`   → escape character\n * - `\\H\\`   → start highlighting (stripped — presentation concern)\n * - `\\N\\`   → normal text / end highlighting (stripped)\n * - `\\.br\\` → carriage return / line break → `\\n`\n * - `\\Xhh…\\` → hex-encoded bytes → UTF-8 string\n *\n * Unknown or locally-defined sequences (`\\Zxxx\\`) are preserved as-is.\n *\n * @param value - Raw field value that may contain escape sequences\n * @param enc   - Encoding characters from the message's MSH segment\n */\nexport function decodeEscapes(value: string, enc: EncodingChars): string {\n  const esc = enc.escape;\n  if (!value.includes(esc)) return value;\n\n  const pattern = new RegExp(`${escRx(esc)}([^${escRx(esc)}]*)${escRx(esc)}`, 'g');\n\n  return value.replace(pattern, (match: string, seq: string): string => {\n    switch (seq) {\n      case 'F':   return enc.field;\n      case 'S':   return enc.component;\n      case 'T':   return enc.subComponent;\n      case 'R':   return enc.repetition;\n      case 'E':   return enc.escape;\n      case 'H':   return '\\x1b[1m';\n      case 'N':   return '\\x1b[0m';\n      case '.br': return '\\n';\n      default: {\n        if (seq.startsWith('X') && seq.length > 1) {\n          try {\n            const hex = seq.slice(1);\n            const bytes = new Uint8Array(hex.match(/.{1,2}/g)?.map(b => parseInt(b, 16)) ?? []);\n            return new TextDecoder().decode(bytes);\n          } catch {\n            return match;\n          }\n        }\n        // Preserve unknown / locally-defined sequences unchanged\n        return match;\n      }\n    }\n  });\n}\n\n/**\n * Encode a plain string value for safe inclusion in an HL7 v2 field,\n * escaping any characters that have special meaning in the given encoding.\n *\n * Characters are escaped in this order to avoid double-escaping:\n * 1. Escape character itself (`\\E\\`)\n * 2. Field separator     (`\\F\\`)\n * 3. Component separator (`\\S\\`)\n * 4. Repetition separator(`\\R\\`)\n * 5. Sub-component sep   (`\\T\\`)\n *\n * @param value - Plain string to encode\n * @param enc   - Encoding characters from the target message\n */\nexport function encodeEscapes(value: string, enc: EncodingChars): string {\n  const esc = enc.escape;\n  // Escape the escape character first to avoid double-escaping\n  return value\n    .replace(new RegExp(escRx(esc), 'g'), `${esc}E${esc}`)\n    .replace(new RegExp(escRx(enc.field), 'g'), `${esc}F${esc}`)\n    .replace(new RegExp(escRx(enc.component), 'g'), `${esc}S${esc}`)\n    .replace(new RegExp(escRx(enc.repetition), 'g'), `${esc}R${esc}`)\n    .replace(new RegExp(escRx(enc.subComponent), 'g'), `${esc}T${esc}`);\n}\n"]}