@stxt-lang/core 0.8.0 → 0.9.0

package/out/core/InlineNode.js

@@ -37,7 +37,7 @@ class InlineNode extends Node_1.Node {
      * @param value new value, or null/undefined for none. It is trimmed.
      */
     setValue(value) {
-        this.value = (value ?? "").trim();
+        this.value = StringUtils_1.StringUtils.trim(value);
     }
     getText() {
         return this.value;

package/out/core/Line.d.ts

@@ -8,7 +8,10 @@ export declare class Line {
     readonly level: number;
     /** Content of the line with the indentation already removed. */
     readonly content: string;
-    /** True if the line is a comment (`#`). */
+    /**
+     * True if the line is a comment (`#`). Its indentation has already been validated like a
+     * node's (spec 9), but it produces no node and never moves the hierarchy.
+     */
     readonly isComment: boolean;
     /** True if the line is a text line belonging to an open BLOCK node (`>>`). */
     readonly isBlock: boolean;
@@ -24,6 +27,6 @@ export declare class Line {
      * @param indentLength number of characters the indentation took up.
      */
     constructor(level: number, content: string, isComment: boolean, isBlock: boolean, indentLength: number);
-    /** @returns true if the line has no content beyond whitespace. */
+    /** @returns true if the line has no content beyond blanks (space/tab only, spec 4). */
     isEmpty(): boolean;
 }

package/out/core/Line.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Line = void 0;
+const StringUtils_1 = require("./StringUtils");
 /**
  * A source line already split into its indentation and its content, as produced by
  * {@link parseLine}. It is what tells the {@link Parser} whether the line opens a node, continues
@@ -23,9 +24,9 @@ class Line {
         this.isBlock = isBlock;
         this.indentLength = indentLength;
     }
-    /** @returns true if the line has no content beyond whitespace. */
+    /** @returns true if the line has no content beyond blanks (space/tab only, spec 4). */
     isEmpty() {
-        return this.content.trim() === "";
+        return StringUtils_1.StringUtils.trim(this.content) === "";
     }
 }
 exports.Line = Line;

package/out/core/LineParser.d.ts

@@ -5,7 +5,10 @@ import { Line } from "./Line";
  *
  * Indentation is one level per tab or per {@link Constants.TAB_SPACES} spaces; mixing both, using
  * a number of spaces that is not a multiple of four or going more than one level deeper than the
- * previous node are errors (spec 8.1 and 8.3).
+ * previous node are errors (spec 8.1 and 8.3). Comment lines are validated exactly like node lines
+ * (spec 9 and 11): they produce no node and never move the hierarchy, but their indentation must
+ * be homogeneous, a multiple of four when spaces, and at most one level deeper than the last node.
+ * Only empty lines are exempt.
  *
  * @param line source line, with its indentation.
  * @param lastNodeBlock true if the node currently open is a BLOCK text node.

package/out/core/LineParser.js

@@ -11,7 +11,10 @@ const Line_1 = require("./Line");
  *
  * Indentation is one level per tab or per {@link Constants.TAB_SPACES} spaces; mixing both, using
  * a number of spaces that is not a multiple of four or going more than one level deeper than the
- * previous node are errors (spec 8.1 and 8.3).
+ * previous node are errors (spec 8.1 and 8.3). Comment lines are validated exactly like node lines
+ * (spec 9 and 11): they produce no node and never move the hierarchy, but their indentation must
+ * be homogeneous, a multiple of four when spaces, and at most one level deeper than the last node.
+ * Only empty lines are exempt.
  *
  * @param line source line, with its indentation.
  * @param lastNodeBlock true if the node currently open is a BLOCK text node.
@@ -28,6 +31,7 @@ function parseLine(line, lastNodeBlock, lastLevel, numLine, validate = true) {
     let pointer = 0;
     let sawSpace = false;
     let sawTab = false;
+    let isComment = false;
     while (pointer < line.length) {
         const c = line.charAt(pointer);
         if (c === Constants_1.Constants.SPACE) {
@@ -44,7 +48,13 @@ function parseLine(line, lastNodeBlock, lastLevel, numLine, validate = true) {
             spaces = 0;
         }
         else if (c === Constants_1.Constants.COMMENT_CHAR) {
-            return new Line_1.Line(level, line.substring(pointer + 1), true, false, pointer);
+            // Comment line: produces no node, but its indentation is validated below exactly like
+            // a node's (spec 9). Reached only when the line is not block text (a '#' deeper than an
+            // open block is caught as text by the check below, before getting here), so inside an
+            // open block a comment always has indent <= the block node: the Parser closes the block
+            // (spec 9.1) and hands the comment over to the observers.
+            isComment = true;
+            break;
         }
         else {
             // First character that is not space/tab/comment => end of indentation
@@ -79,11 +89,17 @@ function parseLine(line, lastNodeBlock, lastLevel, numLine, validate = true) {
     if (validate && spaces > 0) {
         throw new ParseException_1.ParseException(numLine, "INVALID_NUMBER_SPACES", `There are ${spaces} spaces before node`);
     }
-    // Validate the level
+    // Validate the level (spec 11.3). Comments included (spec 9): lastLevel is the level of the
+    // last NODE, a comment never becomes the reference.
     if (validate && level > lastLevel + 1) {
         throw new ParseException_1.ParseException(numLine, "INDENTATION_LEVEL_NOT_VALID", `Level of indent incorrect: ${level}`);
     }
+    // Comment: the text after '#', verbatim
+    if (isComment) {
+        return new Line_1.Line(level, line.substring(pointer + 1), true, false, pointer);
+    }
     // General case: return the line without the indentation already consumed
-    return new Line_1.Line(level, line.substring(pointer).trim(), false, false, pointer);
+    // Blank-only trim (spec 4): an NBSP after the value is part of it
+    return new Line_1.Line(level, StringUtils_1.StringUtils.trim(line.substring(pointer)), false, false, pointer);
 }
 //# sourceMappingURL=LineParser.js.map

package/out/core/NameNamespaceParser.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NameNamespaceParser = void 0;
 const ParseException_1 = require("../exceptions/ParseException");
 const NameNamespace_1 = require("./NameNamespace");
+const StringUtils_1 = require("./StringUtils");
 /** Extracts the name and the namespace `(a.b.c)` from the left-hand side of an STXT line. */
 class NameNamespaceParser {
     constructor() {
@@ -21,7 +22,7 @@ class NameNamespaceParser {
         if (rawName === null || rawName === undefined) {
             throw new ParseException_1.ParseException(lineNumber, "INVALID_LINE", `Line not valid: ${fullLine}`);
         }
-        rawName = rawName.trim();
+        rawName = StringUtils_1.StringUtils.trim(rawName);
         const startIndex = rawName.indexOf("(");
         const endIndex = rawName.indexOf(")");
         let name;
@@ -31,7 +32,7 @@ class NameNamespaceParser {
             if (startIndex > endIndex || endIndex !== rawName.length - 1) {
                 throw new ParseException_1.ParseException(lineNumber, "INVALID_NAMESPACE", `Line not valid: ${fullLine}`);
             }
-            name = rawName.substring(0, startIndex).trim();
+            name = StringUtils_1.StringUtils.trim(rawName.substring(0, startIndex));
             // No trim: the grammar (STXT-SPEC 7/16) does not allow spaces inside '( )'
             namespace = rawName.substring(startIndex + 1, endIndex);
             if (namespace.length === 0) {

package/out/core/NodeCreator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNode = createNode;
+const StringUtils_1 = require("./StringUtils");
 const NameNamespaceParser_1 = require("./NameNamespaceParser");
 const InlineNode_1 = require("./InlineNode");
 const TextNode_1 = require("./TextNode");
@@ -47,7 +48,7 @@ function createNode(lineIndent, lineNumber) {
         name = line.substring(0, nodeIndex);
         value = line.substring(nodeIndex + Constants_1.Constants.SEP_NODE.length);
     }
-    if (textNode && value.trim().length > 0) {
+    if (textNode && StringUtils_1.StringUtils.trim(value).length > 0) {
         throw new ParseException_1.ParseException(lineNumber, "INLINE_VALUE_NOT_VALID", `Line not valid: ${line}`);
     }
     // The namespace the line declares, if any (empty when it inherits)

package/out/core/Parser.js

@@ -90,6 +90,8 @@ class Parser {
             // Parse the line
             const line = (0, LineParser_1.parseLine)(lineString, lastNodeText, lastLevel, lineNumber);
             if (line.isComment) {
+                // Its indentation was validated by parseLine like a node's (spec 9), but it never
+                // becomes the reference level: the stack (and so lastLevel) is only moved by nodes.
                 // A comment at the level of an open block node (or shallower) closes the block
                 // (spec 6.1 and 9.1): a block is a literal and cannot be commented from inside.
                 // Only the block closes; the comment does not touch the rest of the hierarchy.

package/out/core/StringUtils.d.ts

@@ -2,12 +2,29 @@
 export declare class StringUtils {
     private static readonly NODE_NAME;
     private static readonly NODE_NAME_LETTER_OR_DIGIT;
+    private static readonly LEADING_BLANKS;
+    private static readonly TRAILING_BLANKS;
+    private static readonly BLANK_RUN;
     private constructor();
     /**
-     * Removes the trailing whitespace of a string.
+     * Tells whether a character is an STXT blank (STXT-SPEC 4): space or tab.
      *
-     * @param s string to strip the trailing spaces from.
-     * @returns the string without trailing whitespace; null/undefined is treated as the empty string.
+     * @param c single character.
+     * @returns true for U+0020 and U+0009 only.
+     */
+    static isBlank(c: string): boolean;
+    /**
+     * Removes the leading and trailing blanks (space and tab only, STXT-SPEC 4) of a string.
+     *
+     * @param s string to trim.
+     * @returns the trimmed string; null/undefined is treated as the empty string.
+     */
+    static trim(s: string | null | undefined): string;
+    /**
+     * Removes the trailing blanks (space and tab only, STXT-SPEC 4, 10.2) of a string.
+     *
+     * @param s string to strip the trailing blanks from.
+     * @returns the string without trailing blanks; null/undefined is treated as the empty string.
      */
     static rightTrim(s: string | null | undefined): string;
     /**
@@ -25,10 +42,10 @@ export declare class StringUtils {
      */
     static lowerCase(input: string | null | undefined): string;
     /**
-     * Trims a string and collapses its inner whitespace.
+     * Trims a string and collapses its inner runs of blanks (space and tab only).
      *
      * @param s string to compact.
-     * @returns the string with the outer spaces trimmed and the inner ones collapsed into a single one; null/undefined is treated as the empty string.
+     * @returns the string with the outer blanks trimmed and the inner runs collapsed into a single space; null/undefined is treated as the empty string.
      */
     static compactSpaces(s: string | null | undefined): string;
     /**

package/out/core/StringUtils.js

@@ -5,20 +5,33 @@ exports.StringUtils = void 0;
 class StringUtils {
     constructor() {
     }
+    /**
+     * Tells whether a character is an STXT blank (STXT-SPEC 4): space or tab.
+     *
+     * @param c single character.
+     * @returns true for U+0020 and U+0009 only.
+     */
+    static isBlank(c) {
+        return c === " " || c === "\t";
+    }
+    /**
+     * Removes the leading and trailing blanks (space and tab only, STXT-SPEC 4) of a string.
+     *
+     * @param s string to trim.
+     * @returns the trimmed string; null/undefined is treated as the empty string.
+     */
+    static trim(s) {
+        return (s ?? "").replace(this.LEADING_BLANKS, "").replace(this.TRAILING_BLANKS, "");
+    }
     // Used for name>> nodes
     /**
-     * Removes the trailing whitespace of a string.
+     * Removes the trailing blanks (space and tab only, STXT-SPEC 4, 10.2) of a string.
      *
-     * @param s string to strip the trailing spaces from.
-     * @returns the string without trailing whitespace; null/undefined is treated as the empty string.
+     * @param s string to strip the trailing blanks from.
+     * @returns the string without trailing blanks; null/undefined is treated as the empty string.
      */
     static rightTrim(s) {
-        const value = s ?? "";
-        let i = value.length - 1;
-        while (i >= 0 && /\s/.test(value.charAt(i))) {
-            i--;
-        }
-        return value.substring(0, i + 1);
+        return (s ?? "").replace(this.TRAILING_BLANKS, "");
     }
     // Used for BASE64 and HEXADECIMAL nodes
     /**
@@ -43,13 +56,13 @@ class StringUtils {
     }
     // Used for the name of the nodes
     /**
-     * Trims a string and collapses its inner whitespace.
+     * Trims a string and collapses its inner runs of blanks (space and tab only).
      *
      * @param s string to compact.
-     * @returns the string with the outer spaces trimmed and the inner ones collapsed into a single one; null/undefined is treated as the empty string.
+     * @returns the string with the outer blanks trimmed and the inner runs collapsed into a single space; null/undefined is treated as the empty string.
      */
     static compactSpaces(s) {
-        return (s ?? "").trim().replace(/\s+/g, " ");
+        return this.trim(s).replace(this.BLANK_RUN, " ");
     }
     /**
      * Tells whether a value is a valid STXT node name.
@@ -73,14 +86,14 @@ class StringUtils {
      * @returns the canonical name of a node: NFC + lower case, with separators collapsed into '-'; null/undefined is treated as the empty string.
      */
     static normalize(input) {
-        let s = (input ?? "").trim();
+        let s = this.trim(input);
         if (s.length === 0) {
             return "";
         }
         s = s.normalize("NFC");
         s = s.toLowerCase();
-        // every run of separators ('-', '_', spaces) => a single '-'
-        s = s.replace(/[-_\s]+/g, "-");
+        // every run of separators ('-', '_', blanks) => a single '-'
+        s = s.replace(/[-_ \t]+/g, "-");
         // trim the '-'
         s = s.replace(/^-+|-+$/g, "");
         return s;
@@ -92,4 +105,10 @@ exports.StringUtils = StringUtils;
 // decomposed spelling such as "e" + combining acute is accepted as "é".
 StringUtils.NODE_NAME = /^[\p{L}\p{Nd}\p{Mn}\p{Mc}\-_ ]+$/u;
 StringUtils.NODE_NAME_LETTER_OR_DIGIT = /[\p{L}\p{Nd}]/u;
+// STXT-SPEC 4: a blank is exactly U+0020 or U+0009. Every trim in the core works on
+// these two characters only; String.prototype.trim and /\s/ are deliberately avoided
+// because they also remove NBSP, U+3000, U+2028... which STXT treats as content.
+StringUtils.LEADING_BLANKS = /^[ \t]+/;
+StringUtils.TRAILING_BLANKS = /[ \t]+$/;
+StringUtils.BLANK_RUN = /[ \t]+/g;
 //# sourceMappingURL=StringUtils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stxt-lang/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Parser and schema validator for STXT, an indentation-based structured-text format.",
   "main": "out/all.js",
   "types": "out/all.d.ts",