@glion/util-visit 0.26.0 → 0.27.1

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/README.md

@@ -1,10 +1,10 @@
 # @glion/util-visit
 
-Visitor for traversing HL7v2 AST trees with ancestor context, depth, and HL7v2-aware sequence numbers.
+Visitor for traversing HL7v2 AST trees with ancestor context.
 
 ## What it does
 
-Walks an HL7v2 AST from any starting node — Root, Segment, Field, Component, or Subcomponent — calling a visitor function for each matching node. Each call receives the node, its ancestors (root-to-parent), and a `VisitInfo` record with index, HL7v2 sequence number, depth, and extracted metadata. Supports filtering by type string, property object, or predicate, and exposes `SKIP`/`EXIT` control actions. Delegates core traversal to `unist-util-visit-parents`.
+Walks an HL7v2 AST from any starting node — Root, Group, Segment, Field, Component, or Subcomponent — calling a visitor function for each matching node with the node and its ancestors, from the node the walk starts at to the node's parent. Supports filtering by type string, property object, or predicate, and exposes `SKIP`/`EXIT` control actions. Visits in the same order, and reads a visitor's result the same way, as `unist-util-visit-parents`, with types from `@glion/ast`.
 
 ## Install
 
@@ -15,25 +15,21 @@ npm install @glion/util-visit
 ## Use
 
 ```typescript
-import { visit, EXIT, SKIP } from "@glion/util-visit";
-import { parse } from "@glion/parser";
+import { parseHL7v2 } from "@glion/parser";
+import { SKIP, visit } from "@glion/util-visit";
 
-const message = parse("MSH|^~\\&|...\rPID|...");
-
-// Visit all segments
-visit(message, "segment", (node, ancestors, info) => {
-  console.log(`Segment: ${info.metadata?.header} at depth ${info.depth}`);
-});
+const tree = parseHL7v2(
+  "MSH|^~\\&|LAB|FAC|EMR|RFAC|20250601120000||ORU^R01^ORU_R01|MSG00001|P|2.5\rPID|1||12345\rNTE|1||note"
+);
 
-// Find fields with parent context
-visit(message, "field", (node, ancestors, info) => {
-  const segment = ancestors.find((n) => n.type === "segment");
-  console.log(`Field ${info.sequence} in segment`);
+// Visit every segment
+visit(tree, "segment", (segment) => {
+  console.log(segment.name); // "MSH", "PID", "NTE"
 });
 
-// Skip processing of sensitive segments
-visit(message, (node, ancestors, info) => {
-  if (node.type === "segment" && info.metadata?.header === "NTE") {
+// Skip the fields of NTE segments
+visit(tree, (node) => {
+  if (node.type === "segment" && node.name === "NTE") {
     return SKIP;
   }
 });
@@ -45,14 +41,14 @@ visit(message, (node, ancestors, info) => {
 
 ### `visit(tree, test, visitor)`
 
-Visit nodes in an HL7v2 AST tree.
+Visit nodes in an HL7v2 AST tree, in document order.
 
 #### Parameters
 
 - `tree` (`Nodes`) — Tree to traverse. Can be any node type, not just `Root`.
 - `test` (`string | Partial<Nodes> | Test`, optional) — Filter:
   - `string` — Match nodes by type (e.g., `"segment"`).
-  - `Partial<Nodes>` — Match nodes whose own properties equal (`===`) each value (e.g., `{ name: "PATIENT_GROUP" }`). A property the node does not own reads as `undefined`: an `undefined` value matches an absent property, and a key naming an inherited member (`constructor`, `toString`) matches no node.
+  - `Partial<Nodes>` — Match nodes whose own properties equal (`===`) each value (e.g., `{ id: "PATIENT" }`). A property the node does not own reads as `undefined`: an `undefined` value matches an absent property, and a key naming an inherited member (`constructor`, `toString`) matches no node.
   - `Test` — Custom function `(node, ancestors) => boolean`.
 - `visitor` (`Visitor`) — Function called for each matching node.
 
@@ -60,23 +56,18 @@ Visit nodes in an HL7v2 AST tree.
 
 `void`.
 
-#### Important: test vs visitor functions
+#### Test vs visitor functions
 
-**If you pass a function as the second argument, it is always treated as a Visitor, never as a Test.**
+A function passed as the second argument is always the visitor, never a test. A test function needs the three-argument form:
 
 ```typescript
