@glion/to-hl7v2 0.26.0 → 0.27.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Rethink Health
+Copyright (c) 2023 Rethink Health, SUARL
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.js

@@ -1,103 +1,95 @@
 import { DEFAULT_DELIMITERS } from "@glion/utils";
 //#region ../util-query/dist/index.js
+function sentence(code, path) {
+	switch (code) {
+		case "EMPTY_PATH": return "The path is empty; a path is `[GROUP[N].]...NAME[N][.FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]]`, or `FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]` read from a segment, with positions from 1, such as `PID.5.1` or `5.1`.";
+		case "INVALID_PATH": return `Path \`${path}\` does not follow the path grammar; a path is \`[GROUP[N].]...NAME[N][.FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]]\`, or \`FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]\` read from a segment, with positions from 1, such as \`PID.5.1\` or \`5.1\`.`;
+	}
+}
+/** A path that `@glion/util-query` cannot read. */
+var QueryError = class extends Error {
+	name = "QueryError";
+	code;
+	path;
+	constructor(code, path) {
+		super(sentence(code, path));
+		this.code = code;
+		this.path = path;
+	}
+};
 /**
-* Regular expression for canonical HL7 paths.
-*
-* Format:
-* [GROUP[N]-]...[GROUP[N]-]NAME[N][-FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]]
-*
-* **Design Philosophy**: Groups vs Segments are distinguished by POSITION and
-* USAGE, not name length:
+* Canonical HL7 path grammar, every step separated with `.`:
 *
-* - **Navigation (Groups)**: Names appearing as prefixes (before the final name)
-*   are treated as group navigation: `ORDER-ORC`, `ORDER-TIMING-TQ1`
-* - **Target (Segments)**: The final name in the path is the query target.
-*   Whether it's a segment or group is determined by:
-*
-*   1. Field access (-.digit): Definitively a segment → `ORC-1`, `ORDER-ORC-1`
-*   2. No field access: Query the AST to see what exists → `ORC`, `ORDER`
-*
-* This approach:
-*
-* - Makes no assumptions about name length (works with standard 3-char segments
-*   AND edge cases)
-* - Lets the path structure indicate intent (field access = segment internals)
-* - Allows the AST to be the source of truth for what exists
-*
-* Examples:
-*
-* - `MSH-3` → MSH is segment (has field access)
-* - `ORDER-ORC` → ORDER is navigation, ORC is target (could be segment or nested
-*   group)
-* - `ORDER-ORC-1` → ORDER is navigation, ORC is segment (has field access)
-*/
-const PATH_REGEX = /^((?:[A-Z][A-Z0-9_]*(?:\[\d+\])?-)*)([A-Z][A-Z0-9_]*)(?:\[(\d+)\])?(?:-(\d+)(?:(?:\[(\d+)\])?(?:\.(\d+)(?:\.(\d+))?)?)?)?$/;
-/**
-* Cache for parsed paths to avoid re-parsing the same path multiple times.
-* No eviction — the realistic set of unique paths in an application is
-* small (50-100 entries) and the memory cost is negligible.
-*/
-const parseCache = /* @__PURE__ */ new Map();
-/**
-* Pre-computed PathParts for frequently accessed MSH fields.
+* [GROUP[N].]...NAME[N][.FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]]
+* FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]
 *
-* Multiple plugins and lint rules read MSH-9 (message type) and MSH-12
-* (version) on every message. Skipping regex parsing and cache lookups
-* for these paths eliminates ~100ns per call.
+* Names start with a letter and positions are numbers from 1, so the first
+* numeric step is the field. The final name is the query target. Field
+* access makes it a segment (`ORDER.ORC.1`); without it the AST decides
+* whether it names a segment or a group (`ORDER.ORC`, `ORDER`). A path that
+* starts with the field names no segment (`5.1`).
 */
-const HOT_PATHS = {
-	"MSH-10": {
-		field: 10,
-		segment: { name: "MSH" }
-	},
-	"MSH-12": {
-		field: 12,
-		segment: { name: "MSH" }
-	},
-	"MSH-3": {
+const PATH_REGEX = /^(?:([A-Z][A-Z0-9_]*(?:\[[1-9]\d*\])?(?:\.[A-Z][A-Z0-9_]*(?:\[[1-9]\d*\])?)*)(?:\.(?=[1-9])|$))?(?:([1-9]\d*)(?:\[([1-9]\d*)\])?(?:\.([1-9]\d*)(?:\.([1-9]\d*))?)?)?$/;
+const NAVIGATION_STEP_REGEX = /([A-Z][A-Z0-9_]*)(?:\[(\d+)\])?/g;
+/** Parts of the MSH paths that plugins and lint rules read on every message. */
+const PRECOMPUTED_PATHS = new Map([
+	["MSH.3", () => ({
 		field: 3,
 		segment: { name: "MSH" }
-	},
-	"MSH-4": {
+	})],
+	["MSH.4", () => ({
 		field: 4,
 		segment: { name: "MSH" }
-	},
-	"MSH-5": {
+	})],
+	["MSH.5", () => ({
 		field: 5,
 		segment: { name: "MSH" }
-	},
-	"MSH-6": {
+	})],
+	["MSH.6", () => ({
 		field: 6,
 		segment: { name: "MSH" }
-	},
-	"MSH-9": {
+	})],
+	["MSH.9", () => ({
 		field: 9,
 		segment: { name: "MSH" }
-	},
-	"MSH-9.1": {
+	})],
+	["MSH.9.1", () => ({
 		component: 1,
 		field: 9,
 		segment: { name: "MSH" }
-	},
-	"MSH-9.2": {
+	})],
+	["MSH.9.2", () => ({
 		component: 2,
 		field: 9,
 		segment: { name: "MSH" }
-	},
-	"MSH-9.3": {
+	})],
+	["MSH.9.3", () => ({
 		component: 3,
 		field: 9,
 		segment: { name: "MSH" }
-	}
-};
+	})],
+	["MSH.10", () => ({
+		field: 10,
+		segment: { name: "MSH" }
+	})],
+	["MSH.12", () => ({
+		field: 12,
+		segment: { name: "MSH" }
+	})],
+	["MSH.12.1", () => ({
+		component: 1,
+		field: 12,
+		segment: { name: "MSH" }
+	})]
+]);
 /**
 * Parse an HL7 path string into structured parts.
-* Results are memoized for performance. Common MSH paths use
-* pre-computed constants to skip parsing entirely.
+*
+* Returns a new object on every call.
 *
 * @example
 *   ```typescript
-*   parse("PID-5[1].2.1");
+*   parse("PID.5[1].2.1");
 *   // {
 *   //   segment: { name: 'PID' },
 *   //   field: 5,
@@ -111,231 +103,168 @@ const HOT_PATHS = {
 * @returns Structured path components
 */
 function parse(path) {
-	const hot = HOT_PATHS[path];
-	if (hot) return hot;
-	const cached = parseCache.get(path);
-	if (cached) return cached;
-	const result = parseImpl(path);
-	parseCache.set(path, result);
-	return result;
-}
-/**
-* Internal implementation of path parsing.
-*/
-function parseImpl(path) {
-	if (!path || typeof path !== "string") throw new Error(`Path must be a non-empty string, got: ${path}`);
-	if (path.trim() !== path) throw new Error(`Path cannot contain leading/trailing spaces: "${path}"`);
+	const precomputed = PRECOMPUTED_PATHS.get(path);
+	if (precomputed) return precomputed();
+	if (path === "") throw new QueryError("EMPTY_PATH", path);
 	const match = PATH_REGEX.exec(path);
-	if (!match) throw new Error(`Invalid HL7 path format: "${path}". Expected [GROUP[N]-]...NAME[N][-FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]].`);
-	const [, groupsRaw, segmentName, segmentRep, fieldStr, repetitionStr, componentStr, subcomponentStr] = match;
-	if (!segmentName) throw new Error(`Path must include a segment identifier: "${path}"`);
-	const parts = { segment: { name: segmentName } };
-	if (segmentRep) {
-		const repetition = Number.parseInt(segmentRep, 10);
-		if (repetition < 1) throw new Error(`Segment repetition must be ≥1, got: ${segmentRep} in "${path}"`);
-		parts.segment.repetition = repetition;
-	}
-	if (groupsRaw) {
-		const groups = [];
-		for (const groupMatch of groupsRaw.matchAll(/([A-Z][A-Z0-9_]*)(?:\[(\d+)\])?-/g)) {
-			const name = groupMatch[1];
-			if (!name) continue;
-			const repStr = groupMatch[2];
-			const group = { name };
-			if (repStr) {
-				const repetition = Number.parseInt(repStr, 10);
-				if (repetition < 1) throw new Error(`Group repetition must be ≥1, got: ${repStr} in "${path}"`);
-				group.repetition = repetition;
-			}
-			groups.push(group);
-		}
-		if (groups.length > 0) parts.groups = groups;
-	}
-	if (fieldStr) {
-		const field = Number.parseInt(fieldStr, 10);
-		if (field < 1) throw new Error(`Field number must be ≥1, got: ${fieldStr}`);
-		parts.field = field;
-	}
-	if (repetitionStr) {
-		const repetition = Number.parseInt(repetitionStr, 10);
-		if (repetition < 1) throw new Error(`Repetition number must be ≥1, got: ${repetitionStr}`);
-		parts.repetition = repetition;
-	}
-	if (componentStr) {
-		const component = Number.parseInt(componentStr, 10);
-		if (component < 1) throw new Error(`Component number must be ≥1, got: ${componentStr}`);
-		parts.component = component;
-	}
-	if (subcomponentStr) {
-		const subcomponent = Number.parseInt(subcomponentStr, 10);
-		if (subcomponent < 1) throw new Error(`Subcomponent number must be ≥1, got: ${subcomponentStr}`);
-		parts.subcomponent = subcomponent;
-	}
+	if (!match) throw new QueryError("INVALID_PATH", path);
+	const [, navigation = "", field, repetition, component, subcomponent] = match;
+	const steps = [];
+	for (const [, name, position] of navigation.matchAll(NAVIGATION_STEP_REGEX)) steps.push(position === void 0 ? { name } : {
+		name,
+		repetition: Number(position)
+	});
+	const parts = {};
+	const segment = steps.pop();
+	if (segment !== void 0) parts.segment = segment;
+	if (steps.length > 0) parts.groups = steps;
+	if (field !== void 0) parts.field = Number(field);
+	if (repetition !== void 0) parts.repetition = Number(repetition);
+	if (component !== void 0) parts.component = Number(component);
+	if (subcomponent !== void 0) parts.subcomponent = Number(subcomponent);
 	return parts;
 }
