@nodable/sequential-stream-builder 1.0.0

package/README.md

@@ -0,0 +1,219 @@
+# Sequential Stream Output Builder
+
+Produces a sequential array where every element is represented as an object with the **tag name directly as a key** pointing to its children array. There is no separate `elementname` property — the structure is array-first throughout.
+
+## Output structure
+
+```
+[                          ← getOutput() always returns an array
+  {
+    [tagName]: Array,      ← tag name → children array (always present, empty for leaf/empty nodes)
+    [groupBy]?: object,    ← attributes as a sibling property (only when non-empty)
+    text?: any             ← only present on leaf nodes (no child element entries)
+  }
+]
+```
+
+### Leaf node (text only, no child elements)
+
+```js
+{ span: [], text: "Hello" }
+```
+
+### Empty tag (no text, no children)
+
+```js
+{ br: [] }
+```
+
+### Tag with child elements
+
+```js
+{ div: [ /* child entries */ ] }
+```
+
+### Tag with attributes and text
+
+```js
+{ item: [], attributes: { "@_id": 1 }, text: "hello" }
+```
+
+Attributes are a **sibling property** alongside the tag key — they are not nested inside the children array.
+
+### Mixed content (text interleaved with child elements)
+
+Inline text runs appear as `{ "#text": value }` entries inside the children array. The entry itself has no `text` property in this case.
+
+Input:
+```xml
+<p>Hello <b>world</b>!</p>
+```
+
+Output:
+```js
+[
+  {
+    p: [
+      { "#text": "Hello " },
+      { b: [], text: "world" },
+      { "#text": "!" }
+    ]
+  }
+]
+```
+
+## Basic example
+
+Input:
+```xml
+<root>
+  <child>hello</child>
+  <child>world</child>
+</root>
+```
+
+Output:
+```js
+[
+  {
+    root: [
+      { child: [], text: "hello" },
+      { child: [], text: "world" }
+    ]
+  }
+]
+```
+
+## Install
+
+```bash
+npm install @nodable/sequential-stream-builder
+```
+
+## Usage
+
+```js
+import XMLParser from "@nodable/flexible-xml-parser";
+import {SequentialStreamBuilderFactory} from "@nodable/sequential-stream-builder";
+
+const parser = new XMLParser({
+  OutputBuilder: new SequentialStreamBuilderFactory({
+    stream: fs.createWriteStream('output.json'),
+    // onChunk: (chunk) => {
+    //   console.log('CHUNK EMITTED:', chunk);
+    // }
+  }),
+  ...parserOptions,
+});
+
+parser.parse(xmlString);
+// result is always an array
+```
+
+## Options
+
+### `attributes.groupBy` (default: `"attributes"`)
+
+The property name under which all attributes are collected as a sibling alongside the tag key. The property is **only present** when attributes exist and `skip.attributes` is false.
+
+```js
+new SequentialStreamBuilderFactory({
+  attributes: { groupBy: "attributes" }  // default
+})
+```
+
+To use a custom key:
+
+```js
+new SequentialStreamBuilderFactory({
+  attributes: { groupBy: ":@" }
+})
+```
+
+### `nameFor.text` (default: `"#text"`)
+
+The key used for inline text entries inside the children array when a node has mixed content (text interleaved with child elements).
+
+```js
+new SequentialStreamBuilderFactory({
+  nameFor: { text: ":text" }
+})
+```
+
+### `nameFor.comment`
+
+When `skip.comment` is false, this property name is used for comment entries in the children array.
+
+```js
+new SequentialStreamBuilderFactory({
+  nameFor: { comment: "#comment" }
+})
+```
+
+### `nameFor.cdata`
+
+When set, CDATA sections appear as `{ [cdata]: value }` entries in the children array. When unset (default), CDATA content is merged into the node's `text` value (same as regular text).
+
+```js
+// builder config
+const builderConfig = { nameFor: { cdata: "##cdata" } };
+// parser config
+const parserConfig  = { skip: { cdata: false } };
+
+const parser = new XMLParser({
+  OutputBuilder: new SequentialStreamBuilderFactory(builderConfig),
+  ...parserConfig,
+});
+```
+
+Output for `<root><code><![CDATA[data]]></code></root>`:
+```js
+[
+  {
+    root: [
+      {
+        code: [
+          { "##cdata": "data" }
+        ]
+      }
+    ]
+  }
+]
+```
+
+### `textInChild` (default: `false`)
+
+When `true`, text is always stored as a `{ [nameFor.text]: value }` entry in the children array — even on pure leaf nodes that have no element children. The `text` sibling property is never set in this mode.
+
+```js
+new SequentialStreamBuilderFactory({ textInChild: true })
+```
+
+Input:
+```xml
+<root><a>hello</a></root>
+```
+
+Default output (`textInChild: false`):
+```js
+[ { root: [ { a: [], text: "hello" } ] } ]
+```
+
+Output with `textInChild: true`:
+```js
+[ { root: [ { a: [ { "#text": "hello" } ] } ] } ]
+```
+
+### `skip.attributes` (default: `true`)
+
+When `true` (default), all attributes are ignored and no `attributes` property appears on entries. Set to `false` to populate attributes.
+
+### Value parsers
+
+By default the parser chain `["entity", "boolean", "number"]` is applied to text content, converting `"42"` → `42` and `"true"` → `true`. Override with `tags.valueParsers`.
+
+```js
+new SequentialStreamBuilderFactory({
+  tags: { valueParsers: [] }   // keep all values as raw strings
+})
+```

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@nodable/sequential-stream-builder",
+  "version": "1.0.0",
+  "description": "Sequential JS Array stream builder for flexible-xml-parser",
+  "main": "src/index.js",
+  "types": "./src/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "flexible-xml-parser",
+    "nodable",
+    "xml"
+  ],
+  "author": "Amit Gupta (https://solothought.com)",
+  "license": "MIT",
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nodable/base-output-builder": "^1.0.2",
+    "path-expression-matcher": "^1.4.0"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/nodable"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nodable/flexible-output-builder.git"
+  }
+}

