@stxt-lang/core 0.6.2 → 0.7.0

package/out/core/Node.js

@@ -2,165 +2,177 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Node = void 0;
 const ParseException_1 = require("../exceptions/ParseException");
-const RuntimeException_1 = require("../exceptions/RuntimeException");
 const NamespaceValidator_1 = require("./NamespaceValidator");
 const StringUtils_1 = require("./StringUtils");
 /**
- * Node of the STXT tree. Mutable while parsing ({@link Node.addChild}/{@link Node.addTextLine}
- * are public); once the document is closed it must be treated as read-only. It represents both
- * INLINE nodes (with {@link Node.getValue}) and BLOCK text nodes (with {@link Node.getTextLines}),
- * as told apart by {@link Node.isTextNode}.
+ * Node of the STXT tree: what INLINE nodes ({@link InlineNode}) and BLOCK text nodes
+ * ({@link TextNode}) have in common. Those two are the only forms, and each one owns what is
+ * really its own — only an `InlineNode` has a value and children (and so the child lookups); only
+ * a `TextNode` has text lines. Code that walks a tree asks for the form
+ * (`node instanceof InlineNode`), the same way the canonical tree of STXT-TREE-SPEC has
+ * `children` only for inline nodes.
+ *
+ * Nodes are mutable, and the tree keeps its own integrity: a node knows its
+ * {@link Node.getParent | parent} (always an `InlineNode`), {@link InlineNode.addChild} links
+ * both ends and refuses a node that already has a parent, and {@link InlineNode.removeChild} /
+ * {@link Node.detach} undo it. The {@link Node.getLevel | level} is derived from the chain of
+ * parents, never stored.
+ *
+ * The namespace a node *declares* ({@link Node.getDeclaredNamespace}) and the one that *applies*
+ * to it ({@link Node.getNamespace}) are different things: the effective namespace is the declared
+ * one or, failing that, the parent's effective namespace (STXT-SPEC: namespaces are inherited
+ * vertically). Changing the declared namespace of a node therefore changes the effective
+ * namespace of the whole subtree that inherited it, and so does moving a subtree.
+ *
+ * The source line ({@link Node.getLine}) is optional: the parser sets it, code that builds trees
+ * usually does not ({@link Node.NO_LINE}).
  */
 class Node {
     /**
-     * Creates a node with its full position in the document. This is the constructor the
-     * {@link Parser} uses while parsing.
+     * Common initialisation, for the two concrete forms.
      *
-     * @param line line number of the document where the node opens.
-     * @param level indentation level of the node (0 for root nodes).
      * @param name name of the node.
-     * @param namespace namespace of the node, or null/undefined if it has none.
-     * @param textNode true if it is a text block node (BLOCK); false if it is INLINE.
-     * @param value inline value of the node (INLINE node), ignored when it is BLOCK.
-     * @throws ParseException if the name or the namespace are not valid.
+     * @param namespace namespace the node declares, or null/undefined/empty if it declares none.
+     * @param line source line, or {@link Node.NO_LINE}.
+     * @throws ParseException with code `INVALID_NODE_NAME` if the name is not a valid STXT node
+     *         name, or if the namespace does not have a valid format.
      */
-    constructor(line, level, name, namespace, textNode, value) {
-        this.textLines = [];
-        this.children = [];
-        this.level = level;
+    constructor(name, namespace, line) {
+        this.parent = null;
         this.line = line;
-        this.name = StringUtils_1.StringUtils.compactSpaces(name);
-        this.normalizedName = StringUtils_1.StringUtils.normalize(name);
-        this.namespace = StringUtils_1.StringUtils.lowerCase(namespace);
-        this.value = (value ?? "").trim();
-        this.textNode = textNode;
-        NamespaceValidator_1.NamespaceValidator.validateNamespaceFormat(this.namespace, line);
-        if (this.value.length > 0 && this.isTextNode()) {
-            throw new RuntimeException_1.RuntimeException("INLINE_VALUE_NOT_VALID", "Not empty value with textNode");
-        }
-        if (!StringUtils_1.StringUtils.isValidNodeName(this.name)) {
-            throw new ParseException_1.ParseException(line, "INVALID_NODE_NAME", `Node name not valid: ${name}`);
-        }
+        this.setName(name);
+        this.setNamespace(namespace);
+    }
+    // ----------------------------------------------------------------
+    // Name
+    // ----------------------------------------------------------------
+    /** @returns the original name of the node as it appears in the document (with spaces compacted). */
+    getName() {
+        return this.name;
     }
     /**
-     * Appends a text line to a BLOCK node.
+     * Renames the node. The canonical name is recomputed.
      *
-     * @param line text line to append to a BLOCK node ({@link Node.isTextNode}).
+     * @param name new name of the node.
+     * @throws ParseException with code `INVALID_NODE_NAME` if it is not a valid STXT node name.
      */
-    addTextLine(line) {
-        this.textLines.push(line);
+    setName(name) {
+        const compacted = StringUtils_1.StringUtils.compactSpaces(name);
+        if (!StringUtils_1.StringUtils.isValidNodeName(compacted)) {
+            throw new ParseException_1.ParseException(this.line, "INVALID_NODE_NAME", `Node name not valid: ${name}`);
+        }
+        this.name = compacted;
+        this.canonicalName = StringUtils_1.StringUtils.normalize(name);
     }
-    /** @returns the original name of the node as it appears in the document (with spaces compacted). */
-    getName() {
-        return this.name;
+    /** @returns the canonical name of the node (STXT-SPEC §4.3), used to compare/look up by structural identity. */
+    getCanonicalName() {
+        return this.canonicalName;
     }
-    /** @returns the canonical name of the node, used to compare/look up by structural identity. */
+    /**
+     * @returns the canonical name of the node.
+     * @deprecated since 0.7.0, use {@link Node.getCanonicalName}; "canonical name" is the term of
+     *             the specifications. To be removed in a later version.
+     */
     getNormalizedName() {
-        return this.normalizedName;
+        return this.canonicalName;
     }
-    /** @returns the canonical name prefixed by its namespace (`namespace:name`), or just the name when there is no namespace. */
+    /** @returns the canonical name prefixed by the effective namespace (`namespace:name`), or just the canonical name when there is no namespace. */
     getQualifiedName() {
-        return this.namespace.length === 0
-            ? this.normalizedName
-            : `${this.namespace}:${this.normalizedName}`;
-    }
-    /** @returns the effective namespace of the node (its own or inherited from the parent), lower-cased, or the empty string if it has none. */
-    getNamespace() {
-        return this.namespace;
+        const namespace = this.getNamespace();
+        return namespace.length === 0 ? this.canonicalName : `${namespace}:${this.canonicalName}`;
     }
-    /** @returns the children of the node in order of appearance, as a read-only view. */
-    getChildren() {
-        return this.children;
+    // ----------------------------------------------------------------
+    // Namespace
+    // ----------------------------------------------------------------
+    /** @returns the namespace this node declares itself, lower-cased, or the empty string if it declares none (and so inherits the parent's). */
+    getDeclaredNamespace() {
+        return this.declaredNamespace;
     }
     /**
-     * Appends an already closed child to this node.
+     * Sets the namespace this node declares. The empty string (or null/undefined) means "none":
+     * the node then inherits the effective namespace of its parent.
      *
-     * @param node already closed child to append at the end of this node's list of children.
+     * @param namespace namespace to declare, or null/undefined/empty for none.
+     * @throws ParseException if the namespace does not have a valid format (STXT-SPEC §7).
      */
-    addChild(node) {
-        this.children.push(node);
+    setNamespace(namespace) {
+        const lower = StringUtils_1.StringUtils.lowerCase(namespace);
+        NamespaceValidator_1.NamespaceValidator.validateNamespaceFormat(lower, this.line);
+        this.declaredNamespace = lower;
     }
-    /** @returns the inline value of the node (INLINE node), or the empty string if it is a BLOCK node. */
-    getValue() {
-        return this.value;
-    }
-    /** @returns the text lines of a BLOCK node ({@link Node.isTextNode}), in order of appearance. */
-    getTextLines() {
-        return this.textLines;
+    /** @returns the effective namespace of the node: the one it declares or, failing that, the effective namespace of its parent; the empty string if there is none. */
+    getNamespace() {
+        if (this.declaredNamespace.length > 0) {
+            return this.declaredNamespace;
+        }
+        return this.parent ? this.parent.getNamespace() : "";
     }
-    /** @returns the line number of the document where this node was opened. */
+    // ----------------------------------------------------------------
+    // Position in the source
+    // ----------------------------------------------------------------
+    /** @returns the line number of the document where this node was opened, or {@link Node.NO_LINE} if unknown. */
     getLine() {
         return this.line;
     }
-    /** @returns the indentation level of the node (0 for root nodes). */
-    getLevel() {
-        return this.level;
+    /**
+     * Sets the source line of the node.
+     *
+     * @param line line number, or {@link Node.NO_LINE} if unknown.
+     */
+    setLine(line) {
+        this.line = line;
     }
-    /** @returns true if the node is a text block (BLOCK, `>>`); false if it is INLINE. */
-    isTextNode() {
-        return this.textNode;
+    /** @returns the depth of the node in its tree: 0 for a root node, 1 for its children, and so on. */
+    getLevel() {
+        let level = 0;
+        for (let p = this.parent; p !== null; p = p.getParent()) {
+            level++;
+        }
+        return level;
     }
-    /** @returns the textual content of the node: the text lines joined with '\n' if it is BLOCK, or the inline value otherwise. */
-    getText() {
-        return this.isTextNode() ? this.textLines.join("\n") : this.value;
+    // ----------------------------------------------------------------
+    // Tree
+    // ----------------------------------------------------------------
+    /** @returns the parent of this node, or null if it is a root node. */
+    getParent() {
+        return this.parent;
     }
     /**
-     * Looks up the only direct child with that name.
+     * Removes this node from its parent, if it has one. Afterwards the node is a root, and its
+     * effective namespace is the one it declares.
      *
-     * @param cname name of the child to look for.
-     * @param namespace namespace to search in; this node's own namespace when omitted.
-     * @returns the only direct child with that name, or null if there is none.
-     * @throws RuntimeException with code `AMBIGUOUS_CHILD` if there is more than one; use {@link Node.getChildrenByName} then.
+     * @returns true if the node had a parent and was detached; false if it was already a root.
      */
-    getChild(cname, namespace) {
-        const result = this.getChildrenByName(cname, namespace);
-        if (result.length > 1) {
-            throw new RuntimeException_1.RuntimeException("AMBIGUOUS_CHILD", "More than 1 child. Use getChildren");
-        }
-        if (result.length === 0) {
-            return null;
+    detach() {
+        if (this.parent === null) {
+            return false;
         }
-        return result[0];
+        return this.parent.removeChild(this);
     }
-    // Fast access methods to children
     /**
-     * Looks up every direct child with that name.
-     *
-     * @param cname name of the child to look for.
-     * @param namespace namespace to search in; this node's own namespace when omitted.
-     * @returns every direct child with that name in the given namespace, in order of appearance.
+     * Both ends of the link are kept in sync by {@link InlineNode}; nobody else calls this.
+     * @internal
      */
-    getChildrenByName(cname, namespace) {
-        const key = StringUtils_1.StringUtils.normalize(cname);
-        const targetNamespace = namespace !== undefined ? namespace : this.namespace;
-        const result = [];
-        for (const child of this.children) {
-            if (child.getNormalizedName() === key && child.getNamespace() === targetNamespace) {
-                result.push(child);
-            }
-        }
-        return result;
+    _setParent(parent) {
+        this.parent = parent;
     }
     /** @returns a readable representation of the node, for debugging and error messages. */
     toString() {
-        let s = "Node{";
-        s += `line=${this.line}`;
-        s += `, level=${this.level}`;
-        s += `, name='${this.name}'`;
-        if (this.namespace.length > 0) {
-            s += `, ns='${this.namespace}'`;
-        }
-        s += `, text=${this.textNode}`;
-        if (!this.textNode && this.value.length > 0) {
-            s += `, value='${this.value}'`;
+        let s = `${this.constructor.name}{`;
+        if (this.line !== Node.NO_LINE) {
+            s += `line=${this.line}, `;
         }
-        if (this.textNode) {
-            s += `, lines=${this.textLines.length}`;
+        s += `name='${this.name}'`;
+        const namespace = this.getNamespace();
+        if (namespace.length > 0) {
+            s += `, ns='${namespace}'`;
         }
-        s += `, children=${this.children.length}`;
+        s += this.describe();
         s += "}";
         return s;
     }
 }
 exports.Node = Node;
+/** Value of {@link Node.getLine} when the node has no known position in a document. */
+Node.NO_LINE = -1;
 //# sourceMappingURL=Node.js.map

package/out/core/NodeCreator.d.ts

@@ -2,13 +2,13 @@ import { Line } from "./Line";
 import { Node } from "./Node";
 /**
  * Builds the node a line opens, telling apart the INLINE form (`Name: value`) from the BLOCK one
- * (`Name >>`) and resolving the namespace against the parent.
+ * (`Name >>`). The node gets the namespace the line *declares*, if any; inheritance from the
+ * parent is resolved by the node itself through its parent link once it is attached
+ * ({@link Node.getNamespace}).
  *
  * @param lineIndent line already split into indentation and content.
  * @param lineNumber line number of the document where the node opens.
- * @param level indentation level of the node.
- * @param parent node currently open, whose namespace is inherited, or null at root level.
- * @returns the node the line opens, still with no children and no text lines.
+ * @returns the node the line opens, still detached, with no children and no text lines.
  * @throws ParseException if the line is not a valid node declaration.
  */
-export declare function createNode(lineIndent: Line, lineNumber: number, level: number, parent: Node | null): Node;
+export declare function createNode(lineIndent: Line, lineNumber: number): Node;

package/out/core/NodeCreator.js

@@ -2,21 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNode = createNode;
 const NameNamespaceParser_1 = require("./NameNamespaceParser");
-const Node_1 = require("./Node");
+const InlineNode_1 = require("./InlineNode");
+const TextNode_1 = require("./TextNode");
 const ParseException_1 = require("../exceptions/ParseException");
 const Constants_1 = require("./Constants");
 /**
  * Builds the node a line opens, telling apart the INLINE form (`Name: value`) from the BLOCK one
- * (`Name >>`) and resolving the namespace against the parent.
+ * (`Name >>`). The node gets the namespace the line *declares*, if any; inheritance from the
+ * parent is resolved by the node itself through its parent link once it is attached
+ * ({@link Node.getNamespace}).
  *
  * @param lineIndent line already split into indentation and content.
  * @param lineNumber line number of the document where the node opens.
- * @param level indentation level of the node.
- * @param parent node currently open, whose namespace is inherited, or null at root level.
- * @returns the node the line opens, still with no children and no text lines.
+ * @returns the node the line opens, still detached, with no children and no text lines.
  * @throws ParseException if the line is not a valid node declaration.
  */
-function createNode(lineIndent, lineNumber, level, parent) {
+function createNode(lineIndent, lineNumber) {
     const line = lineIndent.content;
     let name;
     let value;
@@ -49,8 +50,8 @@ function createNode(lineIndent, lineNumber, level, parent) {
     if (textNode && value.trim().length > 0) {
         throw new ParseException_1.ParseException(lineNumber, "INLINE_VALUE_NOT_VALID", `Line not valid: ${line}`);
     }
-    // Default namespace: inherited from the parent
-    const nameNamespace = NameNamespaceParser_1.NameNamespaceParser.parse(name, parent ? parent.getNamespace() : null, lineNumber, line);
+    // The namespace the line declares, if any (empty when it inherits)
+    const nameNamespace = NameNamespaceParser_1.NameNamespaceParser.parse(name, null, lineNumber, line);
     name = nameNamespace.getName();
     const namespace = nameNamespace.getNamespace();
     // Validate the name
@@ -58,6 +59,8 @@ function createNode(lineIndent, lineNumber, level, parent) {
         throw new ParseException_1.ParseException(lineNumber, "INVALID_LINE", `Line not valid: ${line}`);
     }
     // Create the node
-    return new Node_1.Node(lineNumber, level, name, namespace, textNode, value);
+    return textNode
+        ? new TextNode_1.TextNode(name, namespace, null, lineNumber)
+        : new InlineNode_1.InlineNode(name, namespace, value, lineNumber);
 }
 //# sourceMappingURL=NodeCreator.js.map

package/out/core/Parser.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
+const TextNode_1 = require("./TextNode");
 const LineParser_1 = require("./LineParser");
 const NodeCreator_1 = require("./NodeCreator");
 const ParseResult_1 = require("./ParseResult");
@@ -72,7 +73,7 @@ class Parser {
             this.processLine(line, lineNumber, stack, documents, result);
         }
         // Close every node still open at EOF
-        this.closeToLevel(stack, documents, 0, result);
+        this.closeToLevel(stack, 0, result);
         // Add the nodes to the result
         for (const doc of documents) {
             result.addNode(doc);
@@ -83,8 +84,9 @@ class Parser {
     processLine(lineString, lineNumber, stack, documents, result) {
         try {
             const lastNode = stack.length === 0 ? null : stack[stack.length - 1];
-            const lastLevel = lastNode ? lastNode.getLevel() : 0;
-            const lastNodeText = lastNode ? lastNode.isTextNode() : false;
+            // The stack holds the open nodes, one per level: its size is the level of the next line's parent
+            const lastLevel = lastNode ? stack.length - 1 : 0;
+            const lastNodeText = lastNode instanceof TextNode_1.TextNode;
             // Parse the line
             const line = (0, LineParser_1.parseLine)(lineString, lastNodeText, lastLevel, lineNumber);
             if (line.isComment) {
@@ -98,10 +100,11 @@ class Parser {
             // When we are inside a text node and the level says it is still text,
             // append the text line instead of creating a node.
             if (line.isBlock) {
-                lastNode.addTextLine(line.content);
+                const textNode = lastNode;
+                textNode.addTextLine(line.content);
                 // Notify the observers about the text line
                 this.observers.forEach(observer => {
-                    observer.onTextLine(lastNode, lineNumber, lineString, line);
+                    observer.onTextLine(textNode, lineNumber, lineString, line);
                 });
                 return;
             }
@@ -109,11 +112,20 @@ class Parser {
             if (line.isEmpty()) {
                 return;
             }
-            // Close the nodes down to the current level (this "finishes" them and attaches them to the parent/documents)
-            this.closeToLevel(stack, documents, currentLevel, result);
-            // Create the new node and leave it "open" on the stack (do NOT attach it yet)
+            // Close the nodes down to the current level (this "finishes" them: validators and observers run)
+            this.closeToLevel(stack, currentLevel, result);
+            // Create the new node, attach it to its parent (or to the documents if it is a root)
+            // and leave it "open" on the stack. Attaching links both ends: the node already knows
+            // its parent, and so its effective namespace and its level, when the observers see it.
+            // The parent is always an InlineNode: a TextNode on top of the stack only takes text lines.
             const parent = stack.length === 0 ? null : stack[stack.length - 1];
-            const node = (0, NodeCreator_1.createNode)(line, lineNumber, currentLevel, parent);
+            const node = (0, NodeCreator_1.createNode)(line, lineNumber);
+            if (parent === null) {
+                documents.push(node);
+            }
+            else {
+                parent.addChild(node);
+            }
             // Hand it over to the observers
             this.observers.forEach(observer => {
                 observer.onCreate(node, lineString);
@@ -138,7 +150,7 @@ class Parser {
             result.addError(new ParseException_1.ParseException(line, unknownErrorCode, String(e)));
         }
     }
-    closeToLevel(stack, documents, targetLevel, result) {
+    closeToLevel(stack, targetLevel, result) {
         while (stack.length > targetLevel) {
             const completed = stack.pop();
             // Hand it over to the validators
@@ -153,12 +165,6 @@ class Parser {
                     this.handleError(e, completed.getLine(), result, "VALIDATION_ERROR", "UNKNOWN_VALIDATION_ERROR");
                 }
             });
-            if (stack.length === 0) {
-                documents.push(completed);
-            }
-            else {
-                stack[stack.length - 1].addChild(completed);
-            }
             // Hand it over to the observers
             this.observers.forEach(observer => {
                 observer.onFinish(completed);

package/out/core/TextNode.d.ts

@@ -0,0 +1,63 @@
+import { Node } from "./Node";
+/**
+ * BLOCK text node of the STXT tree (`Name >>`): an ordered list of literal text lines. It has no
+ * inline value and no children; its content is only text.
+ *
+ * Overloads with two strings always take the second one as the *content* (the text); the
+ * namespace only exists in the three-argument forms.
+ */
+export declare class TextNode extends Node {
+    private readonly lines;
+    /**
+     * Creates an empty text node with no declared namespace and no known source line.
+     *
+     * @param name name of the node.
+     */
+    constructor(name: string);
+    /**
+     * Creates a text node with its text, no declared namespace and no known source line.
+     *
+     * @param name name of the node.
+     * @param text text of the node (split into lines at every line break), or its lines.
+     */
+    constructor(name: string, text: string | ReadonlyArray<string> | null | undefined);
+    /**
+     * Creates a text node with a declared namespace and its text; the source line is optional.
+     * This is the form the {@link Parser} uses (with no text yet: it appends the lines with
+     * {@link TextNode.addTextLine}).
+     *
+     * @param name name of the node.
+     * @param namespace namespace the node declares, or null/undefined/empty for none.
+     * @param text text of the node (split into lines at every line break), or its lines.
+     * @param line source line, or {@link Node.NO_LINE} (the default).
+     * @throws ParseException if the name or the namespace are not valid.
+     */
+    constructor(name: string, namespace: string | null | undefined, text: string | ReadonlyArray<string> | null | undefined, line?: number);
+    /** @returns the text lines of the node, in order, as a read-only view. */
+    getTextLines(): ReadonlyArray<string>;
+    /**
+     * Replaces the whole text of the node.
+     *
+     * @param text new text, split into lines at every line break (LF or CRLF), or the lines
+     *        themselves; null/undefined empties the node.
+     */
+    setText(text: string | ReadonlyArray<string> | null | undefined): void;
+    /**
+     * Replaces the whole text of the node with the given lines.
+     *
+     * @param lines new text lines; null/undefined empties the node.
+     */
+    setTextLines(lines: ReadonlyArray<string> | null | undefined): void;
+    /**
+     * Appends a text line.
+     *
+     * @param line text line to append.
+     */
+    addTextLine(line: string): void;
+    /** Removes every text line. */
+    clearText(): void;
+    getText(): string;
+    isTextNode(): boolean;
+    private static splitLines;
+    protected describe(): string;
+}

package/out/core/TextNode.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextNode = void 0;
+const Node_1 = require("./Node");
+/**
+ * BLOCK text node of the STXT tree (`Name >>`): an ordered list of literal text lines. It has no
+ * inline value and no children; its content is only text.
+ *
+ * Overloads with two strings always take the second one as the *content* (the text); the
+ * namespace only exists in the three-argument forms.
+ */
+class TextNode extends Node_1.Node {
+    constructor(name, ...rest) {
+        // With two arguments the second one is the text; the namespace only exists with three or more
+        const [namespace, text, line] = rest.length <= 1
+            ? [null, rest[0], Node_1.Node.NO_LINE]
+            : [rest[0], rest[1], rest[2] ?? Node_1.Node.NO_LINE];
+        super(name, namespace, line);
+        this.lines = [];
+        this.setText(text);
+    }
+    // ----------------------------------------------------------------
+    // Text
+    // ----------------------------------------------------------------
+    /** @returns the text lines of the node, in order, as a read-only view. */
+    getTextLines() {
+        return this.lines;
+    }
+    /**
+     * Replaces the whole text of the node.
+     *
+     * @param text new text, split into lines at every line break (LF or CRLF), or the lines
+     *        themselves; null/undefined empties the node.
+     */
+    setText(text) {
+        this.lines.length = 0;
+        if (typeof text === "string") {
+            this.lines.push(...TextNode.splitLines(text));
+        }
+        else if (text) {
+            this.lines.push(...text);
+        }
+    }
+    /**
+     * Replaces the whole text of the node with the given lines.
+     *
+     * @param lines new text lines; null/undefined empties the node.
+     */
+    setTextLines(lines) {
+        this.setText(lines);
+    }
+    /**
+     * Appends a text line.
+     *
+     * @param line text line to append.
+     */
+    addTextLine(line) {
+        this.lines.push(line);
+    }
+    /** Removes every text line. */
+    clearText() {
+        this.lines.length = 0;
+    }
+    getText() {
+        return this.lines.join("\n");
+    }
+    isTextNode() {
+        return true;
+    }
+    // LF or CRLF; the trailing part after the last break is a line too (possibly empty)
+    static splitLines(text) {
+        return text.split(/\r?\n/);
+    }
+    describe() {
+        return `, lines=${this.lines.length}`;
+    }
+}
+exports.TextNode = TextNode;
+//# sourceMappingURL=TextNode.js.map

package/out/processors/Observer.d.ts

@@ -1,5 +1,6 @@
 import { Line } from "../core/Line";
 import { Node } from "../core/Node";
+import { TextNode } from "../core/TextNode";
 /**
  * Process hook notified by the {@link Parser} while parsing: when each node is opened and closed,
  * and for every comment and text line it reads. Register it with {@link Parser.registerObserver}.
@@ -33,5 +34,5 @@ export interface Observer {
      * @param lineString source line, as it appears in the document.
      * @param line the same line already split into indentation and content.
      */
-    onTextLine(node: Node, lineNumber: number, lineString: string, line: Line): void;
+    onTextLine(node: TextNode, lineNumber: number, lineString: string, line: Line): void;
 }