@rethinkhealth/hl7v2-parser 0.2.2 → 0.2.4

package/dist/index.js

@@ -1,582 +1,373 @@
-// src/constants.ts
-var DEFAULT_DELIMITERS = {
-  field: "|",
-  component: "^",
-  subcomponent: "&",
-  repetition: "~",
-  escape: "\\",
-  segment: "\n"
-  // default to \n (more common in modern systems)
-};
-var EMPTY_MESSAGE = {
-  type: "root",
-  delimiter: DEFAULT_DELIMITERS.segment,
-  children: [],
-  position: {
-    start: { line: 1, column: 1, offset: 0 },
-    end: { line: 1, column: 1, offset: 0 }
-  }
-};
-
-// src/pipeline/utils/index.ts
-function detectDelimitersFromMSH(raw, segmentDelimiter) {
-  const detectedSegmentDelimiter = detectSegmentDelimiter(
-    raw,
-    segmentDelimiter
-  );
-  const firstLineEnd = raw.indexOf(detectedSegmentDelimiter);
-  const mshSegment = firstLineEnd >= 0 ? raw.slice(0, firstLineEnd) : raw;
-  if (!mshSegment.startsWith("MSH")) {
-    return {};
-  }
-  const fieldDelimiter = mshSegment[3];
-  if (!fieldDelimiter) {
-    return {};
-  }
-  const encodingChars = mshSegment.slice(4, 8);
-  if (encodingChars.length !== 4) {
-    return {};
-  }
-  return {
-    field: fieldDelimiter,
-    component: encodingChars[0],
-    repetition: encodingChars[1],
-    escape: encodingChars[2],
-    subcomponent: encodingChars[3],
-    segment: detectedSegmentDelimiter
+// src/processor.ts
+function createParserCore() {
+  const root = { type: "root", children: [] };
+  let seg = null;
+  let field = null;
+  let rep = null;
+  let comp = null;
+  let currentSub = null;
+  let segmentHasContent = false;
+  const openSegment = () => {
+    seg = { type: "segment", children: [] };
+    root.children.push(seg);
+    field = null;
+    rep = null;
+    comp = null;
+    currentSub = null;
+    segmentHasContent = false;
   };
-}
-function splitByString(text, delimiter) {
-  const result = [];
-  let lastIndex = 0;
-  let index = text.indexOf(delimiter);
-  while (index !== -1) {
-    result.push({
-      value: text.slice(lastIndex, index),
-      start: lastIndex,
-      end: index
-    });
-    lastIndex = index + delimiter.length;
-    index = text.indexOf(delimiter, lastIndex);
-  }
-  result.push({
-    value: text.slice(lastIndex),
-    start: lastIndex,
-    end: text.length
-  });
-  return result;
-}
-function detectSegmentDelimiter(message, fallback = "\n") {
-  const possibleDelimiters = ["\r\n", "\n", "\r"];
-  for (const delimiter of possibleDelimiters) {
-    if (message.includes(delimiter)) {
-      return delimiter;
+  const ensureSegment = () => {
+    if (!seg) {
+      openSegment();
     }
-  }
-  return fallback;
-}
-
-// src/pipeline/core/parsers/subcomponent.ts
-var SubcomponentParser = class {
-  canParse(input) {
-    return input.type === "subcomponent";
-  }
-  parse(input) {
-    if (!this.canParse(input)) {
-      return null;
+  };
+  const openField = () => {
+    ensureSegment();
+    field = { type: "field", children: [] };
+    seg.children.push(field);
+    rep = { type: "field-repetition", children: [] };
+    field.children.push(rep);
+    comp = { type: "component", children: [] };
+    rep.children.push(comp);
+    currentSub = null;
+    segmentHasContent = true;
+  };
+  const openRepetition = () => {
+    if (!field) {
+      openField();
     }
-    return {
-      type: "subcomponent",
-      index: input.subcomponentIndex,
-      value: input.text,
-      position: {
-        start: { line: input.line, column: input.column, offset: input.start },
-        end: {
-          line: input.line,
-          column: input.column + input.text.length,
-          offset: input.end
-        }
-      }
-    };
-  }
-};
-
-// src/pipeline/core/parsers/component.ts
-var ComponentParser = class {
-  subcomponentParser = new SubcomponentParser();
-  canParse(input) {
-    return input.type === "component";
-  }
-  parse(input) {
-    if (!this.canParse(input)) {
-      return null;
+    rep = { type: "field-repetition", children: [] };
+    field.children.push(rep);
+    comp = { type: "component", children: [] };
+    rep.children.push(comp);
+    currentSub = null;
+    segmentHasContent = true;
+  };
+  const openComponent = () => {
+    if (!field) {
+      openField();
     }
-    const baseNode = {
-      type: "component",
-      index: input.componentIndex,
-      position: {
-        start: { line: input.line, column: input.column, offset: input.start },
-        end: {
-          line: input.line,
-          column: input.column + input.text.length,
-          offset: input.end
-        }
-      }
-    };
-    if (input.text.includes(input.context.delimiters.subcomponent)) {
-      return {
-        ...baseNode,
-        delimiter: input.context.delimiters.subcomponent,
-        children: this.parseSubcomponents(input)
-      };
+    if (!rep) {
+      rep = { type: "field-repetition", children: [] };
+      field.children.push(rep);
     }
-    return { ...baseNode, value: input.text };
-  }
-  parseSubcomponents(input) {
-    const subcomponents = this.splitByDelimiter(
-      input.text,
-      input.context.delimiters.subcomponent
-    );
-    const nodes = [];
-    for (let i = 0; i < subcomponents.length; i++) {
-      const sub = subcomponents[i];
-      if (!sub) {
-        continue;
-      }
-      const subNode = this.subcomponentParser.parse({
-        type: "subcomponent",
-        text: sub.value,
-        start: input.start + sub.start,
-        end: input.start + sub.end,
-        index: i,
-        subcomponentIndex: i,
-        line: input.line,
-        column: input.column + sub.start,
-        context: input.context
-      });
-      if (subNode) {
-        nodes.push(subNode);
-      }
+    comp = { type: "component", children: [] };
+    rep.children.push(comp);
+    currentSub = null;
+    segmentHasContent = true;
+  };
+  const ensureForText = () => {
+    if (!field) {
+      openField();
     }
-    return nodes;
-  }
-  splitByDelimiter(text, delimiter) {
-    const result = [];
-    let lastIndex = 0;
-    let index = text.indexOf(delimiter);
-    while (index !== -1) {
-      result.push({
-        value: text.slice(lastIndex, index),
-        start: lastIndex,
-        end: index
-      });
-      lastIndex = index + delimiter.length;
-      index = text.indexOf(delimiter, lastIndex);
+    if (!rep) {
+      openRepetition();
     }
-    result.push({
-      value: text.slice(lastIndex),
-      start: lastIndex,
-      end: text.length
-    });
-    return result;
-  }
-};
-
-// src/pipeline/core/parsers/field.ts
-var FieldParser = class {
-  componentParser = new ComponentParser();
-  canParse(input) {
-    return input.type === "field";
-  }
-  parse(input) {
-    if (!this.canParse(input)) {
-      return null;
+    if (!comp) {
+      openComponent();
     }
-    const baseNode = {
-      type: input.fieldIndex === 0 ? "header" : "field",
-      index: input.fieldIndex,
-      position: {
-        start: { line: input.line, column: input.column, offset: input.start },
-        end: {
-          line: input.line,
-          column: input.column + input.text.length,
-          offset: input.end
+    if (!currentSub) {
+      currentSub = { type: "subcomponent", value: "" };
+      comp.children.push(currentSub);
+      segmentHasContent = true;
+    }
+  };
+  const processToken = (tok) => {
+    switch (tok.type) {
+      case "SEGMENT_END": {
+        dropTrailingEmptyFieldIfPresent();
+        seg = null;
+        field = null;
+        rep = null;
+        comp = null;
+        currentSub = null;
+        segmentHasContent = false;
+        return;
+      }
+      case "FIELD_DELIM": {
+        if (!field) {
+          openField();
+          comp.children.push({ type: "subcomponent", value: "" });
+          segmentHasContent = true;
         }
+        openField();
+        return;
+      }
+      case "REPETITION_DELIM": {
+        if (!field) {
+          openField();
+        }
+        openRepetition();
+        return;
+      }
+      case "COMPONENT_DELIM": {
+        openComponent();
+        return;
+      }
+      case "SUBCOMP_DELIM": {
+        if (!comp) {
+          openComponent();
+        }
+        currentSub = { type: "subcomponent", value: "" };
+        comp.children.push(currentSub);
+        segmentHasContent = true;
+        return;
+      }
+      case "TEXT": {
+        const val = tok.value ?? "";
+        ensureForText();
+        currentSub.value += val;
+        segmentHasContent = true;
+        return;
+      }
+      default: {
+        throw new Error(`Unexpected token type: ${tok.type}`);
       }
-    };
-    if (input.isEncodingField) {
-      return { ...baseNode, value: input.text };
     }
-    if (input.fieldIndex === 0) {
-      return { ...baseNode, value: input.text };
+  };
+  const finalize = () => {
+    dropTrailingEmptyFieldIfPresent();
+    if (seg && !segmentHasContent) {
+      root.children.pop();
     }
-    if (input.text.includes(input.context.delimiters.component)) {
-      return {
-        ...baseNode,
-        delimiter: input.context.delimiters.component,
-        children: this.parseComponents(input)
-      };
+    return root;
+  };
+  function dropTrailingEmptyFieldIfPresent() {
+    if (!seg || seg.children.length === 0) {
+      return;
     }
-    return { ...baseNode, value: input.text };
-  }
-  parseComponents(input) {
-    const components = this.splitByDelimiter(
-      input.text,
-      input.context.delimiters.component
+    const lastField = seg.children.at(-1);
+    const hasAnySubcomponents = lastField.children.some(
+      (r) => r.children.some((c) => c.children.length > 0)
     );
-    const nodes = [];
-    for (let i = 0; i < components.length; i++) {
-      const comp = components[i];
-      if (!comp) {
-        continue;
-      }
-      const componentNode = this.componentParser.parse({
-        type: "component",
-        text: comp.value,
-        start: input.start + comp.start,
-        end: input.start + comp.end,
-        index: i,
-        componentIndex: i,
-        line: input.line,
-        column: input.column + comp.start,
-        context: input.context
-      });
-      if (componentNode) {
-        nodes.push(componentNode);
-      }
+    if (!hasAnySubcomponents) {
+      seg.children.pop();
     }
-    return nodes;
   }
-  splitByDelimiter(text, delimiter) {
-    const result = [];
-    let lastIndex = 0;
-    let index = text.indexOf(delimiter);
-    while (index !== -1) {
-      result.push({
-        value: text.slice(lastIndex, index),
-        start: lastIndex,
-        end: index
-      });
-      lastIndex = index + delimiter.length;
-      index = text.indexOf(delimiter, lastIndex);
-    }
-    result.push({
-      value: text.slice(lastIndex),
-      start: lastIndex,
-      end: text.length
-    });
-    return result;
+  return { processToken, finalize, root };
+}
+function parseHL7v2FromIterator(tokens) {
+  const core = createParserCore();
+  for (const tok of tokens) {
+    core.processToken(tok);
   }
-};
+  return core.finalize();
+}
 
-// src/pipeline/core/parsers/segment.ts
-var SegmentParser = class {
-  segmentType = "DEFAULT";
-  fieldParser = new FieldParser();
-  canParse(input) {
-    return input.type === "segment" && input.text.trim().length > 0;
-  }
-  parse(input) {
-    if (!this.canParse(input)) {
-      return null;
+// src/tokenizer.ts
+import {
+  DEFAULT_DELIMITERS
+} from "@rethinkhealth/hl7v2-utils";
+var HL7v2Tokenizer = class {
+  input = "";
+  i = 0;
+  line = 1;
+  col = 1;
+  delims;
+  // Only-run-once MSH bootstrap at the start of the file
+  didMshBootstrap = false;
+  pendingBootstrap = null;
+  // queue to emit TEXT('MSH'), FIELD_DELIM, TEXT('^~\\&')
+  reset(input, opts) {
+    this.input = input;
+    this.delims = opts.delimiters || DEFAULT_DELIMITERS;
+    this.i = 0;
+    this.line = 1;
+    this.col = 1;
+    this.didMshBootstrap = false;
+    this.pendingBootstrap = null;
+    if (this.input.startsWith("MSH")) {
+      const msh = this._slice(0, 3);
+      const msh2 = this._slice(4, 8);
+      this.pendingBootstrap = [
+        { kind: "TEXT", value: msh, advance: msh.length },
+        { kind: "FIELD_DELIM", advance: 1 },
+        // consume the single field delimiter char at index 3
+        { kind: "TEXT", value: msh2, advance: msh2.length }
+      ];
     }
-    const fields = splitByString(input.text, input.context.delimiters.field);
-    if (!fields[0] || fields.length === 0) {
+  }
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: The cognitive complexity of this method is justified because it must handle the HL7v2 MSH segment bootstrap logic and multiple tokenization cases in a single method for performance and maintainability.
+  next() {
+    const s = this.input;
+    const n = s.length;
+    if (this.i >= n && !this.pendingBootstrap?.length) {
       return null;
     }
-    const segmentNode = {
-      type: "segment",
-      name: fields[0].value,
-      index: input.index,
-      delimiter: input.context.delimiters.field,
-      children: [],
-      position: {
-        start: { line: input.line, column: 1, offset: input.start },
-        end: {
-          line: input.line,
-          column: input.text.length + 1,
-          offset: input.end
+    const start = { offset: this.i, line: this.line, column: this.col };
+    if (!this.didMshBootstrap && this.pendingBootstrap) {
+      const step = this.pendingBootstrap.shift();
+      if (step) {
+        if (step.kind === "TEXT") {
+          const take = Math.min(step.advance, n - this.i);
+          const out = step.value.slice(0, take);
+          this._fastAdvance(out);
+          if (this.pendingBootstrap.length === 0) {
+            this.pendingBootstrap = null;
+            this.didMshBootstrap = true;
+          }
+          return this._tok("TEXT", out, start);
         }
-      }
-    };
-    segmentNode.children = this.parseFields(fields, input);
-    return segmentNode;
-  }
-  parseFields(fields, input) {
-    const children = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i];
-      if (!field) {
-        continue;
-      }
-      const fieldNode = this.fieldParser.parse({
-        type: "field",
-        text: field.value,
-        start: input.start + field.start,
-        end: input.start + field.end,
-        index: i,
-        fieldIndex: i,
-        line: input.line,
-        column: field.start + 1,
-        context: input.context
-      });
-      if (fieldNode) {
-        children.push(fieldNode);
+        this._advance(Math.min(step.advance, n - this.i));
+        if (this.pendingBootstrap.length === 0) {
+          this.pendingBootstrap = null;
+          this.didMshBootstrap = true;
+        }
+        return this._tok("FIELD_DELIM", void 0, start);
       }
     }
-    return children;
-  }
-};
-
-// src/pipeline/core/parsers/segment-msh.ts
-var MSHSegmentParser = class {
-  segmentType = "MSH";
-  fieldParser = new FieldParser();
-  canParse(input) {
-    return input.type === "segment" && input.segmentType === "MSH";
-  }
-  parse(input) {
-    if (!this.canParse(input)) {
+    if (this.i >= n) {
       return null;
     }
-    const fields = this.extractMSHFields(
-      input.text,
-      input.context.delimiters.field
-    );
-    const segmentNode = {
-      type: "segment",
-      name: "MSH",
-      index: input.index,
-      delimiter: input.context.delimiters.field,
-      children: [],
-      position: {
-        start: { line: input.line, column: 1, offset: input.start },
-        end: {
-          line: input.line,
-          column: input.text.length + 1,
-          offset: input.end
-        }
-      }
-    };
-    segmentNode.children = this.parseFields(fields, input);
-    return segmentNode;
-  }
-  extractMSHFields(segmentText, fieldDelimiter) {
-    const msh1 = segmentText[3] ?? "";
-    const msh2 = segmentText.slice(4, 8) ?? "";
-    const rest = segmentText.slice(9);
-    const restFields = splitByString(rest, fieldDelimiter);
-    return [
-      { value: "MSH", start: 0, end: 3 },
-      { value: msh1, start: 3, end: 4 },
-      { value: msh2, start: 4, end: 8, isEncodingField: true },
-      ...restFields.map((f) => ({
-        value: f.value ?? "",
-        start: 9 + (f.start ?? 0),
-        end: 9 + (f.end ?? 0)
-      }))
-    ];
-  }
-  parseFields(fields, input) {
-    const children = [];
-    for (let i = 0; i < fields.length; i++) {
-      const field = fields[i];
-      if (!field) {
-        continue;
-      }
-      const fieldNode = this.fieldParser.parse({
-        type: "field",
-        text: field.value,
-        start: input.start + field.start,
-        end: input.start + field.end,
-        index: i,
-        fieldIndex: i,
-        line: input.line,
-        column: field.start + 1,
-        isEncodingField: field.isEncodingField,
-        context: input.context
-      });
-      if (fieldNode) {
-        children.push(fieldNode);
-      }
+    const ch = s.charAt(this.i);
+    if (ch === this.delims.segment) {
+      this._advance(1, true);
+      return this._tok("SEGMENT_END", void 0, start);
     }
-    return children;
-  }
-};
-
-// src/pipeline/core/registry.ts
-var SegmentParserRegistry = class {
-  parsers = /* @__PURE__ */ new Map();
-  defaultParser;
-  constructor(customParsers) {
-    this.defaultParser = new SegmentParser();
-    this.register(new MSHSegmentParser());
-    if (customParsers) {
-      for (const [, parser] of customParsers) {
-        this.register(parser);
-      }
+    if (ch === this.delims.field) {
+      this._advance(1);
+      return this._tok("FIELD_DELIM", void 0, start);
     }
-  }
-  /**
-   * Register a segment parser for a specific segment type
-   */
-  register(parser) {
-    this.parsers.set(parser.segmentType, parser);
-  }
-  /**
-   * Get the appropriate parser for a segment type
-   */
-  getParser(segmentType) {
-    return this.parsers.get(segmentType) || this.defaultParser;
-  }
-  /**
-   * Check if a parser is registered for a segment type
-   */
-  hasParser(segmentType) {
-    return this.parsers.has(segmentType);
-  }
-  /**
-   * Unregister a parser for a segment type
-   */
-  unregister(segmentType) {
-    return this.parsers.delete(segmentType);
-  }
-  /**
-   * Get all registered segment types
-   */
-  getRegisteredTypes() {
-    return Array.from(this.parsers.keys());
-  }
-};
-
-// src/pipeline/core/message.ts
-var HL7MessageParser = class {
-  segmentRegistry;
-  options;
-  constructor(options = {}) {
-    this.options = options;
-    this.segmentRegistry = new SegmentParserRegistry(options.customParsers);
-  }
-  canParse(input) {
-    return input.type === "message" && input.text.trim().length > 0;
-  }
-  parse(input) {
-    if (!this.canParse(input)) {
-      return EMPTY_MESSAGE;
+    if (ch === this.delims.repetition) {
+      this._advance(1);
+      return this._tok("REPETITION_DELIM", void 0, start);
     }
-    const context = this.createParseContext(input.text);
-    const segments = splitByString(input.text, context.delimiters.segment);
-    const messageNode = {
-      type: "root",
-      delimiter: context.delimiters.segment,
-      children: [],
-      position: {
-        start: { line: 1, column: 1, offset: 0 },
-        end: {
-          line: segments.length,
-          column: (segments.at(-1)?.value.length ?? 0) + 1,
-          offset: input.text.length
-        }
-      }
-    };
-    let currentLine = 1;
-    for (let i = 0; i < segments.length; i++) {
-      const seg = segments[i];
-      const hasContent = seg?.value.trim();
-      if (!seg) {
-        currentLine++;
-        continue;
-      }
-      if (!hasContent) {
-        currentLine++;
-        continue;
-      }
-      const segmentNode = this.parseSegment(seg, currentLine, i, context);
-      if (segmentNode) {
-        messageNode.children = messageNode.children || [];
-        messageNode.children.push(segmentNode);
+    if (ch === this.delims.component) {
+      this._advance(1);
+      return this._tok("COMPONENT_DELIM", void 0, start);
+    }
+    if (ch === this.delims.subcomponent) {
+      this._advance(1);
+      return this._tok("SUBCOMP_DELIM", void 0, start);
+    }
+    let j = this.i;
+    const seg = this.delims.segment, fld = this.delims.field, rep = this.delims.repetition, cmp = this.delims.component, sub = this.delims.subcomponent;
+    while (j < s.length) {
+      const c = s.charAt(j);
+      if (c === seg || c === fld || c === rep || c === cmp || c === sub) {
+        break;
       }
-      currentLine++;
+      j++;
+    }
+    const val = s.slice(this.i, j);
+    this._fastAdvance(val);
+    return this._tok("TEXT", val, start);
+  }
+  // ---- helpers ----
+  _slice(start, end) {
+    return this.input.slice(start, Math.min(end, this.input.length));
+  }
+  _advance(n, isNewline = false) {
+    this.i += n;
+    if (isNewline) {
+      this.line += 1;
+      this.col = 1;
+    } else {
+      this.col += n;
     }
-    return this.applyValidationHooks(messageNode, context);
   }
-  createParseContext(rawMessage) {
-    const baseDelimiters = {
-      ...DEFAULT_DELIMITERS,
-      ...this.options.delimiters
-    };
-    let activeDelimiters = baseDelimiters;
-    if (this.options.autoDetectDelimiters !== false) {
-      const detected = detectDelimitersFromMSH(
-        rawMessage,
-        baseDelimiters.segment
-      );
-      activeDelimiters = { ...baseDelimiters, ...detected };
+  _fastAdvance(chunk) {
+    const parts = chunk.split("\r");
+    if (parts.length > 1) {
+      this.line += parts.length - 1;
+      this.col = (parts.at(-1)?.length ?? 0) + 1;
+    } else {
+      this.col += chunk.length;
     }
-    return {
-      delimiters: activeDelimiters,
-      options: this.options,
-      currentLine: 1,
-      totalOffset: 0
-    };
+    this.i += chunk.length;
   }
-  parseSegment(segment, line, index, context) {
-    const segmentType = segment.value.slice(0, 3);
-    const parser = this.segmentRegistry.getParser(segmentType);
-    return parser.parse({
-      type: "segment",
-      text: segment.value,
-      start: segment.start,
-      end: segment.end,
-      index,
-      segmentType,
-      line,
-      context
-    });
+  _tok(type, value, start) {
+    const end = { offset: this.i, line: this.line, column: this.col };
+    return { type, value, position: { start, end } };
   }
-  applyValidationHooks(node, context) {
-    if (!this.options.validationHooks) {
-      return node;
-    }
-    for (const hook of this.options.validationHooks) {
-      const result = hook.validate(node, context);
-      if (!result.isValid) {
-        throw new Error(result.errors?.[0] ?? "Validation error");
+  // Iterable protocol (sync)
+  [Symbol.iterator]() {
+    return {
+      next: () => {
+        const t = this.next();
+        if (t == null) {
+          return { done: true, value: void 0 };
+        }
+        return { done: false, value: t };
       }
-    }
-    return node;
+    };
   }
+  // Async iteration support removed to keep the API synchronous.
 };
 
-// src/parser.ts
-function fromHL7v2Pipeline(rawMessage, options = {}) {
-  const parser = new HL7MessageParser(options);
-  const result = parser.parse({
-    type: "message",
-    text: rawMessage,
-    start: 0,
-    end: rawMessage.length,
-    index: 0,
-    context: {
-      delimiters: options.delimiters || {},
-      options,
-      currentLine: 1,
-      totalOffset: 0
-    }
-  });
-  return result || EMPTY_MESSAGE;
+// src/utils.ts
+function* iterateTokenizerSync(t) {
+  for (let tok = t.next(); tok; tok = t.next()) {
+    yield tok;
+  }
 }
 
-// src/processor.ts
+// src/parser.ts
+function parseHL7v2(input, opts) {
+  const tokenizer = new HL7v2Tokenizer();
+  tokenizer.reset(input, opts);
+  return parseHL7v2FromIterator(iterateTokenizerSync(tokenizer));
+}
 var hl7v2Parser = function(options = {}) {
   const self = this;
-  function parser(value) {
-    return fromHL7v2Pipeline(value, options);
+  self.parser = (value) => parseHL7v2(value, options);
+};
+var parser_default = hl7v2Parser;
+
+// src/preprocessor.ts
+var stripBOM = (ctx) => {
+  if (ctx.input.charCodeAt(0) === 65279) {
+    ctx.input = ctx.input.slice(1);
   }
-  self.parser = parser;
+  return ctx;
 };
-var processor_default = hl7v2Parser;
+var normalizeNewlines = (ctx) => {
+  ctx.input = ctx.input.replace(/\r?\n/g, "\r");
+  return ctx;
+};
+var detectDelimiters = (ctx) => {
+  if (ctx.input.startsWith("MSH")) {
+    const fieldDelim = ctx.input.charAt(3) || "|";
+    const enc = ctx.input.slice(4, 8);
+    const component = enc.charAt(0) || "^";
+    const repetition = enc.charAt(1) || "~";
+    const _escape = enc.charAt(2) || "\\";
+    const subcomponent = enc.charAt(3) || "&";
+    ctx.options.delimiters = {
+      field: fieldDelim,
+      component,
+      repetition,
+      escape: _escape,
+      subcomponent,
+      segment: "\r"
+    };
+  }
+  return ctx;
+};
+var defaultPreprocessors = [
+  stripBOM,
+  normalizeNewlines,
+  detectDelimiters
+];
+function runPreprocessors(raw, opts = {}, steps = defaultPreprocessors) {
+  let ctx = {
+    input: raw,
+    options: opts,
+    metadata: {}
+  };
+  for (const step of steps) {
+    ctx = step(ctx);
+  }
+  return ctx;
+}
 export {
-  processor_default as hl7v2Parser
+  HL7v2Tokenizer,
+  defaultPreprocessors,
+  detectDelimiters,
+  parser_default as hl7v2Parser,
+  normalizeNewlines,
+  parseHL7v2FromIterator,
+  runPreprocessors,
+  stripBOM
 };
 //# sourceMappingURL=index.js.map