package/src/ParserOptionsBuilder.js

@@ -0,0 +1,78 @@
+const defaultOptions = {
+  nameFor: {
+    text: "#text",
+    // comment: "",
+    // cdata: "",
+  },
+  skip: {
+    // declaration: false,
+    // pi: false,
+    // attributes: true,
+    // cdata: false,
+    // comment: false,
+    // nsPrefix: false,
+    // tags: false,
+  },
+  tags: {
+    valueParsers: [],
+    // stopNodes: [],
+  },
+  attributes: {
+    prefix: "@_",
+    suffix: "",
+    groupBy: "attributes",
+    valueParsers: [],
+  },
+  textInChild: false,
+};
+
+// Default chains: replaceEntities first (expand references), then type coercion.
+const defaultTagParsers = ["entity", "boolean", "number"];
+const defaultAttrParsers = ["entity", "number", "boolean"];
+
+export function buildOptions(options) {
+  const finalOptions = deepClone(defaultOptions);
+
+  if (!options || options.tags?.valueParsers === undefined) {
+    finalOptions.tags.valueParsers = [...defaultTagParsers];
+  }
+  if (!options || options.attributes?.valueParsers === undefined) {
+    finalOptions.attributes.valueParsers = [...defaultAttrParsers];
+  }
+
+  if (options) {
+    copyProperties(finalOptions, options);
+  }
+
+  return finalOptions;
+}
+
+function deepClone(obj) {
+  if (obj === null || typeof obj !== 'object') return obj;
+  if (Array.isArray(obj)) return obj.map(deepClone);
+  const clone = {};
+  for (const key of Object.keys(obj)) {
+    clone[key] = deepClone(obj[key]);
+  }
+  return clone;
+}
+
+function copyProperties(target, source) {
+  for (const key of Object.keys(source)) {
+    // Guard against prototype pollution via option keys
+    if (key === '__proto__' || key === 'constructor' || key === 'prototype') continue;
+
+    if (typeof source[key] === 'function') {
+      target[key] = source[key];
+    } else if (Array.isArray(source[key])) {
+      target[key] = source[key];
+    } else if (typeof source[key] === 'object' && source[key] !== null) {
+      if (typeof target[key] !== 'object' || target[key] === null) {
+        target[key] = {};
+      }
+      copyProperties(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+}

package/src/SequentialStreamBuilder.js

@@ -0,0 +1,370 @@
+import { buildOptions } from './ParserOptionsBuilder.js';
+import { BaseOutputBuilder, BaseOutputBuilderFactory, ElementType } from '@nodable/base-output-builder';
+
+/**
+ * SequentialStreamBuilderFactory
+ *
+ * Stream variant of SequentialBuilderFactory.
+ *
+ * Instead of accumulating all parsed entries in memory and returning them via
+ * getOutput(), this builder emits each **top-level entry** to a Writable stream
+ * (or a plain callback) as soon as its closing tag is processed.  Nested nodes
+ * are still kept in memory during parsing — you cannot emit partial JSON — but
+ * they are released the moment the root-level element closes.
+ *
+ * The wire format is a **JSON array written incrementally**:
+ *
+ *   [                          ← written on first entry
+ *     { "root": [...] },       ← written when the first top-level tag closes
+ *     { "other": [...] }       ← written when the second top-level tag closes
+ *   ]                          ← written when getOutput() is called (end of parse)
+ *
+ * This matches the shape of SequentialBuilder.getOutput() so the two builders
+ * are drop-in replacements for each other.
+ *
+ * Options (in addition to all SequentialBuilderFactory options):
+ *
+ *   stream   {Writable}  – Node.js Writable stream.  Mutually exclusive with onChunk.
+ *   onChunk  {Function}  – Callback invoked with each string chunk.
+ *                          Mutually exclusive with stream.
+ *   space    {number|string} – JSON.stringify spacing (default: undefined → compact).
+ *
+ * Exactly one of `stream` or `onChunk` must be provided.
+ *
+ * Usage:
+ *
+ *   import fs from 'fs';
+ *   import XMLParser from '@nodable/flexible-xml-parser';
+ *   import SequentialStreamBuilderFactory from './SequentialStreamBuilder.js';
+ *
+ *   const out = fs.createWriteStream('output.json');
+ *
+ *   out.on('open', () => {
+ *     const parser = new XMLParser({
+ *       OutputBuilder: new SequentialStreamBuilderFactory({ stream: out }),
+ *     });
+ *
+ *     parser.parse(xmlString);   // synchronous — all onChunk calls fire here
+ *
+ *     out.end();                 // flush + close after parse() returns
+ *   });
+ *
+ * IMPORTANT — parser.parse() is synchronous.
+ * All chunk emissions happen inline during parse().  The stream must be open
+ * (writable) before parse() is called, and end() / finish() is the caller's
+ * responsibility after parse() returns.
+ */
+export default class SequentialStreamBuilderFactory extends BaseOutputBuilderFactory {
+  constructor(options = {}) {
+    super();
+
+    if (!options.stream && typeof options.onChunk !== 'function') {
+      throw new TypeError(
+        'SequentialStreamBuilderFactory: provide either `stream` (Writable) or `onChunk` (Function).'
+      );
+    }
+    if (options.stream && typeof options.onChunk === 'function') {
+      throw new TypeError(
+        'SequentialStreamBuilderFactory: `stream` and `onChunk` are mutually exclusive.'
+      );
+    }
+
+    // Separate stream/formatting options from builder options
+    const { stream, onChunk, space, ...builderOptions } = options;
+
+    this._stream = stream ?? null;
+    this._onChunk = onChunk ?? null;
+    this._space = space ?? undefined;
+
+    this.options = buildOptions(builderOptions);
+  }
+
+  getInstance(parserOptions, readonlyMatcher) {
+    const valParsers = { ...this.commonValParsers };
+
+    // Each parse run gets its own builder instance, with a fresh emit function
+    // that writes to the configured destination.
+    const emit = this._stream
+      ? (chunk) => this._stream.write(chunk)
+      : this._onChunk;
+
+    return new SequentialStreamBuilder(
+      parserOptions,
+      this.options,
+      valParsers,
+      readonlyMatcher,
+      emit,
+      this._space
+    );
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+export class SequentialStreamBuilder extends BaseOutputBuilder {
+  /**
+   * @param {object}   parserOptions
+   * @param {object}   builderOptions   – merged + defaulted options from buildOptions()
+   * @param {object}   registeredValParsers
+   * @param {object}   readonlyMatcher
+   * @param {Function} emit             – (chunk: string) => void
+   * @param {number|string|undefined} space – JSON.stringify space argument
+   */
+  constructor(parserOptions, builderOptions, registeredValParsers, readonlyMatcher, emit, space) {
+    super(readonlyMatcher);
+
+    this.tagsStack = [];
+    this.parserOptions = parserOptions;
+
+    this.options = {
+      ...parserOptions,
+      ...builderOptions,
+      skip: { ...parserOptions.skip, ...builderOptions.skip },
+      nameFor: { ...parserOptions.nameFor, ...builderOptions.nameFor },
+      tags: { ...parserOptions.tags, ...builderOptions.tags },
+      attributes: { ...parserOptions.attributes, ...builderOptions.attributes },
+    };
+
+    this.registeredValParsers = registeredValParsers;
+
+    this._emit = emit;
+    this._space = space;
+    this._entryCount = 0;   // how many top-level entries have been emitted so far
+    this._streamClosed = false;
+
+    // currentNode starts as null — the first addElement() creates the root entry.
+    // We don't need a synthetic root node because we emit each top-level entry
+    // immediately on closeElement() when tagsStack is empty.
+    this.currentNode = null;
+    this.attributes = {};
+    this._pendingStopNode = false;
+  }
+
+  // -------------------------------------------------------------------------
+  // Internal helpers
+  // -------------------------------------------------------------------------
+
+  /**
+   * Emit a fully-closed top-level entry to the stream.
+   * Handles the JSON array framing:  "[" before the first entry,
+   * "," as a separator between subsequent entries.
+   * The closing "]" is written in getOutput().
+   */
+  _emitEntry(entry) {
+    if (this._streamClosed) return;
+
+    const json = JSON.stringify(entry, null, this._space);
+
+    if (this._entryCount === 0) {
+      // Open the JSON array with the first element
+      this._emit('[\n' + json);
+    } else {
+      // Subsequent elements are comma-separated
+      this._emit(',\n' + json);
+    }
+
+    this._entryCount++;
+  }
+
+  // -------------------------------------------------------------------------
+  // BaseOutputBuilder interface
+  // -------------------------------------------------------------------------
+
+  addElement(tag) {
+    if (this.currentNode !== null) {
+      // We are already inside a top-level element — this is a nested open tag.
+      // Migrate any pending text into the children array (mixed-content case).
+      if (this.currentNode.text !== undefined) {
+        this.currentNode.children.unshift({
+          [this.options.nameFor.text]: this.currentNode.text,
+        });
+        delete this.currentNode.text;
+      }
+
+      this.tagsStack.push(this.currentNode);
+    }
+    // else: tagsStack is empty and currentNode is null → this is a new top-level element.
+
+    const node = new Node(tag.name, this.options);
+
+    if (this.attributes && Object.keys(this.attributes).length > 0) {
+      node[this.options.attributes.groupBy] = { ...this.attributes };
+    }
+    this.attributes = {};
+    this.currentNode = node;
+  }
+
+  /**
+   * Called when a stop node is fully collected, before addValue().
+   */
+  onStopNode(tagDetail, rawContent) {
+    this._pendingStopNode = true;
+    if (typeof this.options.onStopNode === 'function') {
+      this.options.onStopNode(tagDetail, rawContent, this.matcher);
+    }
+  }
+
+  closeElement() {
+    const node = this.currentNode;
+
+    this._pendingStopNode = false;
+
+    if (this.options.onClose !== undefined) {
+      const resultTag = this.options.onClose(node, this.matcher);
+      if (resultTag) {
+        // Caller suppressed this entry; restore parent or null
+        this.currentNode = this.tagsStack.pop() ?? null;
+        return;
+      }
+    }
+
+    // Build the entry object — same shape as SequentialBuilder
+    const entry = { [node.tagname]: node.children };
+
+    const groupBy = this.options.attributes.groupBy;
+    if (node[groupBy] && Object.keys(node[groupBy]).length > 0) {
+      entry[groupBy] = node[groupBy];
+    }
+
+    if (node.text !== undefined) {
+      entry.text = node.text;
+    }
+
+    if (this.tagsStack.length === 0) {
+      // ── Top-level element just closed ────────────────────────────────────
+      // Emit immediately; do NOT keep a reference (memory freed here).
+      this._emitEntry(entry);
+      this.currentNode = null;
+    } else {
+      // ── Nested element closed ─────────────────────────────────────────────
+      // Attach to the parent's children array and pop the stack.
+      this.currentNode = this.tagsStack.pop();
+      this.currentNode.children.push(entry);
+    }
+  }
+
+  addValue(text) {
+    if (this.currentNode === null) return; // text outside any tag — ignore
+
+    const hasElementChildren = this.currentNode.children?.some(
+      (c) => !Object.prototype.hasOwnProperty.call(c, this.options.nameFor.text)
+    );
+
+    const context = {
+      elementName: this.currentNode.tagname,
+      elementValue: text,
+      elementType: ElementType.ELEMENT,
+      matcher: this.matcher,
+      isLeafNode: !hasElementChildren,
+    };
+
+    const parsedValue = this.parseValue(text, this.options.tags.valueParsers, context);
+
+    if (hasElementChildren || this.options.textInChild) {
+      this.currentNode.children.push({
+        [this.options.nameFor.text]: parsedValue,
+      });
+    } else {
+      this.currentNode.text = parsedValue;
+    }
+  }
+
+  addInstruction(name) {
+    if (this.currentNode === null) {
+      // PI at document level — emit immediately as a standalone entry
+      const node = new Node(name, this.options);
+      const groupBy = this.options.attributes.groupBy;
+      if (this.attributes && Object.keys(this.attributes).length > 0) {
+        node[groupBy] = { ...this.attributes };
+      }
+      const entry = { [node.tagname]: node.children };
+      if (node[groupBy] && Object.keys(node[groupBy]).length > 0) {
+        entry[groupBy] = node[groupBy];
+      }
+      this.attributes = {};
+      this._emitEntry(entry);
+      return;
+    }
+
+    // PI inside an element — same as SequentialBuilder
+    const node = new Node(name, this.options);
+    const groupBy = this.options.attributes.groupBy;
+    if (this.attributes && Object.keys(this.attributes).length > 0) {
+      node[groupBy] = { ...this.attributes };
+    }
+    const entry = { [node.tagname]: node.children };
+    if (node[groupBy] && Object.keys(node[groupBy]).length > 0) {
+      entry[groupBy] = node[groupBy];
+    }
+    this.currentNode.children.push(entry);
+    this.attributes = {};
+  }
+
+  addComment(text) {
+    if (this.options.skip.comment) return;
+    if (!this.options.nameFor.comment) return;
+    if (this.currentNode === null) return; // comment outside any tag
+
+    this.currentNode.children.push({
+      [this.options.nameFor.comment]: text,
+    });
+  }
+
+  addLiteral(text) {
+    if (this.options.skip.cdata) return;
+
+    if (this.options.nameFor.cdata) {
+      if (this.currentNode === null) return;
+      this.currentNode.children.push({
+        [this.options.nameFor.cdata]: text,
+      });
+    } else {
+      this.addValue(text || '');
+    }
+  }
+
+  /**
+   * Called after the full parse is complete.
+   *
+   * Closes the JSON array that was opened by the first _emitEntry() call.
+   * If no entries were emitted at all (empty document), emits an empty array.
+   *
+   * Returns null — the output lives in the stream, not in memory.
+   */
+  getOutput() {
+    if (this._streamClosed) return null;
+    this._streamClosed = true;
+
+    if (this._entryCount === 0) {
+      this._emit('[]');
+    } else {
+      this._emit('\n]');
+    }
+
+    return null;
+  }
+
+  /**
+   * onExit — called by the parser when exitIf returns true.
+   *
+   * The parser has already closed all open tags before calling this, so
+   * all pending entries have already been emitted via closeElement().
+   * We just need to close the JSON array, same as getOutput().
+   *
+   * @param {object} exitInfo
+   */
+  onExit(exitInfo) { // eslint-disable-line no-unused-vars
+    this.getOutput();
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+class Node {
+  constructor(tagname, options) {
+    this.tagname = tagname;
+    this.children = [];
+    const groupBy = options?.attributes?.groupBy ?? 'attributes';
+    this[groupBy] = {};
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,123 @@
+import type { Writable } from 'node:stream';
+import type {
+  FactoryOptions,
+  SequentialEntry,
+  ValueParser,
+} from './index.js';
+
+/**
+ * Options accepted by SequentialStreamBuilderFactory.
+ *
+ * Extends FactoryOptions with the stream-specific properties.
+ * Exactly one of `stream` or `onChunk` must be provided.
+ */
+export interface StreamBuilderOptions extends FactoryOptions {
+  /**
+   * A Node.js Writable stream.  Chunks of the JSON array are written to it
+   * via stream.write(chunk: string).
+   *
+   * Mutually exclusive with `onChunk`.
+   */
+  stream?: Writable;
+
+  /**
+   * A callback invoked with each string chunk as the parse progresses.
+   * Use this when you don't have a Writable but want to handle output
+   * yourself (e.g. accumulate into a buffer, send over a WebSocket, …).
+   *
+   * Mutually exclusive with `stream`.
+   */
+  onChunk?: (chunk: string) => void;
+
+  /**
+   * Spacing argument forwarded to JSON.stringify().
+   * Omit (or pass undefined) for compact output.
+   * Pass 2 for human-readable indented output.
+   */
+  space?: number | string;
+}
+
+/**
+ * SequentialStreamBuilderFactory
+ *
+ * Stream variant of SequentialBuilderFactory.  Instead of accumulating the
+ * full parse tree in memory, each top-level XML element is serialised to JSON
+ * and emitted to the configured `stream` or `onChunk` callback as soon as its
+ * closing tag is seen.
+ *
+ * Wire format — a JSON array written incrementally:
+ *
+ *   [               ← emitted together with the first top-level entry
+ *     { "root": [...] }
+ *   ]               ← emitted by getOutput() (called by the parser after parse())
+ *
+ * The shape of each entry is identical to SequentialBuilder so the two
+ * builders are drop-in replacements for each other.
+ *
+ * @example
+ * ```ts
+ * import fs from 'node:fs';
+ * import XMLParser from '@nodable/flexible-xml-parser';
+ * import SequentialStreamBuilderFactory from './SequentialStreamBuilder.js';
+ *
+ * const out = fs.createWriteStream('output.json');
+ *
+ * out.on('open', () => {
+ *   const parser = new XMLParser({
+ *     OutputBuilder: new SequentialStreamBuilderFactory({ stream: out }),
+ *   });
+ *
+ *   parser.parse(xmlString);   // synchronous — all writes happen here
+ *
+ *   out.end();                 // caller closes the stream
+ * });
+ * ```
+ */
+export default class SequentialStreamBuilderFactory {
+  constructor(options: StreamBuilderOptions);
+
+  getInstance(
+    parserOptions: FactoryOptions,
+    readonlyMatcher: unknown,
+  ): SequentialStreamBuilderInstance;
+
+  registerValueParser(name: string, parser: ValueParser): void;
+}
+
+export interface SequentialStreamBuilderInstance {
+  addElement(tag: { name: string }): void;
+  closeElement(): void;
+  addValue(text: string): void;
+  addAttribute(name: string, value: unknown): void;
+  addComment(text: string): void;
+  addLiteral(text: string): void;
+  addDeclaration(): void;
+  addInstruction(name: string): void;
+  addInputEntities(entities: object): void;
+
+  onStopNode?(
+    tagDetail: { name: string; line: number; col: number; index: number },
+    rawContent: string,
+    matcher: unknown,
+  ): void;
+
+  /**
+   * Closes the JSON array and returns null.
+   * All output has already been streamed; there is nothing to return in memory.
+   */
+  getOutput(): null;
+
+  /**
+   * Called by the parser when exitIf returns true.
+   * Flushes and closes the JSON array, identical to getOutput().
+   */
+  onExit(exitInfo: {
+    tagDetail: { name: string; line: number; col: number; index: number };
+    matcher: unknown;
+    depth: number;
+  }): void;
+
+  registeredValParsers: Record<string, ValueParser>;
+}
+
+export { SequentialEntry, FactoryOptions };

package/src/index.js

@@ -0,0 +1 @@
+export { default as SequentialStreamBuilderFactory, SequentialStreamBuilder } from './SequentialStreamBuilder.js';