-// WRONG — testFn will be treated as a visitor, not a test
-visit(ast, (node) => node.type === 'segment', ...); // Missing visitor!
-
-// CORRECT — Explicit 3-argument form
-visit(ast, (node) => node.type === 'segment', (node, ancestors, info) => {
-  console.log('Visiting segment');
-});
-
-// CORRECT — Use string or object for simple tests
-visit(ast, 'segment', (node, ancestors, info) => {
-  console.log('Visiting segment');
-});
+visit(
+  tree,
+  (node) => node.type === "segment",
+  (segment) => {
+    console.log(segment.type); // "segment"
+  }
+);
 ```
 
 #### Visitor function
@@ -84,290 +75,106 @@ visit(ast, 'segment', (node, ancestors, info) => {
 ```typescript
 type Visitor<T extends Nodes = Nodes> = (
   node: T,
-  ancestors: Nodes[],
-  info: VisitInfo
+  ancestors: Nodes[]
 ) => VisitorResult;
 ```
 
 The visitor receives:
 
 - `node` — Current AST node.
-- `ancestors` — Array of ancestor nodes from root to parent (not including current node).
-- `info` — Visit information with index, sequence, depth, and metadata.
+- `ancestors` — Ancestor nodes from the node the walk starts at to the parent, not including the current node. Empty for the starting node.
 
 The visitor can return:
 
-- `undefined` or `void` — Continue traversal normally.
-- `SKIP` — Skip children of current node.
-- `EXIT` — Stop traversal immediately.
-
-### `VisitInfo`
-
-```typescript
-interface VisitInfo {
-  /** 0-based index among the parent's children when the node is visited */
-  index: number;
-
-  /** `index` + 1, the HL7v2 sequence number */
-  sequence: number;
-
-  /** 1-based depth in tree (root = 1) */
-  depth: number;
-
-  /** Metadata (e.g., { name: "MSH" } or { name: "PATIENT" }) */
-  metadata: Record<string, unknown> | undefined;
-}
-```
-
-`index` and `sequence` represent the node's **position in the tree**, not its position among filtered results:
+- `undefined` or `CONTINUE` — Continue traversal, into the node's children.
+- `SKIP` — Skip the children of the current node.
+- `EXIT` — Stop traversal.
+- An index — Continue at that index among the current node's siblings.
+- `[action, index]` — Both.
 
-```typescript
-// Structure: MSH segment with fields at positions 1, 2, 3, 4
-// Filter matches only field 3
-visit(
-  ast,
-  (n) => n.type === "field" && hasContent(n),
-  (node, ancestors, info) => {
-    console.log(info.sequence); // 3 (position in segment, not "1st match")
-  }
-);
-```
-
-This is correct because HL7v2 paths like `PID.3` refer to tree positions, not filtered positions.
-
-The position is read when the node is visited, so it reflects siblings a visitor inserted or removed earlier in the same visit. A visitor that removes the current node can return `info.index` to continue with the sibling that moved into its place:
+A visitor that removes the current node returns its former index to continue with the sibling that moved into its place:
 
 ```typescript
