@stxt-lang/core 0.15.0 → 0.16.0

package/README.md

@@ -1,8 +1,8 @@
 # @stxt-lang/core
 
-Parser and schema validator for **STXT**, an indentation-based structured-text format.
+Parser and schema validator for **STXT**, an indentation-based structured-text language.
 
-STXT is a plain-text format for writing structured, semantic documents: no braces, no closing tags, just indentation. It is designed to be equally readable by humans and by machines, and it comes with an optional schema layer so documents can be validated.
+STXT is a plain-text language for writing structured, semantic documents: no braces, no closing tags, just indentation. It is designed to be equally readable by humans and by machines, and it comes with an optional schema layer so documents can be validated.
 
 - Website and language reference: <https://stxt.dev>
 - VSCode extension: [STXT Language](https://marketplace.visualstudio.com/items?itemName=stxt-lang.stxt)

package/out/core/InlineNode.js

@@ -66,6 +66,7 @@ class InlineNode extends Node_1.Node {
         if (child.getParent() !== null) {
             throw new RuntimeException_1.RuntimeException("NODE_ALREADY_ATTACHED", `Node '${child.getName()}' already has a parent: detach it first`);
         }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- cursor of the ancestor walk, not an alias kept around
         for (let p = this; p !== null; p = p.getParent()) {
             if (p === child) {
                 throw new RuntimeException_1.RuntimeException("NODE_CYCLE", `Node '${child.getName()}' cannot be a child of itself or of one of its descendants`);

package/out/core/NameNamespace.d.ts

@@ -3,11 +3,11 @@ export declare class NameNamespace {
     private readonly name;
     private readonly namespace;
     /**
-     * Creates a resolved name and namespace pair.
-     *
-     * @param name name of the node without the namespace part.
-     * @param namespace resolved namespace (its own or inherited).
-     */
+   * Creates a resolved name and namespace pair.
+   *
+   * @param name name of the node without the namespace part.
+   * @param namespace resolved namespace (its own or inherited).
+   */
     constructor(name: string, namespace: string);
     /** @returns the name of the node, without the namespace part. */
     getName(): string;

package/out/core/NameNamespace.js

@@ -4,11 +4,11 @@ exports.NameNamespace = void 0;
 /** Result of splitting a raw node name into its resolved name and namespace. */
 class NameNamespace {
     /**
-     * Creates a resolved name and namespace pair.
-     *
-     * @param name name of the node without the namespace part.
-     * @param namespace resolved namespace (its own or inherited).
-     */
+   * Creates a resolved name and namespace pair.
+   *
+   * @param name name of the node without the namespace part.
+   * @param namespace resolved namespace (its own or inherited).
+   */
     constructor(name, namespace) {
         this.name = name;
         this.namespace = namespace;

package/out/core/NamespaceValidator.d.ts

@@ -11,13 +11,6 @@ export declare class NamespaceValidator {
      * valid examples: "xxx", "xxx.ddd", "zzz.ttt.ooo", "@xxx", "@xxx.ddd".
      */
     private static readonly NAMESPACE_FORMAT;
-    /**
-     * Validates the format of a namespace.
-     *
-     * @param namespace already normalized namespace to validate; ignored when null or empty.
-     * @param lineNumber line number, for the error message.
-     * @throws ParseException with code `INVALID_NAMESPACE` if it does not match the format.
-     */
     /**
      * Tells whether a namespace matches the format, without throwing.
      *
@@ -25,5 +18,12 @@ export declare class NamespaceValidator {
      * @returns true if it matches the format; false when it is null, empty or malformed.
      */
     static isValid(namespace: string | null | undefined): boolean;
+    /**
+     * Validates the format of a namespace.
+     *
+     * @param namespace already normalized namespace to validate; ignored when null or empty.
+     * @param lineNumber line number, for the error message.
+     * @throws ParseException with code `INVALID_NAMESPACE` if it does not match the format.
+     */
     static validateNamespaceFormat(namespace: string | null | undefined, lineNumber: number): void;
 }

package/out/core/NamespaceValidator.js

@@ -4,13 +4,6 @@ exports.NamespaceValidator = void 0;
 const ParseException_1 = require("../exceptions/ParseException");
 /** Validates the format of STXT `(a.b.c)` namespaces. */
 class NamespaceValidator {
-    /**
-     * Validates the format of a namespace.
-     *
-     * @param namespace already normalized namespace to validate; ignored when null or empty.
-     * @param lineNumber line number, for the error message.
-     * @throws ParseException with code `INVALID_NAMESPACE` if it does not match the format.
-     */
     /**
      * Tells whether a namespace matches the format, without throwing.
      *
@@ -20,6 +13,13 @@ class NamespaceValidator {
     static isValid(namespace) {
         return !!namespace && NamespaceValidator.NAMESPACE_FORMAT.test(namespace);
     }
+    /**
+     * Validates the format of a namespace.
+     *
+     * @param namespace already normalized namespace to validate; ignored when null or empty.
+     * @param lineNumber line number, for the error message.
+     * @throws ParseException with code `INVALID_NAMESPACE` if it does not match the format.
+     */
     static validateNamespaceFormat(namespace, lineNumber) {
         if (!namespace) {
             return;

package/out/core/Parser.d.ts

@@ -100,6 +100,11 @@ export declare class Parser {
      * registered callback fires the same.
      */
     private parseLines;
+    /**
+     * Processes one source line. Errors of this line are collected into the result and the
+     * traversal continues with the next line: returns true to keep going, false when a limit
+     * aborted the parse (its error is already emitted) — parseLines stops on it.
+     */
     private processLine;
     /**
      * Records an error raised while parsing or validating a line. Typed exceptions travel as they

package/out/core/Parser.js

@@ -139,20 +139,18 @@ class Parser {
                 this.emitError(new LimitException_1.LimitException(lineNumber, "LIMIT_INPUT_SIZE_EXCEEDED", `Input larger than ${this.maxInputSize} characters`), result);
                 return;
             }
-            try {
-                this.processLine(line, lineNumber, stack, result);
-            }
-            catch (e) {
-                if (e instanceof LimitException_1.LimitException) {
-                    this.emitError(e, result);
-                    return;
-                }
-                throw e;
+            if (!this.processLine(line, lineNumber, stack, result)) {
+                return; // a limit aborted the parse; its error is already emitted
             }
         }
         // Close every node still open at EOF
         this.closeToLevel(stack, 0, result);
     }
+    /**
+     * Processes one source line. Errors of this line are collected into the result and the
+     * traversal continues with the next line: returns true to keep going, false when a limit
+     * aborted the parse (its error is already emitted) — parseLines stops on it.
+     */
     processLine(lineString, lineNumber, stack, result) {
         try {
             const lastNode = stack.length === 0 ? null : stack[stack.length - 1];
@@ -176,7 +174,7 @@ class Parser {
                 this.observers.forEach(observer => {
                     observer.onComment(lineNumber, lineString);
                 });
-                return;
+                return true;
             }
             const currentLevel = line.level;
             // When we are inside a text node and the level says it is still text,
@@ -188,17 +186,18 @@ class Parser {
                 this.observers.forEach(observer => {
                     observer.onTextLine(textNode, lineNumber, lineString, line);
                 });
-                return;
+                return true;
             }
             // Empty lines are ignored
             if (line.isEmpty()) {
-                return;
+                return true;
             }
             // Nesting limit (spec 11.2): only a node line can open a new level. Comment and
             // block text lines returned above; with the consecutive-level rule this triggers
             // exactly when the first node at level maxNesting opens.
             if (this.maxNesting !== -1 && currentLevel >= this.maxNesting) {
-                throw new LimitException_1.LimitException(lineNumber, "LIMIT_NESTING_EXCEEDED", `Nesting deeper than ${this.maxNesting} levels`);
+                this.emitError(new LimitException_1.LimitException(lineNumber, "LIMIT_NESTING_EXCEEDED", `Nesting deeper than ${this.maxNesting} levels`), result);
+                return false;
             }
             // Close the nodes down to the current level (this "finishes" them: validators and observers run)
             this.closeToLevel(stack, currentLevel, result);
@@ -220,11 +219,9 @@ class Parser {
             stack.push(node);
         }
         catch (e) {
-            if (e instanceof LimitException_1.LimitException) {
-                throw e;
-            }
             this.handleError(e, lineNumber, result);
         }
+        return true;
     }
     /**
      * Records an error raised while parsing or validating a line. Typed exceptions travel as they
@@ -256,7 +253,8 @@ class Parser {
     }
     closeToLevel(stack, targetLevel, result) {
         while (stack.length > targetLevel) {
-            const completed = stack.pop();
+            const completed = stack[stack.length - 1];
+            stack.pop();
             // A closing block node drops its final empty lines (STXT-SPEC §10.3): they are not
             // content, only visual separation or an editor's final line breaks. The validators
             // and observers below already see the trimmed node; onTextLine did fire for these

package/out/core/StringUtils.d.ts

@@ -27,13 +27,6 @@ export declare class StringUtils {
      * @returns the string without trailing blanks; null/undefined is treated as the empty string.
      */
     static rightTrim(s: string | null | undefined): string;
-    /**
-     * Removes every whitespace character of a string.
-     *
-     * @param input string to remove the spaces from.
-     * @returns the string without any whitespace at all.
-     */
-    static cleanSpaces(input: string): string;
     /**
      * Lower-cases a string.
      *

package/out/core/StringUtils.js

@@ -33,16 +33,6 @@ class StringUtils {
     static rightTrim(s) {
         return (s ?? "").replace(this.TRAILING_BLANKS, "");
     }
-    // Used for BASE64 and HEXADECIMAL nodes
-    /**
-     * Removes every whitespace character of a string.
-     *
-     * @param input string to remove the spaces from.
-     * @returns the string without any whitespace at all.
-     */
-    static cleanSpaces(input) {
-        return input.replace(/\s+/g, "");
-    }
     // Used to normalize namespaces
     /**
      * Lower-cases a string.

package/out/discovery/DiscoveryResolver.d.ts

@@ -68,7 +68,7 @@ export declare class DiscoveryResolver {
     private existingUnique;
     private loadLevel;
     private collectFiles;
+    private collectFilesAt;
     private loadFile;
     private loadRootNode;
-    private compile;
 }

package/out/discovery/DiscoveryResolver.js

@@ -4,8 +4,9 @@ exports.DiscoveryResolver = void 0;
 const Parser_1 = require("../core/Parser");
 const StringUtils_1 = require("../core/StringUtils");
 const ParseException_1 = require("../exceptions/ParseException");
+const Schema_1 = require("../schema/Schema");
+const DefinitionCompiler_1 = require("../schema/DefinitionCompiler");
 const SchemaProviderMeta_1 = require("../schema/SchemaProviderMeta");
-const SchemaValidator_1 = require("../schema/SchemaValidator");
 const SchemaParser_1 = require("../schema/SchemaParser");
 const MetaTemplateSchemaProvider_1 = require("../template/MetaTemplateSchemaProvider");
 const TemplateParser_1 = require("../template/TemplateParser");
@@ -17,6 +18,12 @@ const STXT_DIR = ".stxt";
 const STXT_EXTENSION = ".stxt";
 /** Default value of {@link DiscoveryOptions.maxAscent}. */
 const DEFAULT_MAX_ASCENT = 32;
+/**
+ * Maximum depth of the recursive descent through a resolution directory's subtree. An
+ * internal safeguard (STXT-DISCOVERY-SPEC sections 3 and 10) against symlink loops and
+ * pathological trees; not part of the public API.
+ */
+const DEFAULT_MAX_DESCENT = 32;
 /**
  * Reference implementation of STXT-DISCOVERY-SPEC: builds the resolution chain of a
  * document (project ascent, user level, system level, or the `STXT_PATH` override), loads
@@ -135,13 +142,34 @@ class DiscoveryResolver {
         return level;
     }
     // Collects every file under a directory, recursively, sorted by path so that results
-    // and error messages do not depend on the listing order of the file system.
+    // and error messages do not depend on the listing order of the file system. The descent
+    // is bounded by DEFAULT_MAX_DESCENT and tolerant of listing failures (STXT-DISCOVERY-SPEC
+    // sections 3 and 10): a subdirectory that reaches the depth limit or cannot be listed
+    // contributes no files, never an exception. Together with adapters that do not follow
+    // directory symlinks, this stops symlink loops and pathological trees from turning
+    // resolution into unbounded recursion or an escaping error.
     async collectFiles(dir) {
+        return this.collectFilesAt(dir, 0);
+    }
+    async collectFilesAt(dir, depth) {
         const files = [];
-        const entries = [...await this.fs.listDirectory(dir)].sort((a, b) => a.path < b.path ? -1 : 1);
+        // Safeguard against symlink loops and pathological trees (spec section 10): stop
+        // descending once the depth limit is reached.
+        if (depth >= DEFAULT_MAX_DESCENT) {
+            return files;
+        }
+        let entries;
+        try {
+            entries = [...await this.fs.listDirectory(dir)].sort((a, b) => a.path < b.path ? -1 : 1);
+        }
+        catch {
+            // A directory that cannot be listed contributes no files (spec section 3); it
+            // does not stop the resolution of the rest of the level.
+            return files;
+        }
         for (const entry of entries) {
             if (entry.isDirectory) {
-                files.push(...await this.collectFiles(entry.path));
+                files.push(...await this.collectFilesAt(entry.path, depth + 1));
             }
             else {
                 files.push(entry.path);
@@ -179,11 +207,11 @@ class DiscoveryResolver {
         const namespace = node.getNamespace();
         let schema;
         try {
-            if (namespace === "@stxt.template") {
-                schema = this.compile(node, this.templateMeta, TemplateParser_1.transformTemplateNodeToSchema);
+            if (namespace === Schema_1.Schema.TEMPLATE_NAMESPACE) {
+                schema = (0, DefinitionCompiler_1.compileDefinitionNode)(node, this.templateMeta, TemplateParser_1.transformTemplateNodeToSchema);
             }
-            else if (namespace === "@stxt.schema") {
-                schema = this.compile(node, this.schemaMeta, SchemaParser_1.transformNodeToSchema);
+            else if (namespace === Schema_1.Schema.SCHEMA_NAMESPACE) {
+                schema = (0, DefinitionCompiler_1.compileDefinitionNode)(node, this.schemaMeta, SchemaParser_1.transformNodeToSchema);
             }
             else {
                 level.errors.push(new DiscoveryError_1.DiscoveryError(DiscoveryError_1.DiscoveryError.NOT_A_DEFINITION, file, `Root node belongs to '${namespace ?? ""}', not to @stxt.schema or @stxt.template: ${file}`));
@@ -217,15 +245,6 @@ class DiscoveryResolver {
         };
         level.definitions.set(key, definition);
     }
-    // Validates a root node against a meta-schema and transforms it into a Schema,
-    // throwing the first validation error (same policy as UnifiedSchemaProvider).
-    compile(node, meta, transform) {
-        const errors = new SchemaValidator_1.SchemaValidator(meta, true).validate(node);
-        if (errors.length > 0) {
-            throw errors[0];
-        }
-        return transform(node);
-    }
 }
 exports.DiscoveryResolver = DiscoveryResolver;
 //# sourceMappingURL=DiscoveryResolver.js.map

package/out/discovery/DiscoveryResult.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiscoveryResult = void 0;
 const StringUtils_1 = require("../core/StringUtils");
+const Schema_1 = require("../schema/Schema");
 /**
  * The outcome of resolving a document's definitions (STXT-DISCOVERY-SPEC): the chain of
  * levels, the active definition per namespace (nearest level wins) and every resolution
@@ -34,11 +35,12 @@ class DiscoveryResult {
      * @returns the schema of the namespace, or null if the chain has no definition for it.
      */
     getSchema(namespace) {
-        if (namespace === "@stxt.template") {
-            return this.templateMeta.getSchema(namespace);
+        const key = StringUtils_1.StringUtils.lowerCase(namespace);
+        if (key === Schema_1.Schema.TEMPLATE_NAMESPACE) {
+            return this.templateMeta.getSchema(key);
         }
-        else if (namespace === "@stxt.schema") {
-            return this.schemaMeta.getSchema(namespace);
+        else if (key === Schema_1.Schema.SCHEMA_NAMESPACE) {
+            return this.schemaMeta.getSchema(key);
         }
         return this.getDefinition(namespace)?.schema ?? null;
     }

package/out/exceptions/ParseException.d.ts

@@ -3,7 +3,14 @@
  * carries an UPPERCASE code and the line of the document where it was detected.
  */
 export declare class ParseException extends Error {
-    /** Line number of the document where the error was detected. */
+    /**
+     * Line of an error that has no single source line: it concerns the document as a whole
+     * (`SCHEMA_MULTIPLE_ROOTS`) or a condition with no one line to point at (`NODE_DUPLICATED`,
+     * `CHILD_NOT_DEFINED`). The value 0 is part of the conformance surface (the kit asserts it);
+     * it is not `Node.NO_LINE` (-1), which marks nodes built programmatically, never errors.
+     */
+    static readonly NO_LINE = 0;
+    /** Line number of the document where the error was detected, or {@link ParseException.NO_LINE}. */
     readonly line: number;
     /** Error code in UPPERCASE (e.g. `INVALID_LINE`). */
     readonly code: string;

package/out/exceptions/ParseException.js

@@ -32,4 +32,11 @@ class ParseException extends Error {
     }
 }
 exports.ParseException = ParseException;
+/**
+ * Line of an error that has no single source line: it concerns the document as a whole
+ * (`SCHEMA_MULTIPLE_ROOTS`) or a condition with no one line to point at (`NODE_DUPLICATED`,
+ * `CHILD_NOT_DEFINED`). The value 0 is part of the conformance surface (the kit asserts it);
+ * it is not `Node.NO_LINE` (-1), which marks nodes built programmatically, never errors.
+ */
+ParseException.NO_LINE = 0;
 //# sourceMappingURL=ParseException.js.map

package/out/runtime/UnifiedSchemaProvider.d.ts

@@ -30,9 +30,7 @@ export declare class UnifiedSchemaProvider implements SchemaProvider {
      *         a schema or a template does not validate against its meta-schema.
      */
     addFile(text: string): void;
-    private addTemplateNode;
-    private addSchemaNode;
-    private static throwIfInvalid;
+    private addNode;
     /** Removes every schema and template registered in this provider. */
     clear(): void;
     /** @returns every schema registered in this provider, in registration order. */

package/out/runtime/UnifiedSchemaProvider.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiedSchemaProvider = void 0;
 const Parser_1 = require("../core/Parser");
 const StringUtils_1 = require("../core/StringUtils");
+const Schema_1 = require("../schema/Schema");
+const DefinitionCompiler_1 = require("../schema/DefinitionCompiler");
 const SchemaProviderMeta_1 = require("../schema/SchemaProviderMeta");
 const SchemaParser_1 = require("../schema/SchemaParser");
-const SchemaValidator_1 = require("../schema/SchemaValidator");
 const MetaTemplateSchemaProvider_1 = require("../template/MetaTemplateSchemaProvider");
 const TemplateParser_1 = require("../template/TemplateParser");
 /**
@@ -31,14 +32,13 @@ class UnifiedSchemaProvider {
      */
     getSchema(namespace) {
         const key = StringUtils_1.StringUtils.lowerCase(namespace);
-        if (namespace === "@stxt.template") {
+        if (key === Schema_1.Schema.TEMPLATE_NAMESPACE) {
             return this.templateMeta.getSchema(key);
         }
-        else if (namespace === "@stxt.schema") {
+        else if (key === Schema_1.Schema.SCHEMA_NAMESPACE) {
             return this.schemaMeta.getSchema(key);
         }
-        let result = this.schemas.get(key);
-        return result;
+        return this.schemas.get(key);
     }
     /**
      * Parses a document and registers every schema or template it defines, each one under its own
@@ -53,37 +53,19 @@ class UnifiedSchemaProvider {
         const nodes = parser.parse(text);
         for (const node of nodes) {
             const namespace = node.getNamespace();
-            if (namespace === "@stxt.template") {
-                this.addTemplateNode(node);
+            if (namespace === Schema_1.Schema.TEMPLATE_NAMESPACE) {
+                this.addNode(node, this.templateMeta, TemplateParser_1.transformTemplateNodeToSchema);
             }
-            else if (namespace === "@stxt.schema") {
-                this.addSchemaNode(node);
+            else if (namespace === Schema_1.Schema.SCHEMA_NAMESPACE) {
+                this.addNode(node, this.schemaMeta, SchemaParser_1.transformNodeToSchema);
             }
         }
     }
-    addTemplateNode(node) {
-        // Validate against the meta-schema of templates
-        const schemaValidator = new SchemaValidator_1.SchemaValidator(this.templateMeta, true);
-        UnifiedSchemaProvider.throwIfInvalid(schemaValidator.validate(node));
-        // Transform the template into a schema
-        const schema = (0, TemplateParser_1.transformTemplateNodeToSchema)(node);
-        const key = StringUtils_1.StringUtils.lowerCase(schema.getNamespace());
-        this.schemas.set(key, schema);
-    }
-    addSchemaNode(node) {
-        // Validate against the meta-schema of schemas
-        const schemaValidator = new SchemaValidator_1.SchemaValidator(this.schemaMeta, true);
-        UnifiedSchemaProvider.throwIfInvalid(schemaValidator.validate(node));
-        // Transform the node into a schema
-        const schema = (0, SchemaParser_1.transformNodeToSchema)(node);
-        const key = StringUtils_1.StringUtils.lowerCase(schema.getNamespace());
-        this.schemas.set(key, schema);
-    }
-    // A schema/template that does not validate against its meta-schema must not be loaded
-    static throwIfInvalid(errors) {
-        if (errors.length > 0) {
-            throw errors[0];
-        }
+    // Compiles a definition root through the shared pipeline (see DefinitionCompiler)
+    // and registers it; a definition that does not validate is never registered.
+    addNode(node, meta, transform) {
+        const schema = (0, DefinitionCompiler_1.compileDefinitionNode)(node, meta, transform);
+        this.schemas.set(StringUtils_1.StringUtils.lowerCase(schema.getNamespace()), schema);
     }
     /** Removes every schema and template registered in this provider. */
     clear() {

package/out/schema/DefinitionCompiler.d.ts

@@ -0,0 +1,27 @@
+import { Node } from "../core/Node";
+import { Schema } from "./Schema";
+import { SchemaProvider } from "./SchemaProvider";
+/**
+ * Validates one root node against the meta provider of its kind and compiles it into a
+ * {@link Schema}.
+ *
+ * @param node root node of the definition (`Schema (@stxt.schema)` or `Template (@stxt.template)`).
+ * @param meta provider of the meta-schema of the kind.
+ * @param transform function that turns the validated node into a Schema.
+ * @returns the compiled schema.
+ * @throws ValidationException the first validation finding, if the node does not validate.
+ */
+export declare function compileDefinitionNode(node: Node, meta: SchemaProvider, transform: (node: Node) => Schema): Schema;
+/**
+ * Parses a whole document that must hold exactly one definition, and compiles it.
+ *
+ * @param text text of the definition document.
+ * @param meta provider of the meta-schema of the kind.
+ * @param transform function that turns the validated root into a Schema.
+ * @param multipleRootsCode error code when the document does not hold exactly one root
+ *        (`SCHEMA_MULTIPLE_ROOTS` for schemas, `TEMPLATE_MULTIPLE_ROOTS` for templates).
+ * @param kind word naming the kind in the error message (`schema` or `template`).
+ * @returns the compiled schema.
+ * @throws ParseException or ValidationException if the document is not a valid definition.
+ */
+export declare function compileDefinitionDocument(text: string, meta: SchemaProvider, transform: (node: Node) => Schema, multipleRootsCode: string, kind: string): Schema;

package/out/schema/DefinitionCompiler.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileDefinitionNode = compileDefinitionNode;
+exports.compileDefinitionDocument = compileDefinitionDocument;
+const Parser_1 = require("../core/Parser");
+const ParseException_1 = require("../exceptions/ParseException");
+const ValidationException_1 = require("../exceptions/ValidationException");
+const SchemaValidator_1 = require("./SchemaValidator");
+/*
+ * The one pipeline every definition loader shares, whatever the store: the in-memory
+ * providers (a document each), UnifiedSchemaProvider (several roots per file) and
+ * discovery. A definition node is validated against the meta-schema of its kind and,
+ * only when valid, transformed into a Schema; a definition that does not validate is
+ * never registered anywhere — the first validation finding is thrown instead.
+ * Mirrors stxt-impl/schema/definition_compiler.txt.
+ */
+/**
+ * Validates one root node against the meta provider of its kind and compiles it into a
+ * {@link Schema}.
+ *
+ * @param node root node of the definition (`Schema (@stxt.schema)` or `Template (@stxt.template)`).
+ * @param meta provider of the meta-schema of the kind.
+ * @param transform function that turns the validated node into a Schema.
+ * @returns the compiled schema.
+ * @throws ValidationException the first validation finding, if the node does not validate.
+ */
+function compileDefinitionNode(node, meta, transform) {
+    const errors = new SchemaValidator_1.SchemaValidator(meta, true).validate(node);
+    if (errors.length > 0) {
+        throw errors[0];
+    }
+    return transform(node);
+}
+/**
+ * Parses a whole document that must hold exactly one definition, and compiles it.
+ *
+ * @param text text of the definition document.
+ * @param meta provider of the meta-schema of the kind.
+ * @param transform function that turns the validated root into a Schema.
+ * @param multipleRootsCode error code when the document does not hold exactly one root
+ *        (`SCHEMA_MULTIPLE_ROOTS` for schemas, `TEMPLATE_MULTIPLE_ROOTS` for templates).
+ * @param kind word naming the kind in the error message (`schema` or `template`).
+ * @returns the compiled schema.
+ * @throws ParseException or ValidationException if the document is not a valid definition.
+ */
+function compileDefinitionDocument(text, meta, transform, multipleRootsCode, kind) {
+    const nodes = new Parser_1.Parser().parse(text);
+    if (nodes.length !== 1) {
+        throw new ValidationException_1.ValidationException(ParseException_1.ParseException.NO_LINE, multipleRootsCode, `A ${kind} document must hold exactly 1 root node, got ${nodes.length}`);
+    }
+    return compileDefinitionNode(nodes[0], meta, transform);
+}
+//# sourceMappingURL=DefinitionCompiler.js.map

package/out/schema/NodeDefinition.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeDefinition = void 0;
+const ParseException_1 = require("../exceptions/ParseException");
 const ValidationException_1 = require("../exceptions/ValidationException");
 const StringUtils_1 = require("../core/StringUtils");
 /**
@@ -65,7 +66,7 @@ class NodeDefinition {
     addChildDefinition(childDefinition) {
         const qname = childDefinition.getQualifiedName();
         if (this.children.has(qname)) {
-            throw new ValidationException_1.ValidationException(0, "CHILD_DUPLICATED", `Exists a previous node definition with: ${qname}`);
+            throw new ValidationException_1.ValidationException(ParseException_1.ParseException.NO_LINE, "CHILD_DUPLICATED", `A child declaration with the same name already exists: ${qname}`);
         }
         this.children.set(qname, childDefinition);
     }
@@ -80,9 +81,11 @@ class NodeDefinition {
      * @throws ValidationException with code `VALUE_DUPLICATED` if the value (once trimmed) had already been added.
      */
     addValue(value, line) {
-        const trimmed = value?.trim() ?? "";
+        // Language blanks only (U+0020/U+0009): any other whitespace (NBSP...) is part of
+        // the value, so `x` and `x<NBSP>` are two different ENUM values, as in every port.
+        const trimmed = StringUtils_1.StringUtils.trim(value ?? "");
         if (this.values.has(trimmed)) {
-            throw new ValidationException_1.ValidationException(line ?? 0, "VALUE_DUPLICATED", `The values ${trimmed} is duplicated`);
+            throw new ValidationException_1.ValidationException(line ?? ParseException_1.ParseException.NO_LINE, "VALUE_DUPLICATED", `The value ${trimmed} is duplicated`);
         }
         this.values.add(trimmed);
     }

package/out/schema/Schema.d.ts

@@ -3,6 +3,8 @@ import { NodeDefinition } from "./NodeDefinition";
 export declare class Schema {
     /** Namespace of the schema language itself, `@stxt.schema`. */
     static readonly SCHEMA_NAMESPACE = "@stxt.schema";
+    /** Namespace of the template language, `@stxt.template`. */
+    static readonly TEMPLATE_NAMESPACE = "@stxt.template";
     private readonly nodes;
     private readonly namespace;
     private readonly description;

package/out/schema/Schema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = void 0;
 const NamespaceValidator_1 = require("../core/NamespaceValidator");
 const StringUtils_1 = require("../core/StringUtils");
+const ParseException_1 = require("../exceptions/ParseException");
 const ValidationException_1 = require("../exceptions/ValidationException");
 /** Schema of a namespace: the set of {@link NodeDefinition} valid for the nodes of that namespace. */
 class Schema {
@@ -44,11 +45,11 @@ class Schema {
      * @throws ValidationException with code `NODE_DUPLICATED` if there already was a node definition with the same name.
      */
     addNodeDefinition(nodeDefinition) {
-        const qname = nodeDefinition.getCanonicalName();
-        if (this.nodes.has(qname)) {
-            throw new ValidationException_1.ValidationException(0, "NODE_DUPLICATED", `Exists a previous node definition with: ${qname}`);
+        const canonicalName = nodeDefinition.getCanonicalName();
+        if (this.nodes.has(canonicalName)) {
+            throw new ValidationException_1.ValidationException(ParseException_1.ParseException.NO_LINE, "NODE_DUPLICATED", `A node definition with the same name already exists: ${canonicalName}`);
         }
-        this.nodes.set(qname, nodeDefinition);
+        this.nodes.set(canonicalName, nodeDefinition);
     }
     /** @returns the namespace this schema applies to. */
     getNamespace() {
@@ -69,4 +70,6 @@ class Schema {
 exports.Schema = Schema;
 /** Namespace of the schema language itself, `@stxt.schema`. */
 Schema.SCHEMA_NAMESPACE = "@stxt.schema";
+/** Namespace of the template language, `@stxt.template`. */
+Schema.TEMPLATE_NAMESPACE = "@stxt.template";
 //# sourceMappingURL=Schema.js.map