-function locateSegmentOrGroup(root, parts) {
-	const ancestors = [root];
-	const scope = followGroups(root, parts.groups ?? [], ancestors);
-	if (!scope) return null;
-	const targetName = parts.segment.name;
-	const targetRepetition = parts.segment.repetition;
-	const matchedSegments = collectSegments(scope, targetName, ancestors);
-	if (matchedSegments.length > 0) {
-		const match = matchedSegments[(targetRepetition ?? 1) - 1];
-		if (match) return [match.segment, match.ancestors];
-	}
-	const matchedGroups = collectGroups(scope, targetName, ancestors);
-	if (matchedGroups.length > 0) {
-		const match = matchedGroups[(targetRepetition ?? 1) - 1];
-		if (match) return [match.group, match.ancestors];
+/** The name a path gives a node: a segment's name, or a group's ID. */
+const keyOf = (node) => {
+	switch (node.type) {
+		case "root":
+		case "field":
+		case "field-repetition":
+		case "component":
+		case "subcomponent": return;
+		case "segment": return node.name;
+		case "group": return node.id;
 	}
-	return null;
-}
-function locateSegment(root, parts) {
-	const ancestors = [root];
-	const scope = followGroups(root, parts.groups ?? [], ancestors);
-	if (!scope) return null;
-	const matchedSegments = collectSegments(scope, parts.segment.name, ancestors);
-	if (matchedSegments.length === 0) return null;
-	const match = matchedSegments[(parts.segment.repetition ?? 1) - 1];
-	if (!match) return null;
-	return [match.segment, match.ancestors];
-}
-function followGroups(root, groups, ancestorChain) {
-	let children = filterSegmentsAndGroups(root.children);
-	for (const locator of groups) {
-		const matchedGroups = children.filter((node) => node.type === "group" && node.id === locator.name);
-		if (matchedGroups.length === 0) return null;
-		const selected = matchedGroups[(locator.repetition ?? 1) - 1];
-		if (!selected) return null;
-		ancestorChain.push(selected);
-		children = filterSegmentsAndGroups(selected.children);
+};
+/**
+* The `position`th of `children` (1-based) when given; otherwise every one
+* when `every` is set, or the first.
+*/
+function pick(children, position, every) {
+	if (position !== void 0) {
+		const child = children[position - 1];
+		return child === void 0 ? [] : [child];
 	}
-	return children;
+	return every ? children : children.slice(0, 1);
 }
-function collectSegments(nodes, targetSegmentName, ancestors) {
+/**
+* The children of `parent` a path step names `name`, segments and groups
+* together: the `position`th (1-based) when given; otherwise every one when
+* `every` is set, or the first.
+*/
+function stepChildren(parent, name, position, every) {
 	const result = [];
-	for (const node of nodes) {
-		if (node.type === "segment") {
-			if (getSegmentName(node) === targetSegmentName) result.push({
-				ancestors: [...ancestors],
-				segment: node
-			});
-		}
-		if (node.type === "group") {
-			const nextAncestors = [...ancestors, node];
-			result.push(...collectSegments(filterSegmentsAndGroups(node.children), targetSegmentName, nextAncestors));
+	const target = position ?? 1;
+	let count = 0;
+	for (const child of parent.children) {
+		if (keyOf(child) !== name) continue;
+		if (every && position === void 0) {
+			result.push(child);
+			continue;
 		}
+		count += 1;
+		if (count === target) return [child];
 	}
 	return result;
 }
-function collectGroups(nodes, targetGroupId, ancestors) {
-	const result = [];
-	for (const node of nodes) {
-		if (node.type === "group" && node.id === targetGroupId) result.push({
-			ancestors: [...ancestors],
-			group: node
-		});
-		if (node.type === "group") {
-			const nextAncestors = [...ancestors, node];
-			result.push(...collectGroups(filterSegmentsAndGroups(node.children), targetGroupId, nextAncestors));
+/** The children of each scope that `step` names, with their ancestors. */
+function advance(scopes, step, every) {
+	const next = [];
+	for (const scope of scopes) for (const node of stepChildren(scope.node, step.name, step.repetition, every)) next.push({
+		ancestors: [...scope.ancestors, scope.node],
+		node
+	});
+	return next;
+}
+/**
+* The field, repetitions, components, or subcomponents `parts` addresses in
+* `segment`.
+*/
+function resolveField(segment, ancestors, fieldNumber, parts, every) {
+	const field = segment.children[fieldNumber - 1];
+	if (!field) return [];
+	const fieldAncestors = [...ancestors, segment];
+	if (parts.repetition === void 0 && parts.component === void 0) return [{
+		ancestors: fieldAncestors,
+		node: field
+	}];
+	const matches = [];
+	for (const repetition of pick(field.children ?? [], parts.repetition, every)) {
+		const repetitionAncestors = [...fieldAncestors, field];
+		if (parts.component === void 0) {
+			matches.push({
+				ancestors: repetitionAncestors,
+				node: repetition
+			});
+			continue;
+		}
+		const component = repetition.children?.[parts.component - 1];
+		if (!component) continue;
+		const componentAncestors = [...repetitionAncestors, repetition];
+		if (parts.subcomponent === void 0) {
+			matches.push({
+				ancestors: componentAncestors,
+				node: component
+			});
+			continue;
 		}
+		const subcomponent = component.children?.[parts.subcomponent - 1];
+		if (subcomponent) matches.push({
+			ancestors: [...componentAncestors, component],
+			node: subcomponent
+		});
 	}
-	return result;
-}
-function locateField(segment, fieldNum, parentAncestors) {
-	const field = getFields(segment)[fieldNum - 1];
-	if (!field) return null;
-	return [field, [...parentAncestors, segment]];
-}
-function locateRepetition(field, repetition, parentAncestors) {
-	if (repetition < 1) return null;
-	const node = field.children?.[repetition - 1];
-	if (!node) return null;
-	return [node, [...parentAncestors, field]];
-}
-function locateComponent(repetition, componentNum, parentAncestors) {
-	if (componentNum < 1) return null;
-	const component = repetition.children?.[componentNum - 1];
-	if (!component) return null;
-	return [component, [...parentAncestors, repetition]];
-}
-function locateSubcomponent(component, subcomponentNum, parentAncestors) {
-	if (subcomponentNum < 1) return null;
-	const node = component.children?.[subcomponentNum - 1];
-	if (!node) return null;
-	return [node, [...parentAncestors, component]];
-}
-function getSegmentName(segment) {
-	return segment.name;
-}
-function getFields(segment) {
-	return segment.children;
+	return matches;
 }
-function filterSegmentsAndGroups(nodes) {
-	return nodes.filter((node) => node.type === "segment" || node.type === "group");
+/**
+* The nodes `parts` addresses under `start`, in document order, each with its
+* own ancestors array, which begins at `start`.
+*
+* Every step names a direct child of the node before it; the first step
+* names a direct child of `start`. A step's `[n]` counts the children with
+* that name, segments and groups together. A step without `[n]` matches the
+* first such child, or every one when `every` is set; so does a field
+* without a repetition when the path names a component.
+*/
+function resolve(start, parts, every) {
+	let scopes = [{
+		ancestors: [],
+		node: start
+	}];
+	for (const group of parts.groups ?? []) scopes = advance(scopes, group, every);
+	if (parts.segment !== void 0) scopes = advance(scopes, parts.segment, every);
+	if (parts.field === void 0) return scopes;
+	const matches = [];
+	for (const { node, ancestors } of scopes) {
+		if (node.type !== "segment") continue;
+		for (const match of resolveField(node, ancestors, parts.field, parts, every)) matches.push(match);
+	}
+	return matches;
 }
 /**
-* Select the first node at the given path and return it with its ancestor
-* chain.
+* The node `path` addresses under `node`, with its ancestors from `node`, or
+* `null`.
 *
-* This function finds the first matching node for the given path. For paths
-* that can match multiple nodes (e.g., "PID" when multiple PID segments exist),
-* use {@link selectAll} to retrieve all matches.
+* Every step of `path` names a direct child of the node before it; the first
+* step names a direct child of `node`, so a path read from a segment starts
+* with the field. A step without `[n]` names the first such child, so
+* `select` returns `null` when that child does not lead to a match, even if a
+* later one does; `selectAll` returns every match.
 *
 * @example
 *   ```typescript
-*   const result = select(root, "PID-5");
-*   if (result) {
-*     result.node; // Type: Field
-*     result.ancestors; // [Root, Segment]
-*   }
+*   select(root, "PID.5"); // { node: Field, ancestors: [Root, Segment] }
+*   select(root, "PATIENT_RESULT.PATIENT.PID.5");
+*   select(segment, "5.1"); // { node: Component, ancestors: [Segment, Field, FieldRepetition] }
 *   ```;
 *
-* @param root - The root node to search from
-* @param path - The HL7 path string
-* @returns Object containing the node and its ancestors, or null if not found
+* @param node - The message, group, or segment to read from.
+* @param path - The path to the node.
+* @returns The node and its ancestors, or `null` when nothing matches.
 */
-function select(root, path) {
-	const parts = parse(path);
-	if (parts.field === void 0) {
-		const result = locateSegmentOrGroup(root, parts);
-		if (!result) return null;
-		return {
-			ancestors: result[1],
-			node: result[0]
-		};
-	}
-	const segmentResult = locateSegment(root, parts);
-	if (!segmentResult) return null;
-	const [segment, segmentAncestors] = segmentResult;
-	const fieldResult = locateField(segment, parts.field, segmentAncestors);
-	if (!fieldResult) return null;
-	const [field, fieldAncestors] = fieldResult;
-	if (parts.component === void 0 && parts.subcomponent === void 0 && parts.repetition === void 0) return {
-		ancestors: fieldAncestors,
-		node: field
-	};
-	const repetitionResult = locateRepetition(field, parts.repetition ?? 1, fieldAncestors);
-	if (!repetitionResult) return null;
-	const [repetitionNode, repetitionAncestors] = repetitionResult;
-	if (parts.component === void 0) return {
-		ancestors: repetitionAncestors,
-		node: repetitionNode
-	};
-	const componentResult = locateComponent(repetitionNode, parts.component, repetitionAncestors);
-	if (!componentResult) return null;
-	const [componentNode, componentAncestors] = componentResult;
-	if (parts.subcomponent === void 0) return {
-		ancestors: componentAncestors,
-		node: componentNode
-	};
-	const subResult = locateSubcomponent(componentNode, parts.subcomponent, componentAncestors);
-	if (!subResult) return null;
-	return {
-		ancestors: subResult[1],
-		node: subResult[0]
-	};
+function select(node, path) {
+	const [match] = resolve(node, parse(path), false);
+	return match ?? null;
 }
 /**
 * Get the string value at the path, drilling down through single-child nodes
@@ -344,7 +273,7 @@ function select(root, path) {
 * This is a convenience function that automatically traverses through container
 * nodes (Field → FieldRepetition → Component → Subcomponent) to extract the
 * primary string value. When a container has multiple children, the first child
-* is selected (e.g., `value(tree, "MSH-12")` returns the first component of a
+* is selected (e.g., `value(tree, "MSH.12")` returns the first component of a
 * composite VID field).
 *
 * Nodes with no children return `value: null` to differentiate between empty
@@ -352,42 +281,51 @@ function select(root, path) {
 *
 * @example
 *   ```typescript
-*   const result = value(root, "PID-5.1");
+*   const result = value(root, "PID.5.1");
 *   if (result) {
 *     console.log(result.value); // string | null
 *     console.log(result.node.type); // 'subcomponent'
 *     console.log(result.ancestors); // [Root, Segment, Field, ...]
 *   }
+*
+*   value(segment, "5.1"); // the same value, read from the PID segment
 *   ```;
 *
-* @param root - The root node to search from
+* @param node - The message, group, or segment to read from
 * @param path - The HL7 path string
-* @returns Object containing the value, node, and ancestors, or null if not
-*   found
+* @returns Object containing the value, node, and ancestors from `node`, or
+*   null if not found
 */
-function value(root, path) {
-	const selectResult = select(root, path);
-	if (!selectResult) return null;
-	let { node } = selectResult;
-	let { ancestors } = selectResult;
-	while (node.type !== "subcomponent") {
-		if (node.type === "segment" || node.type === "group" || node.type === "root") return null;
-		if (!("children" in node && node.children)) return null;
-		if (node.children.length === 0) return {
-			ancestors: [...ancestors],
+function value(node, path) {
+	const selected = select(node, path);
+	return selected ? drill(selected.node, selected.ancestors) : null;
+}
+/**
+* The first subcomponent under `node`, with its value, or `node` with value
+* `null` when a field, repetition, or component on the way has no children.
+* `null` for a root, group, or segment.
+*/
+function drill(node, ancestors) {
+	switch (node.type) {
+		case "root":
+		case "group":
+		case "segment": return null;
+		case "subcomponent": return {
+			ancestors,
 			node,
-			value: null
+			value: node.value
 		};
-		const next = node.children[0];
-		if (!next) return null;
-		ancestors = [...ancestors, node];
-		node = next;
+		case "field":
+		case "field-repetition":
+		case "component": {
+			const first = node.children?.[0];
+			return first ? drill(first, [...ancestors, node]) : {
+				ancestors,
+				node,
+				value: null
+			};
+		}
 	}
-	return {
-		ancestors,
-		node,
-		value: node.value
-	};
 }
 /** Keys of MSH-2 encoding characters in positional order. */
 const MSH2_KEYS = [
@@ -410,9 +348,9 @@ const MSH2_KEYS = [
 */
 function delimiters(root) {
 	const result = { ...DEFAULT_DELIMITERS };
-	const msh1 = value(root, "MSH-1")?.value;
+	const msh1 = value(root, "MSH.1")?.value;
 	if (msh1 && msh1.length === 1) result.field = msh1;
-	const msh2 = value(root, "MSH-2")?.value;
+	const msh2 = value(root, "MSH.2")?.value;
 	if (msh2) {
 		const chars = [...msh2];
 		for (const [i, key] of MSH2_KEYS.entries()) {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["queryDelimiters","delimiters","unsupported"],"sources":["../../util-query/dist/index.js","../src/index.ts"],"sourcesContent":["import { DEFAULT_DELIMITERS } from \"@glion/utils\";\n//#region src/parse.ts\n/**\n* Regular expression for canonical HL7 paths.\n*\n* Format:\n* [GROUP[N]-]...[GROUP[N]-]NAME[N][-FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]]\n*\n* **Design Philosophy**: Groups vs Segments are distinguished by POSITION and\n* USAGE, not name length:\n*\n* - **Navigation (Groups)**: Names appearing as prefixes (before the final name)\n*   are treated as group navigation: `ORDER-ORC`, `ORDER-TIMING-TQ1`\n* - **Target (Segments)**: The final name in the path is the query target.\n*   Whether it's a segment or group is determined by:\n*\n*   1. Field access (-.digit): Definitively a segment → `ORC-1`, `ORDER-ORC-1`\n*   2. No field access: Query the AST to see what exists → `ORC`, `ORDER`\n*\n* This approach:\n*\n* - Makes no assumptions about name length (works with standard 3-char segments\n*   AND edge cases)\n* - Lets the path structure indicate intent (field access = segment internals)\n* - Allows the AST to be the source of truth for what exists\n*\n* Examples:\n*\n* - `MSH-3` → MSH is segment (has field access)\n* - `ORDER-ORC` → ORDER is navigation, ORC is target (could be segment or nested\n*   group)\n* - `ORDER-ORC-1` → ORDER is navigation, ORC is segment (has field access)\n*/\nconst PATH_REGEX = /^((?:[A-Z][A-Z0-9_]*(?:\\[\\d+\\])?-)*)([A-Z][A-Z0-9_]*)(?:\\[(\\d+)\\])?(?:-(\\d+)(?:(?:\\[(\\d+)\\])?(?:\\.(\\d+)(?:\\.(\\d+))?)?)?)?$/;\n/**\n* Cache for parsed paths to avoid re-parsing the same path multiple times.\n* No eviction — the realistic set of unique paths in an application is\n* small (50-100 entries) and the memory cost is negligible.\n*/\nconst parseCache = /* @__PURE__ */ new Map();\n/**\n* Pre-computed PathParts for frequently accessed MSH fields.\n*\n* Multiple plugins and lint rules read MSH-9 (message type) and MSH-12\n* (version) on every message. Skipping regex parsing and cache lookups\n* for these paths eliminates ~100ns per call.\n*/\nconst HOT_PATHS = {\n\t\"MSH-10\": {\n\t\tfield: 10,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-12\": {\n\t\tfield: 12,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-3\": {\n\t\tfield: 3,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-4\": {\n\t\tfield: 4,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-5\": {\n\t\tfield: 5,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-6\": {\n\t\tfield: 6,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-9\": {\n\t\tfield: 9,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-9.1\": {\n\t\tcomponent: 1,\n\t\tfield: 9,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-9.2\": {\n\t\tcomponent: 2,\n\t\tfield: 9,\n\t\tsegment: { name: \"MSH\" }\n\t},\n\t\"MSH-9.3\": {\n\t\tcomponent: 3,\n\t\tfield: 9,\n\t\tsegment: { name: \"MSH\" }\n\t}\n};\n/**\n* Parse an HL7 path string into structured parts.\n* Results are memoized for performance. Common MSH paths use\n* pre-computed constants to skip parsing entirely.\n*\n* @example\n*   ```typescript\n*   parse(\"PID-5[1].2.1\");\n*   // {\n*   //   segment: { name: 'PID' },\n*   //   field: 5,\n*   //   repetition: 1,\n*   //   component: 2,\n*   //   subcomponent: 1\n*   // }\n*   ```;\n*\n* @param path - HL7 path string to parse\n* @returns Structured path components\n*/\nfunction parse(path) {\n\tconst hot = HOT_PATHS[path];\n\tif (hot) return hot;\n\tconst cached = parseCache.get(path);\n\tif (cached) return cached;\n\tconst result = parseImpl(path);\n\tparseCache.set(path, result);\n\treturn result;\n}\n/**\n* Internal implementation of path parsing.\n*/\nfunction parseImpl(path) {\n\tif (!path || typeof path !== \"string\") throw new Error(`Path must be a non-empty string, got: ${path}`);\n\tif (path.trim() !== path) throw new Error(`Path cannot contain leading/trailing spaces: \"${path}\"`);\n\tconst match = PATH_REGEX.exec(path);\n\tif (!match) throw new Error(`Invalid HL7 path format: \"${path}\". Expected [GROUP[N]-]...NAME[N][-FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]].`);\n\tconst [, groupsRaw, segmentName, segmentRep, fieldStr, repetitionStr, componentStr, subcomponentStr] = match;\n\tif (!segmentName) throw new Error(`Path must include a segment identifier: \"${path}\"`);\n\tconst parts = { segment: { name: segmentName } };\n\tif (segmentRep) {\n\t\tconst repetition = Number.parseInt(segmentRep, 10);\n\t\tif (repetition < 1) throw new Error(`Segment repetition must be ≥1, got: ${segmentRep} in \"${path}\"`);\n\t\tparts.segment.repetition = repetition;\n\t}\n\tif (groupsRaw) {\n\t\tconst groups = [];\n\t\tfor (const groupMatch of groupsRaw.matchAll(/([A-Z][A-Z0-9_]*)(?:\\[(\\d+)\\])?-/g)) {\n\t\t\tconst name = groupMatch[1];\n\t\t\tif (!name) continue;\n\t\t\tconst repStr = groupMatch[2];\n\t\t\tconst group = { name };\n\t\t\tif (repStr) {\n\t\t\t\tconst repetition = Number.parseInt(repStr, 10);\n\t\t\t\tif (repetition < 1) throw new Error(`Group repetition must be ≥1, got: ${repStr} in \"${path}\"`);\n\t\t\t\tgroup.repetition = repetition;\n\t\t\t}\n\t\t\tgroups.push(group);\n\t\t}\n\t\tif (groups.length > 0) parts.groups = groups;\n\t}\n\tif (fieldStr) {\n\t\tconst field = Number.parseInt(fieldStr, 10);\n\t\tif (field < 1) throw new Error(`Field number must be ≥1, got: ${fieldStr}`);\n\t\tparts.field = field;\n\t}\n\tif (repetitionStr) {\n\t\tconst repetition = Number.parseInt(repetitionStr, 10);\n\t\tif (repetition < 1) throw new Error(`Repetition number must be ≥1, got: ${repetitionStr}`);\n\t\tparts.repetition = repetition;\n\t}\n\tif (componentStr) {\n\t\tconst component = Number.parseInt(componentStr, 10);\n\t\tif (component < 1) throw new Error(`Component number must be ≥1, got: ${componentStr}`);\n\t\tparts.component = component;\n\t}\n\tif (subcomponentStr) {\n\t\tconst subcomponent = Number.parseInt(subcomponentStr, 10);\n\t\tif (subcomponent < 1) throw new Error(`Subcomponent number must be ≥1, got: ${subcomponentStr}`);\n\t\tparts.subcomponent = subcomponent;\n\t}\n\treturn parts;\n}\n//#endregion\n//#region src/utils.ts\nfunction locateSegmentOrGroup(root, parts) {\n\tconst ancestors = [root];\n\tconst scope = followGroups(root, parts.groups ?? [], ancestors);\n\tif (!scope) return null;\n\tconst targetName = parts.segment.name;\n\tconst targetRepetition = parts.segment.repetition;\n\tconst matchedSegments = collectSegments(scope, targetName, ancestors);\n\tif (matchedSegments.length > 0) {\n\t\tconst match = matchedSegments[(targetRepetition ?? 1) - 1];\n\t\tif (match) return [match.segment, match.ancestors];\n\t}\n\tconst matchedGroups = collectGroups(scope, targetName, ancestors);\n\tif (matchedGroups.length > 0) {\n\t\tconst match = matchedGroups[(targetRepetition ?? 1) - 1];\n\t\tif (match) return [match.group, match.ancestors];\n\t}\n\treturn null;\n}\nfunction locateSegment(root, parts) {\n\tconst ancestors = [root];\n\tconst scope = followGroups(root, parts.groups ?? [], ancestors);\n\tif (!scope) return null;\n\tconst matchedSegments = collectSegments(scope, parts.segment.name, ancestors);\n\tif (matchedSegments.length === 0) return null;\n\tconst match = matchedSegments[(parts.segment.repetition ?? 1) - 1];\n\tif (!match) return null;\n\treturn [match.segment, match.ancestors];\n}\nfunction followGroups(root, groups, ancestorChain) {\n\tlet children = filterSegmentsAndGroups(root.children);\n\tfor (const locator of groups) {\n\t\tconst matchedGroups = children.filter((node) => node.type === \"group\" && node.id === locator.name);\n\t\tif (matchedGroups.length === 0) return null;\n\t\tconst selected = matchedGroups[(locator.repetition ?? 1) - 1];\n\t\tif (!selected) return null;\n\t\tancestorChain.push(selected);\n\t\tchildren = filterSegmentsAndGroups(selected.children);\n\t}\n\treturn children;\n}\n/**\n* Collect all possible scopes when groups can match multiple instances.\n* Used by selectAll to find nodes across all matching groups.\n*/\nfunction collectAllScopes(root, groups) {\n\tif (groups.length === 0) return [{\n\t\tancestors: [root],\n\t\tscope: filterSegmentsAndGroups(root.children)\n\t}];\n\tconst results = [];\n\tconst firstLocator = groups[0];\n\tconst remainingGroups = groups.slice(1);\n\tif (!firstLocator) return [{\n\t\tancestors: [root],\n\t\tscope: filterSegmentsAndGroups(root.children)\n\t}];\n\tconst matchingGroups = filterSegmentsAndGroups(root.children).filter((node) => node.type === \"group\" && node.id === firstLocator.name);\n\tif (firstLocator.repetition !== void 0) {\n\t\tconst selected = matchingGroups[firstLocator.repetition - 1];\n\t\tif (!selected) return [];\n\t\tconst ancestors = [root, selected];\n\t\treturn collectAllScopesRecursive(selected.children, remainingGroups, ancestors);\n\t}\n\tfor (const group of matchingGroups) {\n\t\tconst ancestors = [root, group];\n\t\tconst subScopes = collectAllScopesRecursive(group.children, remainingGroups, ancestors);\n\t\tresults.push(...subScopes);\n\t}\n\treturn results;\n}\nfunction collectAllScopesRecursive(children, groups, ancestors) {\n\tif (groups.length === 0) return [{\n\t\tancestors,\n\t\tscope: filterSegmentsAndGroups(children)\n\t}];\n\tconst results = [];\n\tconst firstLocator = groups[0];\n\tconst remainingGroups = groups.slice(1);\n\tif (!firstLocator) return [{\n\t\tancestors,\n\t\tscope: filterSegmentsAndGroups(children)\n\t}];\n\tconst matchingGroups = filterSegmentsAndGroups(children).filter((node) => node.type === \"group\" && node.id === firstLocator.name);\n\tif (firstLocator.repetition !== void 0) {\n\t\tconst selected = matchingGroups[firstLocator.repetition - 1];\n\t\tif (!selected) return [];\n\t\tconst newAncestors = [...ancestors, selected];\n\t\treturn collectAllScopesRecursive(selected.children, remainingGroups, newAncestors);\n\t}\n\tfor (const group of matchingGroups) {\n\t\tconst newAncestors = [...ancestors, group];\n\t\tconst subScopes = collectAllScopesRecursive(group.children, remainingGroups, newAncestors);\n\t\tresults.push(...subScopes);\n\t}\n\treturn results;\n}\nfunction collectSegments(nodes, targetSegmentName, ancestors) {\n\tconst result = [];\n\tfor (const node of nodes) {\n\t\tif (node.type === \"segment\") {\n\t\t\tif (getSegmentName(node) === targetSegmentName) result.push({\n\t\t\t\tancestors: [...ancestors],\n\t\t\t\tsegment: node\n\t\t\t});\n\t\t}\n\t\tif (node.type === \"group\") {\n\t\t\tconst nextAncestors = [...ancestors, node];\n\t\t\tresult.push(...collectSegments(filterSegmentsAndGroups(node.children), targetSegmentName, nextAncestors));\n\t\t}\n\t}\n\treturn result;\n}\nfunction collectGroups(nodes, targetGroupId, ancestors) {\n\tconst result = [];\n\tfor (const node of nodes) {\n\t\tif (node.type === \"group\" && node.id === targetGroupId) result.push({\n\t\t\tancestors: [...ancestors],\n\t\t\tgroup: node\n\t\t});\n\t\tif (node.type === \"group\") {\n\t\t\tconst nextAncestors = [...ancestors, node];\n\t\t\tresult.push(...collectGroups(filterSegmentsAndGroups(node.children), targetGroupId, nextAncestors));\n\t\t}\n\t}\n\treturn result;\n}\nfunction locateField(segment, fieldNum, parentAncestors) {\n\tconst field = getFields(segment)[fieldNum - 1];\n\tif (!field) return null;\n\treturn [field, [...parentAncestors, segment]];\n}\nfunction locateRepetition(field, repetition, parentAncestors) {\n\tif (repetition < 1) return null;\n\tconst node = field.children?.[repetition - 1];\n\tif (!node) return null;\n\treturn [node, [...parentAncestors, field]];\n}\nfunction locateComponent(repetition, componentNum, parentAncestors) {\n\tif (componentNum < 1) return null;\n\tconst component = repetition.children?.[componentNum - 1];\n\tif (!component) return null;\n\treturn [component, [...parentAncestors, repetition]];\n}\nfunction locateSubcomponent(component, subcomponentNum, parentAncestors) {\n\tif (subcomponentNum < 1) return null;\n\tconst node = component.children?.[subcomponentNum - 1];\n\tif (!node) return null;\n\treturn [node, [...parentAncestors, component]];\n}\nfunction getSegmentName(segment) {\n\treturn segment.name;\n}\nfunction getFields(segment) {\n\treturn segment.children;\n}\nfunction filterSegmentsAndGroups(nodes) {\n\treturn nodes.filter((node) => node.type === \"segment\" || node.type === \"group\");\n}\n//#endregion\n//#region src/select.ts\n/**\n* Select the first node at the given path and return it with its ancestor\n* chain.\n*\n* This function finds the first matching node for the given path. For paths\n* that can match multiple nodes (e.g., \"PID\" when multiple PID segments exist),\n* use {@link selectAll} to retrieve all matches.\n*\n* @example\n*   ```typescript\n*   const result = select(root, \"PID-5\");\n*   if (result) {\n*     result.node; // Type: Field\n*     result.ancestors; // [Root, Segment]\n*   }\n*   ```;\n*\n* @param root - The root node to search from\n* @param path - The HL7 path string\n* @returns Object containing the node and its ancestors, or null if not found\n*/\nfunction select(root, path) {\n\tconst parts = parse(path);\n\tif (parts.field === void 0) {\n\t\tconst result = locateSegmentOrGroup(root, parts);\n\t\tif (!result) return null;\n\t\treturn {\n\t\t\tancestors: result[1],\n\t\t\tnode: result[0]\n\t\t};\n\t}\n\tconst segmentResult = locateSegment(root, parts);\n\tif (!segmentResult) return null;\n\tconst [segment, segmentAncestors] = segmentResult;\n\tconst fieldResult = locateField(segment, parts.field, segmentAncestors);\n\tif (!fieldResult) return null;\n\tconst [field, fieldAncestors] = fieldResult;\n\tif (parts.component === void 0 && parts.subcomponent === void 0 && parts.repetition === void 0) return {\n\t\tancestors: fieldAncestors,\n\t\tnode: field\n\t};\n\tconst repetitionResult = locateRepetition(field, parts.repetition ?? 1, fieldAncestors);\n\tif (!repetitionResult) return null;\n\tconst [repetitionNode, repetitionAncestors] = repetitionResult;\n\tif (parts.component === void 0) return {\n\t\tancestors: repetitionAncestors,\n\t\tnode: repetitionNode\n\t};\n\tconst componentResult = locateComponent(repetitionNode, parts.component, repetitionAncestors);\n\tif (!componentResult) return null;\n\tconst [componentNode, componentAncestors] = componentResult;\n\tif (parts.subcomponent === void 0) return {\n\t\tancestors: componentAncestors,\n\t\tnode: componentNode\n\t};\n\tconst subResult = locateSubcomponent(componentNode, parts.subcomponent, componentAncestors);\n\tif (!subResult) return null;\n\treturn {\n\t\tancestors: subResult[1],\n\t\tnode: subResult[0]\n\t};\n}\n/**\n* Select all nodes that match the given path.\n*\n* This function returns all matching nodes for paths that can match multiple\n* elements. For example, \"PID\" will return all PID segments in the message, and\n* \"OBX-5\" will return all observation values.\n*\n* @example\n*   ```typescript\n*   // Get all OBX segments\n*   const results = selectAll(root, \"OBX\");\n*   for (const { node } of results) {\n*     console.log(node.type); // 'segment'\n*   }\n*\n*   // Get all patient name fields\n*   const names = selectAll(root, \"PID-5\");\n*   ```;\n*\n* @param root - The root node to search from\n* @param path - The HL7 path string (must not include repetition index)\n* @returns Array of objects containing nodes and their ancestor chains\n*/\nfunction selectAll(root, path) {\n\tconst parts = parse(path);\n\tif (parts.segment.repetition !== void 0 || parts.repetition !== void 0) {\n\t\tconst result = select(root, path);\n\t\treturn result ? [result] : [];\n\t}\n\tconst results = [];\n\tconst scopes = collectAllScopes(root, parts.groups ?? []);\n\tconst segments = [];\n\tconst includeGroups = parts.field === void 0;\n\tconst groups = [];\n\tfor (const { scope, ancestors } of scopes) {\n\t\tconst matchingSegments = collectSegments(scope, parts.segment.name, ancestors);\n\t\tsegments.push(...matchingSegments);\n\t\tif (includeGroups) {\n\t\t\tconst matchingGroups = collectGroups(scope, parts.segment.name, ancestors);\n\t\t\tfor (const { group, ancestors: groupAncestors } of matchingGroups) groups.push({\n\t\t\t\tancestors: groupAncestors,\n\t\t\t\tgroup\n\t\t\t});\n\t\t}\n\t}\n\tif (parts.field === void 0) {\n\t\tfor (const { segment, ancestors } of segments) results.push({\n\t\t\tancestors,\n\t\t\tnode: segment\n\t\t});\n\t\tfor (const { group, ancestors } of groups) results.push({\n\t\t\tancestors,\n\t\t\tnode: group\n\t\t});\n\t\treturn results;\n\t}\n\tfor (const { segment, ancestors: segmentAncestors } of segments) {\n\t\tconst fieldResult = locateField(segment, parts.field, segmentAncestors);\n\t\tif (!fieldResult) continue;\n\t\tconst [field, fieldAncestors] = fieldResult;\n\t\tif (parts.component === void 0 && parts.subcomponent === void 0 && parts.repetition === void 0) {\n\t\t\tresults.push({\n\t\t\t\tancestors: fieldAncestors,\n\t\t\t\tnode: field\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tif (!field.children) continue;\n\t\tfor (const repetitionNode of field.children) {\n\t\t\tconst repetitionAncestors = [...fieldAncestors, field];\n\t\t\tif (parts.component === void 0) {\n\t\t\t\tresults.push({\n\t\t\t\t\tancestors: repetitionAncestors,\n\t\t\t\t\tnode: repetitionNode\n\t\t\t\t});\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst componentResult = locateComponent(repetitionNode, parts.component, repetitionAncestors);\n\t\t\tif (!componentResult) continue;\n\t\t\tconst [componentNode, componentAncestors] = componentResult;\n\t\t\tif (parts.subcomponent === void 0) {\n\t\t\t\tresults.push({\n\t\t\t\t\tancestors: componentAncestors,\n\t\t\t\t\tnode: componentNode\n\t\t\t\t});\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst subResult = locateSubcomponent(componentNode, parts.subcomponent, componentAncestors);\n\t\t\tif (subResult) results.push({\n\t\t\t\tancestors: subResult[1],\n\t\t\t\tnode: subResult[0]\n\t\t\t});\n\t\t}\n\t}\n\treturn results;\n}\n//#endregion\n//#region src/value.ts\n/**\n* Get the string value at the path, drilling down through single-child nodes\n* when needed. Also returns the node and ancestor chain for context.\n*\n* This is a convenience function that automatically traverses through container\n* nodes (Field → FieldRepetition → Component → Subcomponent) to extract the\n* primary string value. When a container has multiple children, the first child\n* is selected (e.g., `value(tree, \"MSH-12\")` returns the first component of a\n* composite VID field).\n*\n* Nodes with no children return `value: null` to differentiate between empty\n* strings (\"\") and missing values.\n*\n* @example\n*   ```typescript\n*   const result = value(root, \"PID-5.1\");\n*   if (result) {\n*     console.log(result.value); // string | null\n*     console.log(result.node.type); // 'subcomponent'\n*     console.log(result.ancestors); // [Root, Segment, Field, ...]\n*   }\n*   ```;\n*\n* @param root - The root node to search from\n* @param path - The HL7 path string\n* @returns Object containing the value, node, and ancestors, or null if not\n*   found\n*/\nfunction value(root, path) {\n\tconst selectResult = select(root, path);\n\tif (!selectResult) return null;\n\tlet { node } = selectResult;\n\tlet { ancestors } = selectResult;\n\twhile (node.type !== \"subcomponent\") {\n\t\tif (node.type === \"segment\" || node.type === \"group\" || node.type === \"root\") return null;\n\t\tif (!(\"children\" in node && node.children)) return null;\n\t\tif (node.children.length === 0) return {\n\t\t\tancestors: [...ancestors],\n\t\t\tnode,\n\t\t\tvalue: null\n\t\t};\n\t\tconst next = node.children[0];\n\t\tif (!next) return null;\n\t\tancestors = [...ancestors, node];\n\t\tnode = next;\n\t}\n\treturn {\n\t\tancestors,\n\t\tnode,\n\t\tvalue: node.value\n\t};\n}\n//#endregion\n//#region src/delimiters.ts\n/** Keys of MSH-2 encoding characters in positional order. */\nconst MSH2_KEYS = [\n\t\"component\",\n\t\"repetition\",\n\t\"escape\",\n\t\"subcomponent\"\n];\n/**\n* Extract delimiters from a Root AST by reading MSH-1 and MSH-2.\n*\n* MSH-1 contains the field separator character (e.g., `|`).\n* MSH-2 contains up to 4 encoding characters: component, repetition,\n* escape, and subcomponent (e.g., `^~\\&`).\n*\n* Falls back to DEFAULT_DELIMITERS for any values that cannot be derived.\n*\n* @param root - The Root AST node to extract delimiters from.\n* @returns The resolved Delimiters object.\n*/\nfunction delimiters(root) {\n\tconst result = { ...DEFAULT_DELIMITERS };\n\tconst msh1 = value(root, \"MSH-1\")?.value;\n\tif (msh1 && msh1.length === 1) result.field = msh1;\n\tconst msh2 = value(root, \"MSH-2\")?.value;\n\tif (msh2) {\n\t\tconst chars = [...msh2];\n\t\tfor (const [i, key] of MSH2_KEYS.entries()) {\n\t\t\tconst ch = chars[i];\n\t\t\tif (ch) result[key] = ch;\n\t\t}\n\t}\n\treturn result;\n}\n//#endregion\n//#region src/format.ts\n/** What a path names a node by: a segment's name, or a group's ID. */\nconst keyOf = (node) => node.type === \"group\" ? node.id : node.name;\n/**\n* Format a node and its ancestor chain into a canonical HL7v2 path string.\n*\n* This is the inverse of `select`: given a node and the ancestors\n* returned by `visit` or `select`, it produces the path string that\n* would select that node.\n*\n* @example\n*   ```typescript\n*   visit(tree, \"field\", (node, ancestors) => {\n*     format(node, ancestors); // \"PID-5\"\n*   });\n*\n*   const result = select(root, \"PID-5.2\");\n*   format(result.node, result.ancestors); // \"PID-5.2\"\n*   ```;\n*\n* @param node - The target AST node\n* @param ancestors - Ancestor chain from root to parent (as provided by\n*   visit/select)\n* @returns Canonical path string (e.g., \"PID-5.2\", \"ORDER-ORC-1\"), or `null` if the\n*   ancestor chain contains no segment or group\n*/\nfunction format(node, ancestors) {\n\tlet result = null;\n\tconst chain = [...ancestors, node];\n\tfor (const [i, current] of chain.entries()) {\n\t\tconst parent = chain[i - 1];\n\t\tswitch (current.type) {\n\t\t\tcase \"root\": break;\n\t\t\tcase \"group\":\n\t\t\tcase \"segment\": {\n\t\t\t\tconst pos = positionOf(current, parent);\n\t\t\t\tresult = (result ?? \"\") + keyOf(current);\n\t\t\t\tif (pos > 1) result += `[${pos}]`;\n\t\t\t\tif (current.type === \"group\" && current !== node) result += \"-\";\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"field\":\n\t\t\t\tresult += `-${positionOf(current, parent)}`;\n\t\t\t\tbreak;\n\t\t\tcase \"field-repetition\": {\n\t\t\t\tconst pos = positionOf(current, parent);\n\t\t\t\tif (pos > 1 || current === node) result += `[${pos}]`;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcase \"component\":\n\t\t\t\tresult += `.${positionOf(current, parent)}`;\n\t\t\t\tbreak;\n\t\t\tcase \"subcomponent\":\n\t\t\t\tresult += `.${positionOf(current, parent)}`;\n\t\t\t\tbreak;\n\t\t}\n\t}\n\treturn result;\n}\n/**\n* Compute the 1-based position of a node among its parent's children.\n*\n* For segments and groups, counts only siblings with the same name (a\n* group's ID): the 2nd PID in [MSH, PID, OBX, PID] is PID[2], not PID[4].\n*\n* For positional nodes (fields, repetitions, components, subcomponents),\n* uses the array index directly.\n*/\nfunction positionOf(node, parent) {\n\tif (!parent || !(\"children\" in parent)) return 1;\n\tconst children = parent.children;\n\tif (node.type === \"group\" || node.type === \"segment\") {\n\t\tconst key = keyOf(node);\n\t\tlet count = 0;\n\t\tfor (const child of children) {\n\t\t\tif (child === node) return count + 1;\n\t\t\tif (child.type === node.type && keyOf(child) === key) count++;\n\t\t}\n\t\tthrow new Error(\"format(): node not found in parent's children array\");\n\t}\n\tconst idx = children.indexOf(node);\n\tif (idx === -1) throw new Error(\"format(): node not found in parent's children array\");\n\treturn idx + 1;\n}\n//#endregion\n//#region src/matches.ts\n/**\n* Check if a node exists at the given path.\n*\n* This is a convenience function equivalent to `select(root, path) !== null`,\n* but more semantically clear for existence checks.\n*\n* @example\n*   ```typescript\n*   if (matches(root, \"PID-5\")) {\n*     console.log(\"Patient has a name field\");\n*   }\n*\n*   if (!matches(root, \"OBX-5\")) {\n*     throw new Error(\"Missing observation value\");\n*   }\n*   ```;\n*\n* @param root - The root node to search from\n* @param path - The HL7 path string\n* @returns True if the path resolves to a node, false otherwise\n*/\nfunction matches(root, path) {\n\treturn select(root, path) !== null;\n}\n//#endregion\n//#region src/set.ts\n/**\n* Set a string value at the given HL7 path, creating all missing intermediate\n* nodes as needed (fields, repetitions, components, subcomponents).\n*\n* This is the write counterpart to {@link value}. It handles the full HL7v2\n* path syntax including group navigation and segment repetitions.\n*\n* Padding nodes are created with empty children arrays — they represent\n* structurally absent nodes, not empty values. Only the target node gets\n* a fully populated chain down to the subcomponent.\n*\n* @example\n*   ```typescript\n*   // Update existing value\n*   set(tree, \"MSH-12\", \"2.7.1\");\n*\n*   // Create missing MSH-9.3 (fills gaps with empty components)\n*   set(tree, \"MSH-9.3\", \"ADT_A01\");\n*\n*   // Set a specific repetition\n*   set(tree, \"PID-3[2]\", \"ID-002\");\n*\n*   // Set a subcomponent\n*   set(tree, \"PID-5.1.2\", \"suffix\");\n*   ```;\n*\n* @param root - The root node to modify\n* @param path - The HL7 path string (must include at least a field)\n* @param val - The string value to set\n* @throws When the path has no field specifier (segment-only paths)\n* @throws When the target segment does not exist in the tree\n*/\nfunction set(root, path, val) {\n\tconst parts = parse(path);\n\tif (parts.field === void 0) throw new Error(`Cannot set value on segment-only path: \"${path}\"`);\n\tconst segmentResult = locateSegment(root, parts);\n\tif (!segmentResult) throw new Error(`Segment \"${parts.segment.name}\" not found in tree`);\n\tconst [segment] = segmentResult;\n\tconst fieldIndex = parts.field - 1;\n\tpadArray(segment.children, fieldIndex + 1, stubField);\n\tconst field = segment.children[fieldIndex];\n\tconst repIndex = (parts.repetition ?? 1) - 1;\n\tpadArray(field.children, repIndex + 1, stubRepetition);\n\tconst repetition = field.children[repIndex];\n\tconst compIndex = (parts.component ?? 1) - 1;\n\tpadArray(repetition.children, compIndex + 1, stubComponent);\n\tconst component = repetition.children[compIndex];\n\tconst subIndex = (parts.subcomponent ?? 1) - 1;\n\tpadArray(component.children, subIndex + 1, stubSubcomponent);\n\tcomponent.children[subIndex].value = val;\n}\n/**\n* Pad an array to a target length using a factory function.\n*/\nfunction padArray(arr, targetLength, factory) {\n\twhile (arr.length < targetLength) arr.push(factory());\n}\n/**\n* Stub nodes for padding — created with empty children arrays to represent\n* structurally absent nodes. These are distinguishable from nodes with empty\n* values (which have a subcomponent with value \"\").\n*/\nfunction stubField() {\n\treturn {\n\t\tchildren: [],\n\t\ttype: \"field\"\n\t};\n}\nfunction stubRepetition() {\n\treturn {\n\t\tchildren: [],\n\t\ttype: \"field-repetition\"\n\t};\n}\nfunction stubComponent() {\n\treturn {\n\t\tchildren: [],\n\t\ttype: \"component\"\n\t};\n}\nfunction stubSubcomponent() {\n\treturn {\n\t\ttype: \"subcomponent\",\n\t\tvalue: \"\"\n\t};\n}\n//#endregion\nexport { delimiters, format, matches, parse, select, selectAll, set, value };\n\n//# sourceMappingURL=index.js.map","import type {\n  Component,\n  Delimiters,\n  Field,\n  FieldRepetition,\n  Group,\n  Nodes,\n  Root,\n  Segment,\n  Subcomponent,\n} from \"@glion/ast\";\nimport { delimiters as queryDelimiters } from \"@glion/util-query\";\nimport { DEFAULT_DELIMITERS } from \"@glion/utils\";\nimport type { Plugin } from \"unified\";\nimport type { Node } from \"unist\";\nimport type { VFile } from \"vfile\";\n\nexport interface Hl7v2ToHl7v2Options {\n  /** Append a field delimiter after the last field in each segment. */\n  trailingDelimiter?: boolean;\n}\n\n/**\n * Unified compiler plugin: HL7v2 AST → HL7v2 string.\n *\n * Reads `file.data.delimiters` if set by hl7v2-annotate-delimiters,\n * otherwise derives from MSH-1/MSH-2 via `delimiters()` for standalone use.\n */\nexport const hl7v2ToHl7v2: Plugin<[Hl7v2ToHl7v2Options?], Root, string> =\n  function hl7v2ToHl7v2(options?: Hl7v2ToHl7v2Options): void {\n    // biome-ignore lint/complexity/noUselessThisAlias: unified plugin shape\n    const self = this;\n    self.compiler = (tree: Node, file: VFile): string =>\n      toHl7v2(\n        tree as Nodes,\n        file.data.delimiters as Delimiters | undefined,\n        options\n      );\n  };\n\n/**\n * Serialize an HL7v2 AST node back to its wire format.\n *\n * Works on any node in the tree — a full Root, a single Segment, or\n * even a lone Field. Delimiters default to the standard set unless\n * overridden or derivable from an MSH segment in the tree.\n */\nexport function toHl7v2(\n  node: Nodes,\n  delimiters?: Partial<Delimiters>,\n  options?: Hl7v2ToHl7v2Options\n): string {\n  const d = {\n    ...(node.type === \"root\" ? queryDelimiters(node) : DEFAULT_DELIMITERS),\n    ...delimiters,\n  };\n  const trailing = options?.trailingDelimiter === true;\n\n  // -- leaf & field-level serializers (no options needed) ----------------\n\n  const sub = (s: Subcomponent): string => s.value ?? \"\";\n\n  const comp = (c: Component): string =>\n    ((c.children || []) as Subcomponent[]).map(sub).join(d.subcomponent);\n\n  const rep = (r: FieldRepetition): string =>\n    (r.children as Component[]).map(comp).join(d.component);\n\n  const field = (f: Field): string =>\n    (f.children as FieldRepetition[]).map(rep).join(d.repetition);\n\n  // -- segment-level serializers ----------------------------------------\n\n  const fields = (parts: string[]): string => {\n    const joined = parts.join(d.field);\n    return trailing && joined.length > 0 ? `${joined}${d.field}` : joined;\n  };\n\n  const segment = (seg: Segment): string => {\n    const body = fields(seg.children.map(field));\n    if (!seg.name) {\n      return body;\n    }\n    return body ? `${seg.name}${d.field}${body}` : seg.name;\n  };\n\n  // MSH-1 is the field separator itself — skip it and emit structurally.\n  const msh = (seg: Segment): string => {\n    const tail = fields(seg.children.slice(1).map(field));\n    return tail.length ? `MSH${d.field}${tail}` : `MSH${d.field}`;\n  };\n\n  const line = (seg: Segment): string =>\n    seg.name === \"MSH\" ? msh(seg) : segment(seg);\n\n  const lines = (nodes: readonly (Segment | Group)[]): string[] =>\n    nodes.flatMap((child) =>\n      child.type === \"group\" ? lines(child.children) : [line(child)]\n    );\n\n  // -- dispatch ----------------------------------------------------------\n\n  switch (node.type) {\n    case \"root\":\n    case \"group\": {\n      return lines(node.children as (Segment | Group)[]).join(d.segment);\n    }\n    case \"segment\": {\n      return line(node);\n    }\n    case \"field\": {\n      return field(node);\n    }\n    case \"field-repetition\": {\n      return rep(node);\n    }\n    case \"component\": {\n      return comp(node);\n    }\n    case \"subcomponent\": {\n      return sub(node);\n    }\n    default: {\n      const unsupported: never = node;\n      throw new Error(`Unsupported node type: ${(unsupported as Node).type}`);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAM,aAAa;;;;;;AAMnB,MAAM,6BAA6B,IAAI,KAAK;;;;;;;;AAQ5C,MAAM,YAAY;CACjB,UAAU;EACT,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,UAAU;EACT,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,SAAS;EACR,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,SAAS;EACR,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,SAAS;EACR,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,SAAS;EACR,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,SAAS;EACR,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,WAAW;EACV,WAAW;EACX,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,WAAW;EACV,WAAW;EACX,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD,WAAW;EACV,WAAW;EACX,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB;CACD;;;;;;;;;;;;;;;;;;;;;AAqBD,SAAS,MAAM,MAAM;CACpB,MAAM,MAAM,UAAU;AACtB,KAAI,IAAK,QAAO;CAChB,MAAM,SAAS,WAAW,IAAI,KAAK;AACnC,KAAI,OAAQ,QAAO;CACnB,MAAM,SAAS,UAAU,KAAK;AAC9B,YAAW,IAAI,MAAM,OAAO;AAC5B,QAAO;;;;;AAKR,SAAS,UAAU,MAAM;AACxB,KAAI,CAAC,QAAQ,OAAO,SAAS,SAAU,OAAM,IAAI,MAAM,yCAAyC,OAAO;AACvG,KAAI,KAAK,MAAM,KAAK,KAAM,OAAM,IAAI,MAAM,iDAAiD,KAAK,GAAG;CACnG,MAAM,QAAQ,WAAW,KAAK,KAAK;AACnC,KAAI,CAAC,MAAO,OAAM,IAAI,MAAM,6BAA6B,KAAK,mFAAmF;CACjJ,MAAM,GAAG,WAAW,aAAa,YAAY,UAAU,eAAe,cAAc,mBAAmB;AACvG,KAAI,CAAC,YAAa,OAAM,IAAI,MAAM,4CAA4C,KAAK,GAAG;CACtF,MAAM,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,EAAE;AAChD,KAAI,YAAY;EACf,MAAM,aAAa,OAAO,SAAS,YAAY,GAAG;AAClD,MAAI,aAAa,EAAG,OAAM,IAAI,MAAM,uCAAuC,WAAW,OAAO,KAAK,GAAG;AACrG,QAAM,QAAQ,aAAa;;AAE5B,KAAI,WAAW;EACd,MAAM,SAAS,EAAE;AACjB,OAAK,MAAM,cAAc,UAAU,SAAS,oCAAoC,EAAE;GACjF,MAAM,OAAO,WAAW;AACxB,OAAI,CAAC,KAAM;GACX,MAAM,SAAS,WAAW;GAC1B,MAAM,QAAQ,EAAE,MAAM;AACtB,OAAI,QAAQ;IACX,MAAM,aAAa,OAAO,SAAS,QAAQ,GAAG;AAC9C,QAAI,aAAa,EAAG,OAAM,IAAI,MAAM,qCAAqC,OAAO,OAAO,KAAK,GAAG;AAC/F,UAAM,aAAa;;AAEpB,UAAO,KAAK,MAAM;;AAEnB,MAAI,OAAO,SAAS,EAAG,OAAM,SAAS;;AAEvC,KAAI,UAAU;EACb,MAAM,QAAQ,OAAO,SAAS,UAAU,GAAG;AAC3C,MAAI,QAAQ,EAAG,OAAM,IAAI,MAAM,iCAAiC,WAAW;AAC3E,QAAM,QAAQ;;AAEf,KAAI,eAAe;EAClB,MAAM,aAAa,OAAO,SAAS,eAAe,GAAG;AACrD,MAAI,aAAa,EAAG,OAAM,IAAI,MAAM,sCAAsC,gBAAgB;AAC1F,QAAM,aAAa;;AAEpB,KAAI,cAAc;EACjB,MAAM,YAAY,OAAO,SAAS,cAAc,GAAG;AACnD,MAAI,YAAY,EAAG,OAAM,IAAI,MAAM,qCAAqC,eAAe;AACvF,QAAM,YAAY;;AAEnB,KAAI,iBAAiB;EACpB,MAAM,eAAe,OAAO,SAAS,iBAAiB,GAAG;AACzD,MAAI,eAAe,EAAG,OAAM,IAAI,MAAM,wCAAwC,kBAAkB;AAChG,QAAM,eAAe;;AAEtB,QAAO;;AAIR,SAAS,qBAAqB,MAAM,OAAO;CAC1C,MAAM,YAAY,CAAC,KAAK;CACxB,MAAM,QAAQ,aAAa,MAAM,MAAM,UAAU,EAAE,EAAE,UAAU;AAC/D,KAAI,CAAC,MAAO,QAAO;CACnB,MAAM,aAAa,MAAM,QAAQ;CACjC,MAAM,mBAAmB,MAAM,QAAQ;CACvC,MAAM,kBAAkB,gBAAgB,OAAO,YAAY,UAAU;AACrE,KAAI,gBAAgB,SAAS,GAAG;EAC/B,MAAM,QAAQ,iBAAiB,oBAAoB,KAAK;AACxD,MAAI,MAAO,QAAO,CAAC,MAAM,SAAS,MAAM,UAAU;;CAEnD,MAAM,gBAAgB,cAAc,OAAO,YAAY,UAAU;AACjE,KAAI,cAAc,SAAS,GAAG;EAC7B,MAAM,QAAQ,eAAe,oBAAoB,KAAK;AACtD,MAAI,MAAO,QAAO,CAAC,MAAM,OAAO,MAAM,UAAU;;AAEjD,QAAO;;AAER,SAAS,cAAc,MAAM,OAAO;CACnC,MAAM,YAAY,CAAC,KAAK;CACxB,MAAM,QAAQ,aAAa,MAAM,MAAM,UAAU,EAAE,EAAE,UAAU;AAC/D,KAAI,CAAC,MAAO,QAAO;CACnB,MAAM,kBAAkB,gBAAgB,OAAO,MAAM,QAAQ,MAAM,UAAU;AAC7E,KAAI,gBAAgB,WAAW,EAAG,QAAO;CACzC,MAAM,QAAQ,iBAAiB,MAAM,QAAQ,cAAc,KAAK;AAChE,KAAI,CAAC,MAAO,QAAO;AACnB,QAAO,CAAC,MAAM,SAAS,MAAM,UAAU;;AAExC,SAAS,aAAa,MAAM,QAAQ,eAAe;CAClD,IAAI,WAAW,wBAAwB,KAAK,SAAS;AACrD,MAAK,MAAM,WAAW,QAAQ;EAC7B,MAAM,gBAAgB,SAAS,QAAQ,SAAS,KAAK,SAAS,WAAW,KAAK,OAAO,QAAQ,KAAK;AAClG,MAAI,cAAc,WAAW,EAAG,QAAO;EACvC,MAAM,WAAW,eAAe,QAAQ,cAAc,KAAK;AAC3D,MAAI,CAAC,SAAU,QAAO;AACtB,gBAAc,KAAK,SAAS;AAC5B,aAAW,wBAAwB,SAAS,SAAS;;AAEtD,QAAO;;AA0DR,SAAS,gBAAgB,OAAO,mBAAmB,WAAW;CAC7D,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,QAAQ,OAAO;AACzB,MAAI,KAAK,SAAS;OACb,eAAe,KAAK,KAAK,kBAAmB,QAAO,KAAK;IAC3D,WAAW,CAAC,GAAG,UAAU;IACzB,SAAS;IACT,CAAC;;AAEH,MAAI,KAAK,SAAS,SAAS;GAC1B,MAAM,gBAAgB,CAAC,GAAG,WAAW,KAAK;AAC1C,UAAO,KAAK,GAAG,gBAAgB,wBAAwB,KAAK,SAAS,EAAE,mBAAmB,cAAc,CAAC;;;AAG3G,QAAO;;AAER,SAAS,cAAc,OAAO,eAAe,WAAW;CACvD,MAAM,SAAS,EAAE;AACjB,MAAK,MAAM,QAAQ,OAAO;AACzB,MAAI,KAAK,SAAS,WAAW,KAAK,OAAO,cAAe,QAAO,KAAK;GACnE,WAAW,CAAC,GAAG,UAAU;GACzB,OAAO;GACP,CAAC;AACF,MAAI,KAAK,SAAS,SAAS;GAC1B,MAAM,gBAAgB,CAAC,GAAG,WAAW,KAAK;AAC1C,UAAO,KAAK,GAAG,cAAc,wBAAwB,KAAK,SAAS,EAAE,eAAe,cAAc,CAAC;;;AAGrG,QAAO;;AAER,SAAS,YAAY,SAAS,UAAU,iBAAiB;CACxD,MAAM,QAAQ,UAAU,QAAQ,CAAC,WAAW;AAC5C,KAAI,CAAC,MAAO,QAAO;AACnB,QAAO,CAAC,OAAO,CAAC,GAAG,iBAAiB,QAAQ,CAAC;;AAE9C,SAAS,iBAAiB,OAAO,YAAY,iBAAiB;AAC7D,KAAI,aAAa,EAAG,QAAO;CAC3B,MAAM,OAAO,MAAM,WAAW,aAAa;AAC3C,KAAI,CAAC,KAAM,QAAO;AAClB,QAAO,CAAC,MAAM,CAAC,GAAG,iBAAiB,MAAM,CAAC;;AAE3C,SAAS,gBAAgB,YAAY,cAAc,iBAAiB;AACnE,KAAI,eAAe,EAAG,QAAO;CAC7B,MAAM,YAAY,WAAW,WAAW,eAAe;AACvD,KAAI,CAAC,UAAW,QAAO;AACvB,QAAO,CAAC,WAAW,CAAC,GAAG,iBAAiB,WAAW,CAAC;;AAErD,SAAS,mBAAmB,WAAW,iBAAiB,iBAAiB;AACxE,KAAI,kBAAkB,EAAG,QAAO;CAChC,MAAM,OAAO,UAAU,WAAW,kBAAkB;AACpD,KAAI,CAAC,KAAM,QAAO;AAClB,QAAO,CAAC,MAAM,CAAC,GAAG,iBAAiB,UAAU,CAAC;;AAE/C,SAAS,eAAe,SAAS;AAChC,QAAO,QAAQ;;AAEhB,SAAS,UAAU,SAAS;AAC3B,QAAO,QAAQ;;AAEhB,SAAS,wBAAwB,OAAO;AACvC,QAAO,MAAM,QAAQ,SAAS,KAAK,SAAS,aAAa,KAAK,SAAS,QAAQ;;;;;;;;;;;;;;;;;;;;;;;AAyBhF,SAAS,OAAO,MAAM,MAAM;CAC3B,MAAM,QAAQ,MAAM,KAAK;AACzB,KAAI,MAAM,UAAU,KAAK,GAAG;EAC3B,MAAM,SAAS,qBAAqB,MAAM,MAAM;AAChD,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO;GACN,WAAW,OAAO;GAClB,MAAM,OAAO;GACb;;CAEF,MAAM,gBAAgB,cAAc,MAAM,MAAM;AAChD,KAAI,CAAC,cAAe,QAAO;CAC3B,MAAM,CAAC,SAAS,oBAAoB;CACpC,MAAM,cAAc,YAAY,SAAS,MAAM,OAAO,iBAAiB;AACvE,KAAI,CAAC,YAAa,QAAO;CACzB,MAAM,CAAC,OAAO,kBAAkB;AAChC,KAAI,MAAM,cAAc,KAAK,KAAK,MAAM,iBAAiB,KAAK,KAAK,MAAM,eAAe,KAAK,EAAG,QAAO;EACtG,WAAW;EACX,MAAM;EACN;CACD,MAAM,mBAAmB,iBAAiB,OAAO,MAAM,cAAc,GAAG,eAAe;AACvF,KAAI,CAAC,iBAAkB,QAAO;CAC9B,MAAM,CAAC,gBAAgB,uBAAuB;AAC9C,KAAI,MAAM,cAAc,KAAK,EAAG,QAAO;EACtC,WAAW;EACX,MAAM;EACN;CACD,MAAM,kBAAkB,gBAAgB,gBAAgB,MAAM,WAAW,oBAAoB;AAC7F,KAAI,CAAC,gBAAiB,QAAO;CAC7B,MAAM,CAAC,eAAe,sBAAsB;AAC5C,KAAI,MAAM,iBAAiB,KAAK,EAAG,QAAO;EACzC,WAAW;EACX,MAAM;EACN;CACD,MAAM,YAAY,mBAAmB,eAAe,MAAM,cAAc,mBAAmB;AAC3F,KAAI,CAAC,UAAW,QAAO;AACvB,QAAO;EACN,WAAW,UAAU;EACrB,MAAM,UAAU;EAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgIF,SAAS,MAAM,MAAM,MAAM;CAC1B,MAAM,eAAe,OAAO,MAAM,KAAK;AACvC,KAAI,CAAC,aAAc,QAAO;CAC1B,IAAI,EAAE,SAAS;CACf,IAAI,EAAE,cAAc;AACpB,QAAO,KAAK,SAAS,gBAAgB;AACpC,MAAI,KAAK,SAAS,aAAa,KAAK,SAAS,WAAW,KAAK,SAAS,OAAQ,QAAO;AACrF,MAAI,EAAE,cAAc,QAAQ,KAAK,UAAW,QAAO;AACnD,MAAI,KAAK,SAAS,WAAW,EAAG,QAAO;GACtC,WAAW,CAAC,GAAG,UAAU;GACzB;GACA,OAAO;GACP;EACD,MAAM,OAAO,KAAK,SAAS;AAC3B,MAAI,CAAC,KAAM,QAAO;AAClB,cAAY,CAAC,GAAG,WAAW,KAAK;AAChC,SAAO;;AAER,QAAO;EACN;EACA;EACA,OAAO,KAAK;EACZ;;;AAKF,MAAM,YAAY;CACjB;CACA;CACA;CACA;CACA;;;;;;;;;;;;;AAaD,SAAS,WAAW,MAAM;CACzB,MAAM,SAAS,EAAE,GAAG,oBAAoB;CACxC,MAAM,OAAO,MAAM,MAAM,QAAQ,EAAE;AACnC,KAAI,QAAQ,KAAK,WAAW,EAAG,QAAO,QAAQ;CAC9C,MAAM,OAAO,MAAM,MAAM,QAAQ,EAAE;AACnC,KAAI,MAAM;EACT,MAAM,QAAQ,CAAC,GAAG,KAAK;AACvB,OAAK,MAAM,CAAC,GAAG,QAAQ,UAAU,SAAS,EAAE;GAC3C,MAAM,KAAK,MAAM;AACjB,OAAI,GAAI,QAAO,OAAO;;;AAGxB,QAAO;;;;;;;;;;AC1iBR,MAAa,eACX,SAAS,aAAa,SAAqC;CAEzD,MAAM,OAAO;AACb,MAAK,YAAY,MAAY,SAC3B,QACE,MACA,KAAK,KAAK,YACV,QACD;;;;;;;;;AAUP,SAAgB,QACd,MACA,cACA,SACQ;CACR,MAAM,IAAI;EACR,GAAI,KAAK,SAAS,SAASA,WAAgB,KAAK,GAAG;EACnD,GAAGC;EACJ;CACD,MAAM,WAAW,SAAS,sBAAsB;CAIhD,MAAM,OAAO,MAA4B,EAAE,SAAS;CAEpD,MAAM,QAAQ,OACV,EAAE,YAAY,EAAE,EAAqB,IAAI,IAAI,CAAC,KAAK,EAAE,aAAa;CAEtE,MAAM,OAAO,MACV,EAAE,SAAyB,IAAI,KAAK,CAAC,KAAK,EAAE,UAAU;CAEzD,MAAM,SAAS,MACZ,EAAE,SAA+B,IAAI,IAAI,CAAC,KAAK,EAAE,WAAW;CAI/D,MAAM,UAAU,UAA4B;EAC1C,MAAM,SAAS,MAAM,KAAK,EAAE,MAAM;AAClC,SAAO,YAAY,OAAO,SAAS,IAAI,GAAG,SAAS,EAAE,UAAU;;CAGjE,MAAM,WAAW,QAAyB;EACxC,MAAM,OAAO,OAAO,IAAI,SAAS,IAAI,MAAM,CAAC;AAC5C,MAAI,CAAC,IAAI,KACP,QAAO;AAET,SAAO,OAAO,GAAG,IAAI,OAAO,EAAE,QAAQ,SAAS,IAAI;;CAIrD,MAAM,OAAO,QAAyB;EACpC,MAAM,OAAO,OAAO,IAAI,SAAS,MAAM,EAAE,CAAC,IAAI,MAAM,CAAC;AACrD,SAAO,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,EAAE;;CAGxD,MAAM,QAAQ,QACZ,IAAI,SAAS,QAAQ,IAAI,IAAI,GAAG,QAAQ,IAAI;CAE9C,MAAM,SAAS,UACb,MAAM,SAAS,UACb,MAAM,SAAS,UAAU,MAAM,MAAM,SAAS,GAAG,CAAC,KAAK,MAAM,CAAC,CAC/D;AAIH,SAAQ,KAAK,MAAb;EACE,KAAK;EACL,KAAK,QACH,QAAO,MAAM,KAAK,SAAgC,CAAC,KAAK,EAAE,QAAQ;EAEpE,KAAK,UACH,QAAO,KAAK,KAAK;EAEnB,KAAK,QACH,QAAO,MAAM,KAAK;EAEpB,KAAK,mBACH,QAAO,IAAI,KAAK;EAElB,KAAK,YACH,QAAO,KAAK,KAAK;EAEnB,KAAK,eACH,QAAO,IAAI,KAAK;EAElB,QAEE,OAAM,IAAI,MAAM,0BAA2BC,KAAqB,OAAO"}
+{"version":3,"file":"index.js","names":["queryDelimiters","delimiters","unsupported"],"sources":["../../util-query/dist/index.js","../src/index.ts"],"sourcesContent":["import { DEFAULT_DELIMITERS } from \"@glion/utils\";\n//#region src/errors.ts\n/**\n* The typed failure for `@glion/util-query`. Branch on `code`; each code is\n* one cause.\n*\n* @module\n*/\n/**\n* Machine-readable codes for what a path got wrong:\n*\n* - `EMPTY_PATH` — the path is empty.\n* - `INVALID_PATH` — the path does not follow the path grammar.\n*/\nconst QueryErrorCode = {\n\tEMPTY_PATH: \"EMPTY_PATH\",\n\tINVALID_PATH: \"INVALID_PATH\"\n};\nfunction sentence(code, path) {\n\tswitch (code) {\n\t\tcase \"EMPTY_PATH\": return \"The path is empty; a path is `[GROUP[N].]...NAME[N][.FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]]`, or `FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]` read from a segment, with positions from 1, such as `PID.5.1` or `5.1`.\";\n\t\tcase \"INVALID_PATH\": return `Path \\`${path}\\` does not follow the path grammar; a path is \\`[GROUP[N].]...NAME[N][.FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]]\\`, or \\`FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]\\` read from a segment, with positions from 1, such as \\`PID.5.1\\` or \\`5.1\\`.`;\n\t}\n}\n/** A path that `@glion/util-query` cannot read. */\nvar QueryError = class extends Error {\n\tname = \"QueryError\";\n\tcode;\n\tpath;\n\tconstructor(code, path) {\n\t\tsuper(sentence(code, path));\n\t\tthis.code = code;\n\t\tthis.path = path;\n\t}\n};\n//#endregion\n//#region src/parse.ts\n/**\n* Canonical HL7 path grammar, every step separated with `.`:\n*\n* [GROUP[N].]...NAME[N][.FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]]\n* FIELD[REPETITION][.COMPONENT[.SUBCOMPONENT]]\n*\n* Names start with a letter and positions are numbers from 1, so the first\n* numeric step is the field. The final name is the query target. Field\n* access makes it a segment (`ORDER.ORC.1`); without it the AST decides\n* whether it names a segment or a group (`ORDER.ORC`, `ORDER`). A path that\n* starts with the field names no segment (`5.1`).\n*/\nconst PATH_REGEX = /^(?:([A-Z][A-Z0-9_]*(?:\\[[1-9]\\d*\\])?(?:\\.[A-Z][A-Z0-9_]*(?:\\[[1-9]\\d*\\])?)*)(?:\\.(?=[1-9])|$))?(?:([1-9]\\d*)(?:\\[([1-9]\\d*)\\])?(?:\\.([1-9]\\d*)(?:\\.([1-9]\\d*))?)?)?$/;\nconst NAVIGATION_STEP_REGEX = /([A-Z][A-Z0-9_]*)(?:\\[(\\d+)\\])?/g;\n/** Parts of the MSH paths that plugins and lint rules read on every message. */\nconst PRECOMPUTED_PATHS = new Map([\n\t[\"MSH.3\", () => ({\n\t\tfield: 3,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.4\", () => ({\n\t\tfield: 4,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.5\", () => ({\n\t\tfield: 5,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.6\", () => ({\n\t\tfield: 6,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.9\", () => ({\n\t\tfield: 9,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.9.1\", () => ({\n\t\tcomponent: 1,\n\t\tfield: 9,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.9.2\", () => ({\n\t\tcomponent: 2,\n\t\tfield: 9,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.9.3\", () => ({\n\t\tcomponent: 3,\n\t\tfield: 9,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.10\", () => ({\n\t\tfield: 10,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.12\", () => ({\n\t\tfield: 12,\n\t\tsegment: { name: \"MSH\" }\n\t})],\n\t[\"MSH.12.1\", () => ({\n\t\tcomponent: 1,\n\t\tfield: 12,\n\t\tsegment: { name: \"MSH\" }\n\t})]\n]);\n/**\n* Parse an HL7 path string into structured parts.\n*\n* Returns a new object on every call.\n*\n* @example\n*   ```typescript\n*   parse(\"PID.5[1].2.1\");\n*   // {\n*   //   segment: { name: 'PID' },\n*   //   field: 5,\n*   //   repetition: 1,\n*   //   component: 2,\n*   //   subcomponent: 1\n*   // }\n*   ```;\n*\n* @param path - HL7 path string to parse\n* @returns Structured path components\n*/\nfunction parse(path) {\n\tconst precomputed = PRECOMPUTED_PATHS.get(path);\n\tif (precomputed) return precomputed();\n\tif (path === \"\") throw new QueryError(\"EMPTY_PATH\", path);\n\tconst match = PATH_REGEX.exec(path);\n\tif (!match) throw new QueryError(\"INVALID_PATH\", path);\n\tconst [, navigation = \"\", field, repetition, component, subcomponent] = match;\n\tconst steps = [];\n\tfor (const [, name, position] of navigation.matchAll(NAVIGATION_STEP_REGEX)) steps.push(position === void 0 ? { name } : {\n\t\tname,\n\t\trepetition: Number(position)\n\t});\n\tconst parts = {};\n\tconst segment = steps.pop();\n\tif (segment !== void 0) parts.segment = segment;\n\tif (steps.length > 0) parts.groups = steps;\n\tif (field !== void 0) parts.field = Number(field);\n\tif (repetition !== void 0) parts.repetition = Number(repetition);\n\tif (component !== void 0) parts.component = Number(component);\n\tif (subcomponent !== void 0) parts.subcomponent = Number(subcomponent);\n\treturn parts;\n}\n//#endregion\n//#region src/resolve.ts\n/** The name a path gives a node: a segment's name, or a group's ID. */\nconst keyOf = (node) => {\n\tswitch (node.type) {\n\t\tcase \"root\":\n\t\tcase \"field\":\n\t\tcase \"field-repetition\":\n\t\tcase \"component\":\n\t\tcase \"subcomponent\": return;\n\t\tcase \"segment\": return node.name;\n\t\tcase \"group\": return node.id;\n\t}\n};\n/**\n* The `position`th of `children` (1-based) when given; otherwise every one\n* when `every` is set, or the first.\n*/\nfunction pick(children, position, every) {\n\tif (position !== void 0) {\n\t\tconst child = children[position - 1];\n\t\treturn child === void 0 ? [] : [child];\n\t}\n\treturn every ? children : children.slice(0, 1);\n}\n/**\n* The children of `parent` a path step names `name`, segments and groups\n* together: the `position`th (1-based) when given; otherwise every one when\n* `every` is set, or the first.\n*/\nfunction stepChildren(parent, name, position, every) {\n\tconst result = [];\n\tconst target = position ?? 1;\n\tlet count = 0;\n\tfor (const child of parent.children) {\n\t\tif (keyOf(child) !== name) continue;\n\t\tif (every && position === void 0) {\n\t\t\tresult.push(child);\n\t\t\tcontinue;\n\t\t}\n\t\tcount += 1;\n\t\tif (count === target) return [child];\n\t}\n\treturn result;\n}\n/** The children of each scope that `step` names, with their ancestors. */\nfunction advance(scopes, step, every) {\n\tconst next = [];\n\tfor (const scope of scopes) for (const node of stepChildren(scope.node, step.name, step.repetition, every)) next.push({\n\t\tancestors: [...scope.ancestors, scope.node],\n\t\tnode\n\t});\n\treturn next;\n}\n/**\n* The field, repetitions, components, or subcomponents `parts` addresses in\n* `segment`.\n*/\nfunction resolveField(segment, ancestors, fieldNumber, parts, every) {\n\tconst field = segment.children[fieldNumber - 1];\n\tif (!field) return [];\n\tconst fieldAncestors = [...ancestors, segment];\n\tif (parts.repetition === void 0 && parts.component === void 0) return [{\n\t\tancestors: fieldAncestors,\n\t\tnode: field\n\t}];\n\tconst matches = [];\n\tfor (const repetition of pick(field.children ?? [], parts.repetition, every)) {\n\t\tconst repetitionAncestors = [...fieldAncestors, field];\n\t\tif (parts.component === void 0) {\n\t\t\tmatches.push({\n\t\t\t\tancestors: repetitionAncestors,\n\t\t\t\tnode: repetition\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tconst component = repetition.children?.[parts.component - 1];\n\t\tif (!component) continue;\n\t\tconst componentAncestors = [...repetitionAncestors, repetition];\n\t\tif (parts.subcomponent === void 0) {\n\t\t\tmatches.push({\n\t\t\t\tancestors: componentAncestors,\n\t\t\t\tnode: component\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\t\tconst subcomponent = component.children?.[parts.subcomponent - 1];\n\t\tif (subcomponent) matches.push({\n\t\t\tancestors: [...componentAncestors, component],\n\t\t\tnode: subcomponent\n\t\t});\n\t}\n\treturn matches;\n}\n/**\n* The nodes `parts` addresses under `start`, in document order, each with its\n* own ancestors array, which begins at `start`.\n*\n* Every step names a direct child of the node before it; the first step\n* names a direct child of `start`. A step's `[n]` counts the children with\n* that name, segments and groups together. A step without `[n]` matches the\n* first such child, or every one when `every` is set; so does a field\n* without a repetition when the path names a component.\n*/\nfunction resolve(start, parts, every) {\n\tlet scopes = [{\n\t\tancestors: [],\n\t\tnode: start\n\t}];\n\tfor (const group of parts.groups ?? []) scopes = advance(scopes, group, every);\n\tif (parts.segment !== void 0) scopes = advance(scopes, parts.segment, every);\n\tif (parts.field === void 0) return scopes;\n\tconst matches = [];\n\tfor (const { node, ancestors } of scopes) {\n\t\tif (node.type !== \"segment\") continue;\n\t\tfor (const match of resolveField(node, ancestors, parts.field, parts, every)) matches.push(match);\n\t}\n\treturn matches;\n}\n//#endregion\n//#region src/select.ts\n/**\n* The node `path` addresses under `node`, with its ancestors from `node`, or\n* `null`.\n*\n* Every step of `path` names a direct child of the node before it; the first\n* step names a direct child of `node`, so a path read from a segment starts\n* with the field. A step without `[n]` names the first such child, so\n* `select` returns `null` when that child does not lead to a match, even if a\n* later one does; `selectAll` returns every match.\n*\n* @example\n*   ```typescript\n*   select(root, \"PID.5\"); // { node: Field, ancestors: [Root, Segment] }\n*   select(root, \"PATIENT_RESULT.PATIENT.PID.5\");\n*   select(segment, \"5.1\"); // { node: Component, ancestors: [Segment, Field, FieldRepetition] }\n*   ```;\n*\n* @param node - The message, group, or segment to read from.\n* @param path - The path to the node.\n* @returns The node and its ancestors, or `null` when nothing matches.\n*/\nfunction select(node, path) {\n\tconst [match] = resolve(node, parse(path), false);\n\treturn match ?? null;\n}\n/**\n* Every node `path` addresses under `node`, with its ancestors from `node`, in\n* document order.\n*\n* Every step of `path` names a direct child of the node before it; the first\n* step names a direct child of `node`, so a path read from a segment starts\n* with the field. A step without `[n]` matches every such child, and so does\n* a field without a repetition when `path` names a component.\n*\n* @example\n*   ```typescript\n*   selectAll(root, \"OBX.5\"); // OBX-5 of every top-level OBX\n*   selectAll(root, \"OBX.1[2]\"); // the second repetition of OBX-1 in every OBX\n*   selectAll(segment, \"3.1\"); // the first component of every repetition of field 3\n*   ```;\n*\n* @param node - The message, group, or segment to read from.\n* @param path - The path to the nodes.\n* @returns The nodes and their ancestors; empty when nothing matches.\n*/\nfunction selectAll(node, path) {\n\treturn resolve(node, parse(path), true);\n}\n//#endregion\n//#region src/value.ts\n/**\n* Get the string value at the path, drilling down through single-child nodes\n* when needed. Also returns the node and ancestor chain for context.\n*\n* This is a convenience function that automatically traverses through container\n* nodes (Field → FieldRepetition → Component → Subcomponent) to extract the\n* primary string value. When a container has multiple children, the first child\n* is selected (e.g., `value(tree, \"MSH.12\")` returns the first component of a\n* composite VID field).\n*\n* Nodes with no children return `value: null` to differentiate between empty\n* strings (\"\") and missing values.\n*\n* @example\n*   ```typescript\n*   const result = value(root, \"PID.5.1\");\n*   if (result) {\n*     console.log(result.value); // string | null\n*     console.log(result.node.type); // 'subcomponent'\n*     console.log(result.ancestors); // [Root, Segment, Field, ...]\n*   }\n*\n*   value(segment, \"5.1\"); // the same value, read from the PID segment\n*   ```;\n*\n* @param node - The message, group, or segment to read from\n* @param path - The HL7 path string\n* @returns Object containing the value, node, and ancestors from `node`, or\n*   null if not found\n*/\nfunction value(node, path) {\n\tconst selected = select(node, path);\n\treturn selected ? drill(selected.node, selected.ancestors) : null;\n}\n/**\n* The first subcomponent under `node`, with its value, or `node` with value\n* `null` when a field, repetition, or component on the way has no children.\n* `null` for a root, group, or segment.\n*/\nfunction drill(node, ancestors) {\n\tswitch (node.type) {\n\t\tcase \"root\":\n\t\tcase \"group\":\n\t\tcase \"segment\": return null;\n\t\tcase \"subcomponent\": return {\n\t\t\tancestors,\n\t\t\tnode,\n\t\t\tvalue: node.value\n\t\t};\n\t\tcase \"field\":\n\t\tcase \"field-repetition\":\n\t\tcase \"component\": {\n\t\t\tconst first = node.children?.[0];\n\t\t\treturn first ? drill(first, [...ancestors, node]) : {\n\t\t\t\tancestors,\n\t\t\t\tnode,\n\t\t\t\tvalue: null\n\t\t\t};\n\t\t}\n\t}\n}\n//#endregion\n//#region src/delimiters.ts\n/** Keys of MSH-2 encoding characters in positional order. */\nconst MSH2_KEYS = [\n\t\"component\",\n\t\"repetition\",\n\t\"escape\",\n\t\"subcomponent\"\n];\n/**\n* Extract delimiters from a Root AST by reading MSH-1 and MSH-2.\n*\n* MSH-1 contains the field separator character (e.g., `|`).\n* MSH-2 contains up to 4 encoding characters: component, repetition,\n* escape, and subcomponent (e.g., `^~\\&`).\n*\n* Falls back to DEFAULT_DELIMITERS for any values that cannot be derived.\n*\n* @param root - The Root AST node to extract delimiters from.\n* @returns The resolved Delimiters object.\n*/\nfunction delimiters(root) {\n\tconst result = { ...DEFAULT_DELIMITERS };\n\tconst msh1 = value(root, \"MSH.1\")?.value;\n\tif (msh1 && msh1.length === 1) result.field = msh1;\n\tconst msh2 = value(root, \"MSH.2\")?.value;\n\tif (msh2) {\n\t\tconst chars = [...msh2];\n\t\tfor (const [i, key] of MSH2_KEYS.entries()) {\n\t\t\tconst ch = chars[i];\n\t\t\tif (ch) result[key] = ch;\n\t\t}\n\t}\n\treturn result;\n}\n//#endregion\n//#region src/format.ts\n/**\n* Format a node and its ancestor chain into a canonical HL7v2 path string.\n*\n* When `ancestors` starts at the root, `select(root, path)` returns `node`:\n* the path names every group, and `[n]` counts the siblings with the same\n* name, segments and groups together.\n*\n* @example\n*   ```typescript\n*   visit(tree, \"field\", (node, ancestors) => {\n*     format(node, ancestors); // \"PID.5\"\n*   });\n*\n*   const result = select(root, \"PID.5.2\");\n*   format(result.node, result.ancestors); // \"PID.5.2\"\n*   ```;\n*\n* @param node - The target AST node\n* @param ancestors - Ancestor chain from root to parent (as provided by\n*   visit/select)\n* @returns Canonical path string (e.g., \"PID.5.2\", \"ORDER.ORC.1\"), or `null` if the\n*   ancestor chain contains no segment or group, or an ancestor does not\n*   hold the next node in the chain\n*/\nfunction format(node, ancestors) {\n\tconst chain = [...ancestors, node];\n\tconst steps = [];\n\tlet positions = \"\";\n\tfor (const [index, current] of chain.entries()) {\n\t\tconst position = positionOf(current, chain[index - 1]);\n\t\tif (position === 0) return null;\n\t\tswitch (current.type) {\n\t\t\tcase \"root\": break;\n\t\t\tcase \"group\":\n\t\t\tcase \"segment\":\n\t\t\t\tsteps.push(position > 1 ? `${keyOf(current)}[${position}]` : `${keyOf(current)}`);\n\t\t\t\tbreak;\n\t\t\tcase \"field-repetition\":\n\t\t\t\tif (position > 1 || current === node) positions += `[${position}]`;\n\t\t\t\tbreak;\n\t\t\tcase \"field\":\n\t\t\tcase \"component\":\n\t\t\tcase \"subcomponent\":\n\t\t\t\tpositions += `.${position}`;\n\t\t\t\tbreak;\n\t\t}\n\t}\n\treturn steps.length === 0 ? null : steps.join(\".\") + positions;\n}\n/**\n* The 1-based position of `node` among the children of `parent`: for a\n* segment or group, its `[n]` counted as `select` counts it; otherwise its\n* index. 1 without a parent; 0 when `parent` does not hold `node`.\n*/\nfunction positionOf(node, parent) {\n\tif (parent === void 0 || !(\"children\" in parent)) return 1;\n\tswitch (node.type) {\n\t\tcase \"group\":\n\t\tcase \"segment\": return stepChildren(parent, keyOf(node), void 0, true).indexOf(node) + 1;\n\t\tcase \"root\":\n\t\tcase \"field\":\n\t\tcase \"field-repetition\":\n\t\tcase \"component\":\n\t\tcase \"subcomponent\": return parent.children.indexOf(node) + 1;\n\t}\n}\n//#endregion\n//#region src/matches.ts\n/**\n* Whether `select(node, path)` finds a node.\n*\n* A step without `[n]` names the first such child, so `matches` is `false`\n* when that child does not lead to a match, even if a later one does.\n*\n* @example\n*   ```typescript\n*   if (matches(root, \"PID.5\")) {\n*     console.log(\"Patient has a name field\");\n*   }\n*\n*   if (!matches(root, \"OBX.5\")) {\n*     throw new Error(\"Missing observation value\");\n*   }\n*   ```;\n*\n* @param node - The message, group, or segment to read from\n* @param path - The HL7 path string\n* @returns True if the path resolves to a node, false otherwise\n*/\nfunction matches(node, path) {\n\treturn select(node, path) !== null;\n}\n//#endregion\nexport { QueryError, QueryErrorCode, delimiters, format, matches, parse, select, selectAll, value };\n\n//# sourceMappingURL=index.js.map","import type {\n  Component,\n  Delimiters,\n  Field,\n  FieldRepetition,\n  Group,\n  Nodes,\n  Root,\n  Segment,\n  Subcomponent,\n} from \"@glion/ast\";\nimport { delimiters as queryDelimiters } from \"@glion/util-query\";\nimport { DEFAULT_DELIMITERS } from \"@glion/utils\";\nimport type { Plugin } from \"unified\";\nimport type { Node } from \"unist\";\nimport type { VFile } from \"vfile\";\n\nexport interface Hl7v2ToHl7v2Options {\n  /** Append a field delimiter after the last field in each segment. */\n  trailingDelimiter?: boolean;\n}\n\n/**\n * Unified compiler plugin: HL7v2 AST → HL7v2 string.\n *\n * Reads `file.data.delimiters` if set by hl7v2-annotate-delimiters,\n * otherwise derives from MSH-1/MSH-2 via `delimiters()` for standalone use.\n */\nexport const hl7v2ToHl7v2: Plugin<[Hl7v2ToHl7v2Options?], Root, string> =\n  function hl7v2ToHl7v2(options?: Hl7v2ToHl7v2Options): void {\n    // biome-ignore lint/complexity/noUselessThisAlias: unified plugin shape\n    const self = this;\n    self.compiler = (tree: Node, file: VFile): string =>\n      toHl7v2(\n        tree as Nodes,\n        file.data.delimiters as Delimiters | undefined,\n        options\n      );\n  };\n\n/**\n * Serialize an HL7v2 AST node back to its wire format.\n *\n * Works on any node in the tree — a full Root, a single Segment, or\n * even a lone Field. Delimiters default to the standard set unless\n * overridden or derivable from an MSH segment in the tree.\n */\nexport function toHl7v2(\n  node: Nodes,\n  delimiters?: Partial<Delimiters>,\n  options?: Hl7v2ToHl7v2Options\n): string {\n  const d = {\n    ...(node.type === \"root\" ? queryDelimiters(node) : DEFAULT_DELIMITERS),\n    ...delimiters,\n  };\n  const trailing = options?.trailingDelimiter === true;\n\n  // -- leaf & field-level serializers (no options needed) ----------------\n\n  const sub = (s: Subcomponent): string => s.value ?? \"\";\n\n  const comp = (c: Component): string =>\n    ((c.children || []) as Subcomponent[]).map(sub).join(d.subcomponent);\n\n  const rep = (r: FieldRepetition): string =>\n    (r.children as Component[]).map(comp).join(d.component);\n\n  const field = (f: Field): string =>\n    (f.children as FieldRepetition[]).map(rep).join(d.repetition);\n\n  // -- segment-level serializers ----------------------------------------\n\n  const fields = (parts: string[]): string => {\n    const joined = parts.join(d.field);\n    return trailing && joined.length > 0 ? `${joined}${d.field}` : joined;\n  };\n\n  const segment = (seg: Segment): string => {\n    const body = fields(seg.children.map(field));\n    if (!seg.name) {\n      return body;\n    }\n    return body ? `${seg.name}${d.field}${body}` : seg.name;\n  };\n\n  // MSH-1 is the field separator itself — skip it and emit structurally.\n  const msh = (seg: Segment): string => {\n    const tail = fields(seg.children.slice(1).map(field));\n    return tail.length ? `MSH${d.field}${tail}` : `MSH${d.field}`;\n  };\n\n  const line = (seg: Segment): string =>\n    seg.name === \"MSH\" ? msh(seg) : segment(seg);\n\n  const lines = (nodes: readonly (Segment | Group)[]): string[] =>\n    nodes.flatMap((child) =>\n      child.type === \"group\" ? lines(child.children) : [line(child)]\n    );\n\n  // -- dispatch ----------------------------------------------------------\n\n  switch (node.type) {\n    case \"root\":\n    case \"group\": {\n      return lines(node.children as (Segment | Group)[]).join(d.segment);\n    }\n    case \"segment\": {\n      return line(node);\n    }\n    case \"field\": {\n      return field(node);\n    }\n    case \"field-repetition\": {\n      return rep(node);\n    }\n    case \"component\": {\n      return comp(node);\n    }\n    case \"subcomponent\": {\n      return sub(node);\n    }\n    default: {\n      const unsupported: never = node;\n      throw new Error(`Unsupported node type: ${(unsupported as Node).type}`);\n    }\n  }\n}\n"],"mappings":";;AAkBA,SAAS,SAAS,MAAM,MAAM;AAC7B,SAAQ,MAAR;EACC,KAAK,aAAc,QAAO;EAC1B,KAAK,eAAgB,QAAO,UAAU,KAAK;;;;AAI7C,IAAI,aAAa,cAAc,MAAM;CACpC,OAAO;CACP;CACA;CACA,YAAY,MAAM,MAAM;AACvB,QAAM,SAAS,MAAM,KAAK,CAAC;AAC3B,OAAK,OAAO;AACZ,OAAK,OAAO;;;;;;;;;;;;;;;AAiBd,MAAM,aAAa;AACnB,MAAM,wBAAwB;;AAE9B,MAAM,oBAAoB,IAAI,IAAI;CACjC,CAAC,gBAAgB;EAChB,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,gBAAgB;EAChB,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,gBAAgB;EAChB,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,gBAAgB;EAChB,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,gBAAgB;EAChB,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,kBAAkB;EAClB,WAAW;EACX,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,kBAAkB;EAClB,WAAW;EACX,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,kBAAkB;EAClB,WAAW;EACX,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,iBAAiB;EACjB,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,iBAAiB;EACjB,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC,mBAAmB;EACnB,WAAW;EACX,OAAO;EACP,SAAS,EAAE,MAAM,OAAO;EACxB,EAAE;CACH,CAAC;;;;;;;;;;;;;;;;;;;;;AAqBF,SAAS,MAAM,MAAM;CACpB,MAAM,cAAc,kBAAkB,IAAI,KAAK;AAC/C,KAAI,YAAa,QAAO,aAAa;AACrC,KAAI,SAAS,GAAI,OAAM,IAAI,WAAW,cAAc,KAAK;CACzD,MAAM,QAAQ,WAAW,KAAK,KAAK;AACnC,KAAI,CAAC,MAAO,OAAM,IAAI,WAAW,gBAAgB,KAAK;CACtD,MAAM,GAAG,aAAa,IAAI,OAAO,YAAY,WAAW,gBAAgB;CACxE,MAAM,QAAQ,EAAE;AAChB,MAAK,MAAM,GAAG,MAAM,aAAa,WAAW,SAAS,sBAAsB,CAAE,OAAM,KAAK,aAAa,KAAK,IAAI,EAAE,MAAM,GAAG;EACxH;EACA,YAAY,OAAO,SAAS;EAC5B,CAAC;CACF,MAAM,QAAQ,EAAE;CAChB,MAAM,UAAU,MAAM,KAAK;AAC3B,KAAI,YAAY,KAAK,EAAG,OAAM,UAAU;AACxC,KAAI,MAAM,SAAS,EAAG,OAAM,SAAS;AACrC,KAAI,UAAU,KAAK,EAAG,OAAM,QAAQ,OAAO,MAAM;AACjD,KAAI,eAAe,KAAK,EAAG,OAAM,aAAa,OAAO,WAAW;AAChE,KAAI,cAAc,KAAK,EAAG,OAAM,YAAY,OAAO,UAAU;AAC7D,KAAI,iBAAiB,KAAK,EAAG,OAAM,eAAe,OAAO,aAAa;AACtE,QAAO;;;AAKR,MAAM,SAAS,SAAS;AACvB,SAAQ,KAAK,MAAb;EACC,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,eAAgB;EACrB,KAAK,UAAW,QAAO,KAAK;EAC5B,KAAK,QAAS,QAAO,KAAK;;;;;;;AAO5B,SAAS,KAAK,UAAU,UAAU,OAAO;AACxC,KAAI,aAAa,KAAK,GAAG;EACxB,MAAM,QAAQ,SAAS,WAAW;AAClC,SAAO,UAAU,KAAK,IAAI,EAAE,GAAG,CAAC,MAAM;;AAEvC,QAAO,QAAQ,WAAW,SAAS,MAAM,GAAG,EAAE;;;;;;;AAO/C,SAAS,aAAa,QAAQ,MAAM,UAAU,OAAO;CACpD,MAAM,SAAS,EAAE;CACjB,MAAM,SAAS,YAAY;CAC3B,IAAI,QAAQ;AACZ,MAAK,MAAM,SAAS,OAAO,UAAU;AACpC,MAAI,MAAM,MAAM,KAAK,KAAM;AAC3B,MAAI,SAAS,aAAa,KAAK,GAAG;AACjC,UAAO,KAAK,MAAM;AAClB;;AAED,WAAS;AACT,MAAI,UAAU,OAAQ,QAAO,CAAC,MAAM;;AAErC,QAAO;;;AAGR,SAAS,QAAQ,QAAQ,MAAM,OAAO;CACrC,MAAM,OAAO,EAAE;AACf,MAAK,MAAM,SAAS,OAAQ,MAAK,MAAM,QAAQ,aAAa,MAAM,MAAM,KAAK,MAAM,KAAK,YAAY,MAAM,CAAE,MAAK,KAAK;EACrH,WAAW,CAAC,GAAG,MAAM,WAAW,MAAM,KAAK;EAC3C;EACA,CAAC;AACF,QAAO;;;;;;AAMR,SAAS,aAAa,SAAS,WAAW,aAAa,OAAO,OAAO;CACpE,MAAM,QAAQ,QAAQ,SAAS,cAAc;AAC7C,KAAI,CAAC,MAAO,QAAO,EAAE;CACrB,MAAM,iBAAiB,CAAC,GAAG,WAAW,QAAQ;AAC9C,KAAI,MAAM,eAAe,KAAK,KAAK,MAAM,cAAc,KAAK,EAAG,QAAO,CAAC;EACtE,WAAW;EACX,MAAM;EACN,CAAC;CACF,MAAM,UAAU,EAAE;AAClB,MAAK,MAAM,cAAc,KAAK,MAAM,YAAY,EAAE,EAAE,MAAM,YAAY,MAAM,EAAE;EAC7E,MAAM,sBAAsB,CAAC,GAAG,gBAAgB,MAAM;AACtD,MAAI,MAAM,cAAc,KAAK,GAAG;AAC/B,WAAQ,KAAK;IACZ,WAAW;IACX,MAAM;IACN,CAAC;AACF;;EAED,MAAM,YAAY,WAAW,WAAW,MAAM,YAAY;AAC1D,MAAI,CAAC,UAAW;EAChB,MAAM,qBAAqB,CAAC,GAAG,qBAAqB,WAAW;AAC/D,MAAI,MAAM,iBAAiB,KAAK,GAAG;AAClC,WAAQ,KAAK;IACZ,WAAW;IACX,MAAM;IACN,CAAC;AACF;;EAED,MAAM,eAAe,UAAU,WAAW,MAAM,eAAe;AAC/D,MAAI,aAAc,SAAQ,KAAK;GAC9B,WAAW,CAAC,GAAG,oBAAoB,UAAU;GAC7C,MAAM;GACN,CAAC;;AAEH,QAAO;;;;;;;;;;;;AAYR,SAAS,QAAQ,OAAO,OAAO,OAAO;CACrC,IAAI,SAAS,CAAC;EACb,WAAW,EAAE;EACb,MAAM;EACN,CAAC;AACF,MAAK,MAAM,SAAS,MAAM,UAAU,EAAE,CAAE,UAAS,QAAQ,QAAQ,OAAO,MAAM;AAC9E,KAAI,MAAM,YAAY,KAAK,EAAG,UAAS,QAAQ,QAAQ,MAAM,SAAS,MAAM;AAC5E,KAAI,MAAM,UAAU,KAAK,EAAG,QAAO;CACnC,MAAM,UAAU,EAAE;AAClB,MAAK,MAAM,EAAE,MAAM,eAAe,QAAQ;AACzC,MAAI,KAAK,SAAS,UAAW;AAC7B,OAAK,MAAM,SAAS,aAAa,MAAM,WAAW,MAAM,OAAO,OAAO,MAAM,CAAE,SAAQ,KAAK,MAAM;;AAElG,QAAO;;;;;;;;;;;;;;;;;;;;;;;AAyBR,SAAS,OAAO,MAAM,MAAM;CAC3B,MAAM,CAAC,SAAS,QAAQ,MAAM,MAAM,KAAK,EAAE,MAAM;AACjD,QAAO,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDjB,SAAS,MAAM,MAAM,MAAM;CAC1B,MAAM,WAAW,OAAO,MAAM,KAAK;AACnC,QAAO,WAAW,MAAM,SAAS,MAAM,SAAS,UAAU,GAAG;;;;;;;AAO9D,SAAS,MAAM,MAAM,WAAW;AAC/B,SAAQ,KAAK,MAAb;EACC,KAAK;EACL,KAAK;EACL,KAAK,UAAW,QAAO;EACvB,KAAK,eAAgB,QAAO;GAC3B;GACA;GACA,OAAO,KAAK;GACZ;EACD,KAAK;EACL,KAAK;EACL,KAAK,aAAa;GACjB,MAAM,QAAQ,KAAK,WAAW;AAC9B,UAAO,QAAQ,MAAM,OAAO,CAAC,GAAG,WAAW,KAAK,CAAC,GAAG;IACnD;IACA;IACA,OAAO;IACP;;;;;AAOJ,MAAM,YAAY;CACjB;CACA;CACA;CACA;CACA;;;;;;;;;;;;;AAaD,SAAS,WAAW,MAAM;CACzB,MAAM,SAAS,EAAE,GAAG,oBAAoB;CACxC,MAAM,OAAO,MAAM,MAAM,QAAQ,EAAE;AACnC,KAAI,QAAQ,KAAK,WAAW,EAAG,QAAO,QAAQ;CAC9C,MAAM,OAAO,MAAM,MAAM,QAAQ,EAAE;AACnC,KAAI,MAAM;EACT,MAAM,QAAQ,CAAC,GAAG,KAAK;AACvB,OAAK,MAAM,CAAC,GAAG,QAAQ,UAAU,SAAS,EAAE;GAC3C,MAAM,KAAK,MAAM;AACjB,OAAI,GAAI,QAAO,OAAO;;;AAGxB,QAAO;;;;;;;;;;AC7XR,MAAa,eACX,SAAS,aAAa,SAAqC;CAEzD,MAAM,OAAO;AACb,MAAK,YAAY,MAAY,SAC3B,QACE,MACA,KAAK,KAAK,YACV,QACD;;;;;;;;;AAUP,SAAgB,QACd,MACA,cACA,SACQ;CACR,MAAM,IAAI;EACR,GAAI,KAAK,SAAS,SAASA,WAAgB,KAAK,GAAG;EACnD,GAAGC;EACJ;CACD,MAAM,WAAW,SAAS,sBAAsB;CAIhD,MAAM,OAAO,MAA4B,EAAE,SAAS;CAEpD,MAAM,QAAQ,OACV,EAAE,YAAY,EAAE,EAAqB,IAAI,IAAI,CAAC,KAAK,EAAE,aAAa;CAEtE,MAAM,OAAO,MACV,EAAE,SAAyB,IAAI,KAAK,CAAC,KAAK,EAAE,UAAU;CAEzD,MAAM,SAAS,MACZ,EAAE,SAA+B,IAAI,IAAI,CAAC,KAAK,EAAE,WAAW;CAI/D,MAAM,UAAU,UAA4B;EAC1C,MAAM,SAAS,MAAM,KAAK,EAAE,MAAM;AAClC,SAAO,YAAY,OAAO,SAAS,IAAI,GAAG,SAAS,EAAE,UAAU;;CAGjE,MAAM,WAAW,QAAyB;EACxC,MAAM,OAAO,OAAO,IAAI,SAAS,IAAI,MAAM,CAAC;AAC5C,MAAI,CAAC,IAAI,KACP,QAAO;AAET,SAAO,OAAO,GAAG,IAAI,OAAO,EAAE,QAAQ,SAAS,IAAI;;CAIrD,MAAM,OAAO,QAAyB;EACpC,MAAM,OAAO,OAAO,IAAI,SAAS,MAAM,EAAE,CAAC,IAAI,MAAM,CAAC;AACrD,SAAO,KAAK,SAAS,MAAM,EAAE,QAAQ,SAAS,MAAM,EAAE;;CAGxD,MAAM,QAAQ,QACZ,IAAI,SAAS,QAAQ,IAAI,IAAI,GAAG,QAAQ,IAAI;CAE9C,MAAM,SAAS,UACb,MAAM,SAAS,UACb,MAAM,SAAS,UAAU,MAAM,MAAM,SAAS,GAAG,CAAC,KAAK,MAAM,CAAC,CAC/D;AAIH,SAAQ,KAAK,MAAb;EACE,KAAK;EACL,KAAK,QACH,QAAO,MAAM,KAAK,SAAgC,CAAC,KAAK,EAAE,QAAQ;EAEpE,KAAK,UACH,QAAO,KAAK,KAAK;EAEnB,KAAK,QACH,QAAO,MAAM,KAAK;EAEpB,KAAK,mBACH,QAAO,IAAI,KAAK;EAElB,KAAK,YACH,QAAO,KAAK,KAAK;EAEnB,KAAK,eACH,QAAO,IAAI,KAAK;EAElB,QAEE,OAAM,IAAI,MAAM,0BAA2BC,KAAqB,OAAO"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glion/to-hl7v2",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "hl7v2 plugin to transform hl7v2 messages to a hl7v2. Useful for sanitizing messages.",
   "keywords": [
     "health",
@@ -36,7 +36,7 @@
     "unified": "11.0.5",
     "unist-util-visit": "5.1.0",
     "unist-util-visit-parents": "6.0.2",
-    "@glion/utils": "0.26.0"
+    "@glion/utils": "0.27.0"
   },
   "devDependencies": {
     "@stryker-mutator/core": "10.0.0",
@@ -50,12 +50,12 @@
     "unist-builder": "^4.0.0",
     "vfile": "^6.0.3",
     "vitest": "4.1.11",
-    "@glion/ast": "0.26.0",
-    "@glion/builder": "0.26.0",
-    "@glion/testing": "0.18.0",
+    "@glion/ast": "0.27.0",
+    "@glion/builder": "0.27.0",
     "@glion/check-readme": "0.18.0",
-    "@glion/tsconfig": "0.18.0",
-    "@glion/util-query": "0.26.0"
+    "@glion/testing": "0.18.0",
+    "@glion/util-query": "0.27.0",
+    "@glion/tsconfig": "0.18.0"
   },
   "engines": {
     "node": ">=22"