-visit(segment, "field", (node, ancestors, info) => {
-  if (isEmptyNode(node)) {
-    ancestors.at(-1).children.splice(info.index, 1);
-    return info.index;
-  }
+visit(tree, { type: "segment", name: "NTE" }, (segment, ancestors) => {
+  const parent = ancestors.at(-1) as Root | Group;
+  const index = parent.children.indexOf(segment);
+  parent.children.splice(index, 1);
+  return index;
 });
 ```
 
-### Automatic metadata extraction
-
-The `metadata` field is populated automatically:
-
-| Node type | Metadata key | Description                                 |
-| --------- | ------------ | ------------------------------------------- |
-| `segment` | `header`     | Segment identifier (e.g., `"MSH"`, `"PID"`) |
-| `group`   | `name`       | Group name (e.g., `"PATIENT_GROUP"`)        |
+`indexOf` scans the parent's children, so removing many children of one parent this way costs time in the square of their number. To remove many, filter `parent.children` once from the parent's visitor instead.
 
 ### Exports
 
 ```typescript
 import {
-  visit, // Main traversal function
+  visit, // Traversal function
   EXIT, // Return to stop traversal
   SKIP, // Return to skip children
 } from "@glion/util-visit";
 
 import type {
-  VisitInfo, // { index, sequence, depth, metadata }
-  Visitor, // (node, ancestors, info) => VisitorResult
-  VisitorResult, // Return type from visitor
-  Test, // Filter predicate
+  Visitor, // (node, ancestors) => VisitorResult
+  VisitorResult, // Return type of a visitor
+  Test, // Filter: type string, property object, predicate, or null
   Predicate, // (node, ancestors) => boolean
 } from "@glion/util-visit";
 ```
 
 ## Examples
 
-### Filter by node type
-
-```typescript
-visit(ast, "segment", (node, ancestors, info) => {
-  console.log(`Found segment: ${info.metadata?.header}`);
-});
-```
-
 ### Filter by properties
 
 ```typescript
-visit(ast, { name: "PATIENT_GROUP" }, (node, ancestors, info) => {
-  console.log("Inside PATIENT_GROUP");
+// A group's `id` is its key in paths; its `name` is the title for display
+visit(tree, { type: "group", id: "PATIENT" }, (group) => {
+  console.log(group.name); // "Patient"
 });
 ```
 
-### Custom test function
+### Read the ancestors
 
 ```typescript
-// Visit fields in MSH segment only
-visit(
-  ast,
-  (node, ancestors) => {
-    const parent = ancestors.at(-1);
-    return node.type === "field" && parent?.type === "segment";
-  },
-  (node, ancestors, info) => {
-    console.log(`Field at sequence ${info.sequence}`);
-  }
-);
-```
-
-### Access parent and ancestors
-
-```typescript
-visit(ast, "component", (node, ancestors, info) => {
-  const parent = ancestors.at(-1);
-  const segment = ancestors.findLast((n) => n.type === "segment");
-  console.log(`Component at depth ${info.depth}`);
+visit(tree, "component", (component, ancestors) => {
+  const parent = ancestors.at(-1); // the field repetition
+  const segment = ancestors.findLast((node) => node.type === "segment");
 });
 ```
 
-### Control flow: skip children
+### Read the segment groups above a segment
 
 ```typescript
-visit(ast, (node, ancestors, info) => {
-  if (node.type === "segment" && info.metadata?.header === "OBX") {
-    return SKIP; // Don't process OBX segment children
-  }
+visit(tree, "segment", (segment, ancestors) => {
+  const groups = ancestors
+    .filter((node): node is Group => node.type === "group")
+    .map((group) => group.id);
+  console.log(`${segment.name}: ${groups.join(" > ")}`); // "PID: PATIENT_RESULT > PATIENT"
 });
 ```
 
-### Control flow: exit early
+### Stop at the first match
 
 ```typescript
 import { EXIT } from "@glion/util-visit";
 
-let found = false;
-visit(ast, "field", (node, ancestors, info) => {
-  if (/* some condition */) {
-    found = true;
-    return EXIT; // Stop traversal completely
-  }
+let first: Segment | undefined;
+visit(tree, { type: "segment", name: "OBX" }, (segment) => {
+  first = segment as Segment;
+  return EXIT;
 });
 ```
 
 ### Start from any node
 
 ```typescript
-import { s, f, c } from "@glion/builder";
+import { c, f, s } from "@glion/builder";
 
-// Create a standalone segment
 const segment = s("PID", f(c("value1")), f(c("value2")));
 
-// Traverse from segment (not root)
-visit(segment, "field", (node, ancestors, info) => {
-  console.log(`Field at sequence ${info.sequence}`);
-});
-```
-
-### Track nesting levels
-
-```typescript
-visit(ast, (node, ancestors, info) => {
-  const indent = "  ".repeat(info.depth - 1);
-  console.log(`${indent}${node.type} [${info.sequence}]`);
+visit(segment, "field", (field, ancestors) => {
+  console.log(ancestors.length); // 1: the segment
 });
-// root [1]
-//   segment [1]
-//     segment-header [0]
-//     field [1]
-//       field-repetition [1]
-//         component [1]
-```
-
-### Group hierarchy navigation
-
-```typescript
-visit(ast, "segment", (node, ancestors, info) => {
-  const groups = ancestors
-    .filter((n) => n.type === "group")
-    .map((n) => (n as any).name)
-    .filter((name): name is string => typeof name === "string");
-
-  console.log(`${info.metadata?.header} is in groups: ${groups.join(" > ")}`);
-});
-// PID is in groups: PATIENT_GROUP
-```
-
-### Validate required fields
-
-```typescript
-function validateRequiredFields(ast: Root): string[] {
-  const errors: string[] = [];
-
-  visit(ast, "segment", (node, ancestors, info) => {
-    const segment = node as Segment;
-    const header = info.metadata?.header;
-
-    if (header === "MSH" && segment.children.length < 12) {
-      errors.push("MSH segment missing required fields");
-    }
-
-    if (header === "PID") {
-      const patientId = segment.children[3];
-      if (!patientId || patientId.children.length === 0) {
-        errors.push("PID segment missing required Patient ID (PID.3)");
-      }
-    }
-  });
-
-  return errors;
-}
-```
-
-### Extract data with context
-
-```typescript
-interface PatientName {
-  name: string;
-  sequence: number;
-  inGroup?: string;
-}
-
-function extractPatientNames(ast: Root): PatientName[] {
-  const names: PatientName[] = [];
-
-  visit(ast, "segment", (node, ancestors, info) => {
-    if (info.metadata?.header !== "PID") return;
-
-    const segment = node as Segment;
-    const nameField = segment.children[5];
-    if (nameField?.children[0]?.children[0]) {
-      const nameComponent = nameField.children[0].children[0];
-      const name = (nameComponent.children[0] as Subcomponent)?.value || "";
-      const groupAncestor = ancestors.find(
-        (n): n is Group => n.type === "group"
-      );
-
-      names.push({
-        name,
-        sequence: info.sequence,
-        inGroup: groupAncestor?.name,
-      });
-    }
-  });
-
-  return names;
-}
-```
-
-### Find first match and exit
-
-```typescript
-function findFirstObservation(ast: Root, targetCode: string): string | null {
-  let result: string | null = null;
-
-  visit(ast, "segment", (node, ancestors, info) => {
-    if (info.metadata?.header !== "OBX") return;
-
-    const segment = node as Segment;
-    const identifierField = segment.children[3];
-    const code = identifierField?.children[0]?.children[0]?.children[0]?.value;
-
-    if (code === targetCode) {
-      const valueField = segment.children[5];
-      result = valueField?.children[0]?.children[0]?.children[0]?.value || null;
-      return EXIT;
-    }
-  });
-
-  return result;
-}
 ```
 
 ## Part of Glion

package/dist/index.d.ts

@@ -1,14 +1,14 @@
 /**
- * HL7v2 AST Visitor
+ * HL7v2 AST visitor, typed for `@glion/ast`, with the semantics of
+ * `unist-util-visit-parents`.
  *
- * Wraps unist-util-visit-parents to add HL7v2-specific context
- * (index, sequence, depth, metadata) while delegating core traversal.
+ * @module
  */
 import type { Nodes } from "@glion/ast";
 import type { Test, Visitor } from "./types";
 export type { VisitorResult } from "unist-util-visit-parents";
 export { EXIT, SKIP } from "unist-util-visit-parents";
-export type { Predicate, Test, VisitInfo, Visitor } from "./types";
+export type { Predicate, Test, Visitor } from "./types";
 export declare function visit(tree: Nodes, visitor: Visitor): void;
 export declare function visit<Type extends Nodes["type"]>(tree: Nodes, test: Type, visitor: Visitor<Extract<Nodes, {
     type: Type;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC,OAAO,KAAK,EAAE,IAAI,EAAa,OAAO,EAAE,MAAM,SAAS,CAAC;AAGxD,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAEtD,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGnE,wBAAgB,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;AAC3D,wBAAgB,KAAK,CAAC,IAAI,SAAS,KAAK,CAAC,MAAM,CAAC,EAC9C,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,GAC/C,IAAI,CAAC;AACR,wBAAgB,KAAK,CAAC,CAAC,SAAS,KAAK,EACnC,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAClB,IAAI,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAIxC,OAAO,KAAK,EAAa,IAAI,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGxD,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAEtD,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGxD,wBAAgB,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;AAC3D,wBAAgB,KAAK,CAAC,IAAI,SAAS,KAAK,CAAC,MAAM,CAAC,EAC9C,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,GAC/C,IAAI,CAAC;AACR,wBAAgB,KAAK,CAAC,CAAC,SAAS,KAAK,EACnC,IAAI,EAAE,KAAK,EACX,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EACb,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAClB,IAAI,CAAC"}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { EXIT, SKIP, visitParents } from "unist-util-visit-parents";
+import { EXIT, EXIT as EXIT$1, SKIP, SKIP as SKIP$1 } from "unist-util-visit-parents";
 //#region src/utils.ts
 /**
 * The predicate a `visit` test describes.
@@ -46,18 +46,35 @@ function createTest(test) {
 //#endregion
 //#region src/index.ts
 /**
-* Visit nodes in an HL7 AST tree.
-* Wraps unist-util-visit-parents to add HL7v2-specific context.
+* Visits `tree` and every node below it, depth-first and in document order,
+* calling `visitor` with each node that passes `test` and that node's
+* ancestors.
 *
-* @param tree - The tree to traverse (can be any node type, not just Root)
-* @param test - Optional test to filter nodes (type string, partial match, or
-*   Test function)
-* @param visitor - Function called for each matching node
+* `test` is a node type (`"segment"`), an object whose own properties a node
+* must equal (`{ name: "PID" }`), or a function of `(node, ancestors)`. With no
+* test, every node passes. A function passed as the second argument is always
+* the visitor; a test function needs the three-argument form.
 *
-*   **Important**: If you pass a function as the second argument, it is always
-*   treated as a Visitor, never as a Test. To use a Test function, you MUST
-*   provide both the test and visitor parameters: `visit(tree, testFn,
-*   visitorFn)`.
+* The visitor's result decides what the walk does next:
+*
+* - Nothing: enter the node's children, then go on.
+* - `SKIP`: do not enter the node's children.
+* - `EXIT`: stop the whole walk.
+* - A number: go on at that index among the node's siblings, after the visitor
+*   removed or inserted siblings. `[action, index]` combines both.
+*
+* `ancestors` runs from `tree` to the node's parent. Siblings share one array:
+* a visitor MUST NOT change it, and MAY keep it, since a later visit never
+* changes it either.
+*
+* With a type test, the walk does not enter a node that cannot contain that
+* type in an HL7v2 tree (Root → Group → Segment → Field → FieldRepetition →
+* Component → Subcomponent): `visit(tree, "segment", …)` never enters a
+* segment. Nodes of a type `@glion/ast` does not define are always entered.
+*
+* @param tree - The node the walk starts at, of any type.
+* @param test - Which nodes the visitor is called with.
+* @param visitor - Called with each node that passes `test`.
 */
 function visit(tree, arg2, arg3) {
 	let test = null;
@@ -67,23 +84,52 @@ function visit(tree, arg2, arg3) {
 		test = arg2;
 		visitor = arg3;
 	}
-	const predicate = createTest(test);
-	let currentIndex = 0;
-	const captureIndex = (_node, index) => {
-		currentIndex = index ?? 0;
-		return true;
-	};
-	visitParents(tree, captureIndex, (node, ancestors) => {
-		if (!predicate(node, ancestors)) return;
-		const info = {
-			depth: ancestors.length + 1,
-			index: currentIndex,
-			metadata: "name" in node ? { name: node.name } : void 0,
-			sequence: currentIndex + 1
-		};
-		return visitor(node, ancestors, info);
+	walk(tree, [], {
+		predicate: createTest(test),
+		unmatchableBelow: UNMATCHABLE_BELOW.get(test),
+		visitor
 	});
 }
+/**
+* The depth of each `@glion/ast` node type in an HL7v2 tree. A group may hold
+* groups, so it is the one type found below its own depth.
+*/
+const DEPTH = new Map([
+	["root", 0],
+	["group", 1],
+	["segment", 2],
+	["field", 3],
+	["field-repetition", 4],
+	["component", 5],
+	["subcomponent", 6]
+]);
+/**
+* For each node type, the node types whose children cannot include a node of
+* that type. Any other test, such as an object or a function, finds nothing.
+*/
+const UNMATCHABLE_BELOW = new Map([...DEPTH].map(([type, depth]) => [type, new Set([...DEPTH].filter(([parent, parentDepth]) => parentDepth >= depth && !(parent === "group" && type === "group")).map(([parent]) => parent))]));
+/**
+* Visits `node`, then its children in order, and returns the visitor's result
+* for `node`, or the first EXIT a descendant's visitor returns.
+*
+* Reads `children` after the visitor runs, and again after each child, so a
+* visitor may change its own children or its parent's.
+*/
+function walk(node, ancestors, context) {
+	const result = context.predicate(node, ancestors) ? context.visitor(node, ancestors) : void 0;
+	const action = Array.isArray(result) ? result[0] : result;
+	if (action === EXIT$1 || action === SKIP$1 || !("children" in node) || context.unmatchableBelow?.has(node.type)) return result;
+	const childAncestors = [...ancestors, node];
+	let index = 0;
+	while (index < node.children.length) {
+		const child = node.children[index];
+		const childResult = walk(child, childAncestors, context);
+		if ((Array.isArray(childResult) ? childResult[0] : childResult) === EXIT$1) return childResult;
+		const next = Array.isArray(childResult) ? childResult[1] : childResult;
+		index = typeof next === "number" ? next : index + 1;
+	}
+	return result;
+}
 //#endregion
 export { EXIT, SKIP, visit };
 

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/utils.ts","../src/index.ts"],"sourcesContent":["import type { Nodes } from \"@glion/ast\";\n\nimport type { Predicate, Test } from \"./types\";\n\n/**\n * The predicate a `visit` test describes.\n *\n * - `null` matches every node.\n * - A string matches nodes whose `type` equals it.\n * - A function is the predicate.\n * - An object matches nodes whose own property equals (`===`) each of its values.\n *   A property the node does not own reads as `undefined`, so an `undefined`\n *   value matches an absent property, and a key that names an inherited member\n *   (`constructor`, `toString`, an own `__proto__`) matches no node. The\n *   object's entries are read once, when the predicate is created.\n *\n * @example\n *   ```typescript\n *   const msh = s(\"MSH\", f(\"|\"));\n *\n *   createTest(null)(msh, []); // true\n *   createTest(\"segment\")(msh, []); // true\n *   createTest(\"field\")(msh, []); // false\n *\n *   createTest({ type: \"segment\", name: \"MSH\" })(msh, []); // true\n *   createTest({ name: \"PID\" })(msh, []); // false\n *\n *   // `undefined` matches a property the node does not have\n *   createTest({ name: undefined })(f(\"|\"), []); // true\n *\n *   // An inherited member is never matched\n *   createTest({ constructor: Object })(msh, []); // false\n *\n *   // A function receives the ancestors as well\n *   const inGroup = createTest((_node, ancestors) => ancestors.length > 1);\n *   ```;\n *\n * @param test - `null`, a node type, a property object, or a predicate.\n * @returns The predicate.\n */\nexport function createTest(test: Test<Nodes>): Predicate {\n  if (test === null) {\n    return () => true;\n  }\n  if (typeof test === \"string\") {\n    return (node) => node.type === test;\n  }\n  if (typeof test === \"function\") {\n    // Used as is: `visit` calls it with `(node, ancestors)`, so it may match on\n    // a node's position in the tree as well as on the node itself.\n    return test;\n  }\n\n  // Read once here rather than per visited node: a visit calls the predicate\n  // for every node, and a test object changed during the visit does not change\n  // which nodes match.\n  const entries = Object.entries(test);\n\n  return (node) =>\n    entries.every(\n      ([key, value]) =>\n        // `Object.hasOwn` limits the match to the node's own properties. Without\n        // it, `node[key]` also finds inherited members, so `{ constructor: x }`\n        // or `{ toString: x }` would be compared against `Object.prototype`.\n        // `Reflect.get(node, key)` is `node[key]`; it compiles for an arbitrary\n        // string key, which `Nodes` (no index signature) does not allow.\n        (Object.hasOwn(node, key) ? Reflect.get(node, key) : undefined) ===\n        value\n    );\n}\n","/**\n * HL7v2 AST Visitor\n *\n * Wraps unist-util-visit-parents to add HL7v2-specific context\n * (index, sequence, depth, metadata) while delegating core traversal.\n */\n\nimport type { Nodes } from \"@glion/ast\";\nimport { visitParents } from \"unist-util-visit-parents\";\n\nimport type { Test, VisitInfo, Visitor } from \"./types\";\nimport { createTest } from \"./utils\";\n\nexport type { VisitorResult } from \"unist-util-visit-parents\";\n\nexport { EXIT, SKIP } from \"unist-util-visit-parents\";\n\nexport type { Predicate, Test, VisitInfo, Visitor } from \"./types\";\n\n// Overload signatures\nexport function visit(tree: Nodes, visitor: Visitor): void;\nexport function visit<Type extends Nodes[\"type\"]>(\n  tree: Nodes,\n  test: Type,\n  visitor: Visitor<Extract<Nodes, { type: Type }>>\n): void;\nexport function visit<T extends Nodes>(\n  tree: Nodes,\n  test: Test<T>,\n  visitor: Visitor<T>\n): void;\n\n/**\n * Visit nodes in an HL7 AST tree.\n * Wraps unist-util-visit-parents to add HL7v2-specific context.\n *\n * @param tree - The tree to traverse (can be any node type, not just Root)\n * @param test - Optional test to filter nodes (type string, partial match, or\n *   Test function)\n * @param visitor - Function called for each matching node\n *\n *   **Important**: If you pass a function as the second argument, it is always\n *   treated as a Visitor, never as a Test. To use a Test function, you MUST\n *   provide both the test and visitor parameters: `visit(tree, testFn,\n *   visitorFn)`.\n */\nexport function visit<T extends Nodes>(\n  tree: Nodes,\n  arg2: Visitor<T> | Test<T>,\n  arg3?: Visitor<T>\n): void {\n  let test: Test<T> = null;\n  let visitor: Visitor<T>;\n\n  if (arg3 === undefined) {\n    visitor = arg2 as Visitor<T>;\n  } else {\n    test = arg2 as Test<T>;\n    visitor = arg3;\n  }\n\n  const predicate = createTest(test as Test<Nodes>);\n\n  // visit-parents passes a node's index among its parent's children only to\n  // its test, `test(node, index, parent)`, never to its visitor. It calls the\n  // test and, when the test passes, the visitor on that same node with nothing\n  // in between (unist-util-visit-parents 6.0.2, lib/index.js; the version is\n  // pinned). `captureIndex` is that test: it stores the index for the visitor\n  // to read and passes every node. The index is the node's position when it\n  // is visited, so it reflects siblings a visitor inserted or removed earlier.\n  let currentIndex = 0;\n  const captureIndex = (_node: unknown, index?: number): boolean => {\n    // The node `visit` starts from has no parent, so it has no index.\n    currentIndex = index ?? 0;\n    return true;\n  };\n\n  visitParents(tree, captureIndex, (node, ancestors) => {\n    // The caller's test runs here, not in `captureIndex`: it may read\n    // `ancestors`, which visit-parents gives only to the visitor.\n    if (!predicate(node, ancestors)) {\n      // Returning nothing means \"continue\": visit-parents still walks into\n      // this node's children, so `visit(tree, \"field\", …)` reaches the fields\n      // of segments it does not match.\n      return;\n    }\n\n    const info: VisitInfo = {\n      depth: ancestors.length + 1,\n      index: currentIndex,\n      metadata: \"name\" in node ? { name: node.name } : undefined,\n      sequence: currentIndex + 1,\n    };\n\n    // visit-parents reads the visitor's return value to decide what to visit\n    // next, so the caller's result is passed through unchanged:\n    // - nothing or CONTINUE: walk into this node's children;\n    // - SKIP: skip this node's children;\n    // - EXIT: stop the walk;\n    // - a number: continue at that index among this node's siblings, as after\n    //   removing the current node with `splice(info.index, 1)`;\n    // - [action, index]: both.\n    // Calling the visitor without returning its result would turn every one\n    // of these into \"continue\".\n    return visitor(node as T, ancestors, info);\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,WAAW,MAA8B;AACvD,KAAI,SAAS,KACX,cAAa;AAEf,KAAI,OAAO,SAAS,SAClB,SAAQ,SAAS,KAAK,SAAS;AAEjC,KAAI,OAAO,SAAS,WAGlB,QAAO;CAMT,MAAM,UAAU,OAAO,QAAQ,KAAK;AAEpC,SAAQ,SACN,QAAQ,OACL,CAAC,KAAK,YAMJ,OAAO,OAAO,MAAM,IAAI,GAAG,QAAQ,IAAI,MAAM,IAAI,GAAG,KAAA,OACrD,MACH;;;;;;;;;;;;;;;;;;ACtBL,SAAgB,MACd,MACA,MACA,MACM;CACN,IAAI,OAAgB;CACpB,IAAI;AAEJ,KAAI,SAAS,KAAA,EACX,WAAU;MACL;AACL,SAAO;AACP,YAAU;;CAGZ,MAAM,YAAY,WAAW,KAAoB;CASjD,IAAI,eAAe;CACnB,MAAM,gBAAgB,OAAgB,UAA4B;AAEhE,iBAAe,SAAS;AACxB,SAAO;;AAGT,cAAa,MAAM,eAAe,MAAM,cAAc;AAGpD,MAAI,CAAC,UAAU,MAAM,UAAU,CAI7B;EAGF,MAAM,OAAkB;GACtB,OAAO,UAAU,SAAS;GAC1B,OAAO;GACP,UAAU,UAAU,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,KAAA;GACjD,UAAU,eAAe;GAC1B;AAYD,SAAO,QAAQ,MAAW,WAAW,KAAK;GAC1C"}
+{"version":3,"file":"index.js","names":["EXIT","SKIP"],"sources":["../src/utils.ts","../src/index.ts"],"sourcesContent":["import type { Nodes } from \"@glion/ast\";\n\nimport type { Predicate, Test } from \"./types\";\n\n/**\n * The predicate a `visit` test describes.\n *\n * - `null` matches every node.\n * - A string matches nodes whose `type` equals it.\n * - A function is the predicate.\n * - An object matches nodes whose own property equals (`===`) each of its values.\n *   A property the node does not own reads as `undefined`, so an `undefined`\n *   value matches an absent property, and a key that names an inherited member\n *   (`constructor`, `toString`, an own `__proto__`) matches no node. The\n *   object's entries are read once, when the predicate is created.\n *\n * @example\n *   ```typescript\n *   const msh = s(\"MSH\", f(\"|\"));\n *\n *   createTest(null)(msh, []); // true\n *   createTest(\"segment\")(msh, []); // true\n *   createTest(\"field\")(msh, []); // false\n *\n *   createTest({ type: \"segment\", name: \"MSH\" })(msh, []); // true\n *   createTest({ name: \"PID\" })(msh, []); // false\n *\n *   // `undefined` matches a property the node does not have\n *   createTest({ name: undefined })(f(\"|\"), []); // true\n *\n *   // An inherited member is never matched\n *   createTest({ constructor: Object })(msh, []); // false\n *\n *   // A function receives the ancestors as well\n *   const inGroup = createTest((_node, ancestors) => ancestors.length > 1);\n *   ```;\n *\n * @param test - `null`, a node type, a property object, or a predicate.\n * @returns The predicate.\n */\nexport function createTest(test: Test<Nodes>): Predicate {\n  if (test === null) {\n    return () => true;\n  }\n  if (typeof test === \"string\") {\n    return (node) => node.type === test;\n  }\n  if (typeof test === \"function\") {\n    // Used as is: `visit` calls it with `(node, ancestors)`, so it may match on\n    // a node's position in the tree as well as on the node itself.\n    return test;\n  }\n\n  // Read once here rather than per visited node: a visit calls the predicate\n  // for every node, and a test object changed during the visit does not change\n  // which nodes match.\n  const entries = Object.entries(test);\n\n  return (node) =>\n    entries.every(\n      ([key, value]) =>\n        // `Object.hasOwn` limits the match to the node's own properties. Without\n        // it, `node[key]` also finds inherited members, so `{ constructor: x }`\n        // or `{ toString: x }` would be compared against `Object.prototype`.\n        // `Reflect.get(node, key)` is `node[key]`; it compiles for an arbitrary\n        // string key, which `Nodes` (no index signature) does not allow.\n        (Object.hasOwn(node, key) ? Reflect.get(node, key) : undefined) ===\n        value\n    );\n}\n","/**\n * HL7v2 AST visitor, typed for `@glion/ast`, with the semantics of\n * `unist-util-visit-parents`.\n *\n * @module\n */\n\nimport type { Nodes } from \"@glion/ast\";\nimport { EXIT, SKIP } from \"unist-util-visit-parents\";\nimport type { VisitorResult } from \"unist-util-visit-parents\";\n\nimport type { Predicate, Test, Visitor } from \"./types\";\nimport { createTest } from \"./utils\";\n\nexport type { VisitorResult } from \"unist-util-visit-parents\";\n\nexport { EXIT, SKIP } from \"unist-util-visit-parents\";\n\nexport type { Predicate, Test, Visitor } from \"./types\";\n\n// Overload signatures\nexport function visit(tree: Nodes, visitor: Visitor): void;\nexport function visit<Type extends Nodes[\"type\"]>(\n  tree: Nodes,\n  test: Type,\n  visitor: Visitor<Extract<Nodes, { type: Type }>>\n): void;\nexport function visit<T extends Nodes>(\n  tree: Nodes,\n  test: Test<T>,\n  visitor: Visitor<T>\n): void;\n\n/**\n * Visits `tree` and every node below it, depth-first and in document order,\n * calling `visitor` with each node that passes `test` and that node's\n * ancestors.\n *\n * `test` is a node type (`\"segment\"`), an object whose own properties a node\n * must equal (`{ name: \"PID\" }`), or a function of `(node, ancestors)`. With no\n * test, every node passes. A function passed as the second argument is always\n * the visitor; a test function needs the three-argument form.\n *\n * The visitor's result decides what the walk does next:\n *\n * - Nothing: enter the node's children, then go on.\n * - `SKIP`: do not enter the node's children.\n * - `EXIT`: stop the whole walk.\n * - A number: go on at that index among the node's siblings, after the visitor\n *   removed or inserted siblings. `[action, index]` combines both.\n *\n * `ancestors` runs from `tree` to the node's parent. Siblings share one array:\n * a visitor MUST NOT change it, and MAY keep it, since a later visit never\n * changes it either.\n *\n * With a type test, the walk does not enter a node that cannot contain that\n * type in an HL7v2 tree (Root → Group → Segment → Field → FieldRepetition →\n * Component → Subcomponent): `visit(tree, \"segment\", …)` never enters a\n * segment. Nodes of a type `@glion/ast` does not define are always entered.\n *\n * @param tree - The node the walk starts at, of any type.\n * @param test - Which nodes the visitor is called with.\n * @param visitor - Called with each node that passes `test`.\n */\nexport function visit<T extends Nodes>(\n  tree: Nodes,\n  arg2: Visitor<T> | Test<T>,\n  arg3?: Visitor<T>\n): void {\n  let test: Test<T> = null;\n  let visitor: Visitor<T>;\n\n  if (arg3 === undefined) {\n    visitor = arg2 as Visitor<T>;\n  } else {\n    test = arg2 as Test<T>;\n    visitor = arg3;\n  }\n\n  walk(tree, [], {\n    predicate: createTest(test as Test<Nodes>),\n    unmatchableBelow: UNMATCHABLE_BELOW.get(test),\n    visitor: visitor as Visitor<Nodes>,\n  });\n}\n\n/** What one `visit` call holds fixed for every node it walks. */\ninterface Walk {\n  predicate: Predicate;\n  /** Node types whose children cannot pass the test. */\n  unmatchableBelow: ReadonlySet<string> | undefined;\n  visitor: Visitor<Nodes>;\n}\n\n/**\n * The depth of each `@glion/ast` node type in an HL7v2 tree. A group may hold\n * groups, so it is the one type found below its own depth.\n */\nconst DEPTH: ReadonlyMap<string, number> = new Map([\n  [\"root\", 0],\n  [\"group\", 1],\n  [\"segment\", 2],\n  [\"field\", 3],\n  [\"field-repetition\", 4],\n  [\"component\", 5],\n  [\"subcomponent\", 6],\n]);\n\n/**\n * For each node type, the node types whose children cannot include a node of\n * that type. Any other test, such as an object or a function, finds nothing.\n */\nconst UNMATCHABLE_BELOW: ReadonlyMap<unknown, ReadonlySet<string>> = new Map(\n  [...DEPTH].map(([type, depth]) => [\n    type,\n    new Set(\n      [...DEPTH]\n        .filter(\n          ([parent, parentDepth]) =>\n            parentDepth >= depth && !(parent === \"group\" && type === \"group\")\n        )\n        .map(([parent]) => parent)\n    ),\n  ])\n);\n\n/**\n * Visits `node`, then its children in order, and returns the visitor's result\n * for `node`, or the first EXIT a descendant's visitor returns.\n *\n * Reads `children` after the visitor runs, and again after each child, so a\n * visitor may change its own children or its parent's.\n */\nfunction walk(node: Nodes, ancestors: Nodes[], context: Walk): VisitorResult {\n  const result = context.predicate(node, ancestors)\n    ? context.visitor(node, ancestors)\n    : undefined;\n  const action = Array.isArray(result) ? result[0] : result;\n\n  if (\n    action === EXIT ||\n    action === SKIP ||\n    !(\"children\" in node) ||\n    context.unmatchableBelow?.has(node.type)\n  ) {\n    return result;\n  }\n\n  // One array for all of this node's children: the visitor's contract forbids\n  // changing it, so siblings can share it.\n  const childAncestors = [...ancestors, node];\n  let index = 0;\n\n  while (index < node.children.length) {\n    const child = node.children[index] as Nodes;\n    const childResult = walk(child, childAncestors, context);\n    const childAction = Array.isArray(childResult)\n      ? childResult[0]\n      : childResult;\n\n    if (childAction === EXIT) {\n      return childResult;\n    }\n\n    // A child's visitor that returns an index (alone or as `[action, index]`)\n    // names the sibling to visit next; otherwise the walk moves one along.\n    const next = Array.isArray(childResult) ? childResult[1] : childResult;\n    index = typeof next === \"number\" ? next : index + 1;\n  }\n\n  return result;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,WAAW,MAA8B;AACvD,KAAI,SAAS,KACX,cAAa;AAEf,KAAI,OAAO,SAAS,SAClB,SAAQ,SAAS,KAAK,SAAS;AAEjC,KAAI,OAAO,SAAS,WAGlB,QAAO;CAMT,MAAM,UAAU,OAAO,QAAQ,KAAK;AAEpC,SAAQ,SACN,QAAQ,OACL,CAAC,KAAK,YAMJ,OAAO,OAAO,MAAM,IAAI,GAAG,QAAQ,IAAI,MAAM,IAAI,GAAG,KAAA,OACrD,MACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACJL,SAAgB,MACd,MACA,MACA,MACM;CACN,IAAI,OAAgB;CACpB,IAAI;AAEJ,KAAI,SAAS,KAAA,EACX,WAAU;MACL;AACL,SAAO;AACP,YAAU;;AAGZ,MAAK,MAAM,EAAE,EAAE;EACb,WAAW,WAAW,KAAoB;EAC1C,kBAAkB,kBAAkB,IAAI,KAAK;EACpC;EACV,CAAC;;;;;;AAeJ,MAAM,QAAqC,IAAI,IAAI;CACjD,CAAC,QAAQ,EAAE;CACX,CAAC,SAAS,EAAE;CACZ,CAAC,WAAW,EAAE;CACd,CAAC,SAAS,EAAE;CACZ,CAAC,oBAAoB,EAAE;CACvB,CAAC,aAAa,EAAE;CAChB,CAAC,gBAAgB,EAAE;CACpB,CAAC;;;;;AAMF,MAAM,oBAA+D,IAAI,IACvE,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,WAAW,CAChC,MACA,IAAI,IACF,CAAC,GAAG,MAAM,CACP,QACE,CAAC,QAAQ,iBACR,eAAe,SAAS,EAAE,WAAW,WAAW,SAAS,SAC5D,CACA,KAAK,CAAC,YAAY,OAAO,CAC7B,CACF,CAAC,CACH;;;;;;;;AASD,SAAS,KAAK,MAAa,WAAoB,SAA8B;CAC3E,MAAM,SAAS,QAAQ,UAAU,MAAM,UAAU,GAC7C,QAAQ,QAAQ,MAAM,UAAU,GAChC,KAAA;CACJ,MAAM,SAAS,MAAM,QAAQ,OAAO,GAAG,OAAO,KAAK;AAEnD,KACE,WAAWA,UACX,WAAWC,UACX,EAAE,cAAc,SAChB,QAAQ,kBAAkB,IAAI,KAAK,KAAK,CAExC,QAAO;CAKT,MAAM,iBAAiB,CAAC,GAAG,WAAW,KAAK;CAC3C,IAAI,QAAQ;AAEZ,QAAO,QAAQ,KAAK,SAAS,QAAQ;EACnC,MAAM,QAAQ,KAAK,SAAS;EAC5B,MAAM,cAAc,KAAK,OAAO,gBAAgB,QAAQ;AAKxD,OAJoB,MAAM,QAAQ,YAAY,GAC1C,YAAY,KACZ,iBAEgBD,OAClB,QAAO;EAKT,MAAM,OAAO,MAAM,QAAQ,YAAY,GAAG,YAAY,KAAK;AAC3D,UAAQ,OAAO,SAAS,WAAW,OAAO,QAAQ;;AAGpD,QAAO"}

package/dist/types.d.ts

@@ -1,33 +1,13 @@
 import type { Nodes } from "@glion/ast";
 import type { VisitorResult } from "unist-util-visit-parents";
-/**
- * Visit information computed for each node.
- * This is HL7v2-specific context not provided by unist-util-visit-parents.
- */
-export interface VisitInfo {
-    /**
-     * 0-based index among the parent's children when the node is visited, or 0
-     * for the node the visit starts from. Reflects changes a visitor made to
-     * those children earlier in the same visit.
-     */
-    index: number;
-    /** `index` + 1, the HL7v2 sequence number. */
-    sequence: number;
-    /** 1-based depth in tree (root = 1) */
-    depth: number;
-    /** Metadata extracted from node (e.g., { name: "MSH" } or { name: "PATIENT" }) */
-    metadata: Record<string, unknown> | undefined;
-}
 /**
  * A function called for each node during traversal.
- * Extends unist's visitor signature with HL7v2-specific context.
  *
  * @param node - Current node being visited
  * @param ancestors - Array of ancestor nodes from root to parent
- * @param info - HL7v2-specific visit info (index, sequence, depth, metadata)
  * @returns VisitorResult to control traversal (EXIT, SKIP, etc.)
  */
-export type Visitor<T extends Nodes = Nodes> = (node: T, ancestors: Nodes[], info: VisitInfo) => VisitorResult;
+export type Visitor<T extends Nodes = Nodes> = (node: T, ancestors: Nodes[]) => VisitorResult;
 /**
  * Predicate function to test if a node matches filter criteria.
  * Compatible with unist-util-is predicates but uses our Nodes type.

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IAEjB,uCAAuC;IACvC,KAAK,EAAE,MAAM,CAAC;IAEd,kFAAkF;IAClF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;CAC/C;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,IAAI,CAC7C,IAAI,EAAE,CAAC,EACP,SAAS,EAAE,KAAK,EAAE,EAClB,IAAI,EAAE,SAAS,KACZ,aAAa,CAAC;AAEnB;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC;AAErE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,IACpC,MAAM,GACN,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,IAAI,IAAI,CAAC,CAAC,GAChD,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,GAC9C,IAAI,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,IAAI,CAC7C,IAAI,EAAE,CAAC,EACP,SAAS,EAAE,KAAK,EAAE,KACf,aAAa,CAAC;AAEnB;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC;AAErE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,IAAI,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,IACpC,MAAM,GACN,OAAO,CAAC,CAAC,CAAC,GACV,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,IAAI,IAAI,CAAC,CAAC,GAChD,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,GAC9C,IAAI,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glion/util-visit",
-  "version": "0.26.0",
+  "version": "0.27.1",
   "description": "An AST visitor for HL7v2 messages",
   "keywords": [
     "health",
@@ -45,10 +45,10 @@
     "tsdown": "0.21.10",
     "typescript": "6.0.3",
     "vitest": "4.1.11",
-    "@glion/ast": "0.26.0",
-    "@glion/builder": "0.26.0",
+    "@glion/ast": "0.27.1",
+    "@glion/builder": "0.27.1",
     "@glion/check-readme": "0.18.0",
-    "@glion/parser": "0.26.0",
+    "@glion/parser": "0.27.1",
     "@glion/testing": "0.18.0",
     "@glion/tsconfig": "0.18.0"
   },