@stxt-lang/core 0.14.1 → 0.16.0

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

package/out/schema/SchemaParser.js

@@ -5,6 +5,7 @@ const Schema_1 = require("./Schema");
 const NodeDefinition_1 = require("./NodeDefinition");
 const ChildDefinition_1 = require("./ChildDefinition");
 const InlineNode_1 = require("../core/InlineNode");
+const ParseException_1 = require("../exceptions/ParseException");
 const ValidationException_1 = require("../exceptions/ValidationException");
 const NamespaceValidator_1 = require("../core/NamespaceValidator");
 const StringUtils_1 = require("../core/StringUtils");
@@ -27,9 +28,11 @@ function transformNodeToSchema(node) {
         throw new ValidationException_1.ValidationException(node.getLine(), "SCHEMA_ROOT_NOT_VALID", `Expected schema(${Schema_1.Schema.SCHEMA_NAMESPACE}) but got ${nodeName}(${namespaceSchema})`);
     }
     const root = inline(node);
-    // The target namespace: required, and with a valid format
+    // The target namespace: required, and with a valid format. The value arrives already
+    // trimmed of language blanks by the parser; any other whitespace (NBSP...) is content
+    // and must fall through to the format check, exactly as in the other ports.
     const targetNamespace = StringUtils_1.StringUtils.lowerCase(root.getValue());
-    if (!targetNamespace || targetNamespace.trim().length === 0) {
+    if (!targetNamespace) {
         throw new ValidationException_1.ValidationException(root.getLine(), "SCHEMA_NAMESPACE_EMPTY", "Schema namespace is empty");
     }
     if (!NamespaceValidator_1.NamespaceValidator.isValid(targetNamespace)) {
@@ -53,7 +56,7 @@ function transformNodeToSchema(node) {
             if (schChild.getNamespace() === schema.getNamespace()) {
                 const childNorm = schChild.getCanonicalName();
                 if (!allNames.has(childNorm)) {
-                    throw new ValidationException_1.ValidationException(0, "CHILD_NOT_DEFINED", `Child ${childNorm} not defined in ${schema.getNamespace()}`);
+                    throw new ValidationException_1.ValidationException(ParseException_1.ParseException.NO_LINE, "CHILD_NOT_DEFINED", `Child ${childNorm} not defined in ${schema.getNamespace()}`);
                 }
             }
         }
@@ -88,8 +91,9 @@ function createFrom(node, namespace) {
             putChildToSchemaNode(result, child, namespace);
         }
     }
-    // Look at the values
-    let valuesNodes = n.getChildrenByName("values");
+    // Allowed values: only valid for the ENUM type
+    const valuesNodes = n.getChildrenByName("values"); // the "Values:" containers
+    let valueEntries = []; // the "Value:" entries inside
     if (valuesNodes && valuesNodes.length > 0) {
         if (type !== "ENUM") {
             throw new ValidationException_1.ValidationException(n.getLine(), "VALUES_NOT_ALLOWED_FOR_TYPE", `Values only supported for type ENUM, not for type ${type}`);
@@ -97,9 +101,8 @@ function createFrom(node, namespace) {
         if (valuesNodes.length > 1) {
             throw new ValidationException_1.ValidationException(valuesNodes[1].getLine(), "VALUES_DUPLICATED", `Node '${n.getValue()}' defines 'Values' ${valuesNodes.length} times`);
         }
-        const valuesNode = valuesNodes[0];
-        const values = inline(valuesNode).getChildrenByName("value");
-        for (const v of values) {
+        valueEntries = inline(valuesNodes[0]).getChildrenByName("value");
+        for (const v of valueEntries) {
             // An empty Value: is a schema error (STXT-SCHEMA-SPEC 7.2, condition 14 of section 13):
             // an enumeration whose only valid value is the empty string makes no sense
             if (v.getText().length === 0) {
@@ -107,11 +110,9 @@ function createFrom(node, namespace) {
             }
             result.addValue(v.getText(), v.getLine());
         }
-        // For the final ENUM check
-        valuesNodes = values;
     }
-    // Look at the enum
-    if (type === "ENUM" && (!valuesNodes || valuesNodes.length === 0)) {
+    // An ENUM must declare at least one value (a "Values:" with no entries included)
+    if (type === "ENUM" && valueEntries.length === 0) {
         throw new ValidationException_1.ValidationException(n.getLine(), "VALUES_REQUIRED", "ENUM Type must include values");
     }
     return result;

package/out/schema/SchemaProviderMemory.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaProviderMemory = void 0;
-const Parser_1 = require("../core/Parser");
 const StringUtils_1 = require("../core/StringUtils");
-const ValidationException_1 = require("../exceptions/ValidationException");
+const DefinitionCompiler_1 = require("./DefinitionCompiler");
 const SchemaParser_1 = require("./SchemaParser");
 const SchemaProviderMeta_1 = require("./SchemaProviderMeta");
-const SchemaValidator_1 = require("./SchemaValidator");
 /**
  * In-memory {@link SchemaProvider}: it keeps the schemas added with {@link SchemaProviderMemory.addSchema}
  * indexed by namespace, and falls back to a parent provider (the meta-schema by default) for the
@@ -52,22 +50,8 @@ class SchemaProviderMemory {
      *         particular `SCHEMA_MULTIPLE_ROOTS` if it does not hold exactly one root node.
      */
     addSchema(txt) {
-        const parser = new Parser_1.Parser();
-        const nodes = parser.parse(txt);
-        if (nodes.length !== 1) {
-            throw new ValidationException_1.ValidationException(0, "SCHEMA_MULTIPLE_ROOTS", `A schema document must hold exactly 1 root node, got ${nodes.length}`);
-        }
-        const node = nodes[0];
-        // A schema that does not validate against its meta-schema must not be
-        // registered (same policy as UnifiedSchemaProvider/DiscoveryResolver)
-        const schemaValidator = new SchemaValidator_1.SchemaValidator(new SchemaProviderMeta_1.SchemaProviderMeta(), true);
-        const errors = schemaValidator.validate(node);
-        if (errors.length > 0) {
-            throw errors[0];
-        }
-        const schema = (0, SchemaParser_1.transformNodeToSchema)(node);
-        const key = schema.getNamespace();
-        this.schemas.set(key, schema);
+        const schema = (0, DefinitionCompiler_1.compileDefinitionDocument)(txt, new SchemaProviderMeta_1.SchemaProviderMeta(), SchemaParser_1.transformNodeToSchema, "SCHEMA_MULTIPLE_ROOTS", "schema");
+        this.schemas.set(schema.getNamespace(), schema);
     }
     /** Removes every schema registered in this provider (the parent one is left untouched). */
     clear() {

package/out/schema/SchemaProviderMeta.d.ts

@@ -6,9 +6,15 @@ import { SchemaProvider } from "./SchemaProvider";
  */
 export declare class SchemaProviderMeta implements SchemaProvider {
     private static readonly META_TEXT;
+    /**
+     * The meta-schema is immutable, so it is compiled once per process, lazily, and every
+     * instance serves this same schema (constructing these providers is common: every
+     * `addSchema()` and every discovery compilation builds one).
+     */
+    private static compiledMeta;
     private readonly meta;
     /**
-     * Parses the meta-schema and keeps it ready to be served.
+     * Compiles the meta-schema the first time and keeps it ready to be served.
      *
      * @throws ValidationException with code `META_SCHEMA_INVALID` if the meta-schema does not produce exactly one document.
      */

package/out/schema/SchemaProviderMeta.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaProviderMeta = void 0;
 const Schema_1 = require("./Schema");
 const Parser_1 = require("../core/Parser");
+const ParseException_1 = require("../exceptions/ParseException");
 const ValidationException_1 = require("../exceptions/ValidationException");
 const SchemaParser_1 = require("./SchemaParser");
 /**
@@ -11,17 +12,20 @@ const SchemaParser_1 = require("./SchemaParser");
  */
 class SchemaProviderMeta {
     /**
-     * Parses the meta-schema and keeps it ready to be served.
+     * Compiles the meta-schema the first time and keeps it ready to be served.
      *
      * @throws ValidationException with code `META_SCHEMA_INVALID` if the meta-schema does not produce exactly one document.
      */
     constructor() {
-        const parser = new Parser_1.Parser();
-        const nodes = parser.parse(SchemaProviderMeta.META_TEXT);
-        if (nodes.length !== 1) {
-            throw new ValidationException_1.ValidationException(0, "META_SCHEMA_INVALID", `Meta schema must produce exactly 1 document, got ${nodes.length}`);
+        if (!SchemaProviderMeta.compiledMeta) {
+            const parser = new Parser_1.Parser();
+            const nodes = parser.parse(SchemaProviderMeta.META_TEXT);
+            if (nodes.length !== 1) {
+                throw new ValidationException_1.ValidationException(ParseException_1.ParseException.NO_LINE, "META_SCHEMA_INVALID", `Meta schema must produce exactly 1 document, got ${nodes.length}`);
+            }
+            SchemaProviderMeta.compiledMeta = (0, SchemaParser_1.transformNodeToSchema)(nodes[0]);
         }
-        this.meta = (0, SchemaParser_1.transformNodeToSchema)(nodes[0]);
+        this.meta = SchemaProviderMeta.compiledMeta;
     }
     /**
      * Serves the meta-schema of the schema language.
@@ -38,9 +42,6 @@ class SchemaProviderMeta {
         if (namespace !== Schema_1.Schema.SCHEMA_NAMESPACE) {
             return null;
         }
-        if (!this.meta) {
-            throw new ValidationException_1.ValidationException(0, "META_SCHEMA_NOT_AVAILABLE", "Meta schema not available");
-        }
         return this.meta;
     }
 }

package/out/schema/SchemaValidator.js

@@ -119,10 +119,12 @@ class SchemaValidator {
         for (const child of SchemaValidator.childrenOf(node)) {
             const childName = child.getQualifiedName();
             count.set(childName, (count.get(childName) ?? 0) + 1);
-            if (!childrenByType.has(childName)) {
-                childrenByType.set(childName, []);
+            let sameName = childrenByType.get(childName);
+            if (!sameName) {
+                sameName = [];
+                childrenByType.set(childName, sameName);
             }
-            childrenByType.get(childName).push(child);
+            sameName.push(child);
         }
         for (const childDef of nodeDef.getChildren().values()) {
             const qname = childDef.getQualifiedName();

package/out/schema/type/BASE64.d.ts

@@ -1,8 +1,10 @@
 import { Type } from "../Type";
 /**
  * STXT-SCHEMA-SPEC 9.5: standard Base64 (not URL-safe), padding optional, no leftover bits,
- * never empty. The check is a regular expression plus the leftover-bits rule, never the
- * platform decoder, which silently ignores characters outside the alphabet.
+ * never empty. The shape is checked in linear time — strip the optional trailing padding,
+ * enforce the padding/length rule, verify the core belongs to the standard alphabet — plus
+ * the leftover-bits rule; never the platform decoder, which silently ignores characters
+ * outside the alphabet.
  *
  * @param value value already stripped of blanks.
  * @returns whether it is valid Base64.

package/out/schema/type/BASE64.js

@@ -7,30 +7,54 @@ const binaryValue_1 = require("./binaryValue");
 /** Standard alphabet of RFC 4648 section 4, used to check the leftover bits of the last character. */
 const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 /**
- * Shape of a Base64 value (STXT-SCHEMA-SPEC 9.5): groups of four characters of the standard
- * alphabet, with an optional final group of two or three characters whose `=` padding may be
- * omitted. The empty string matches here and is rejected separately.
+ * Membership test for the standard alphabet, applied to the padding-stripped core. A plain
+ * character class with a single `*`, which matches in linear time with no backtracking —
+ * unlike a grouped-repetition shape such as `(?:[A-Za-z0-9+/]{4})*`, whose backtracking state
+ * overflows V8's call stack (`RangeError`) on inputs of a few million characters, still inside
+ * the default `maxInputSize`.
  */
-const SHAPE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/;
+const ALPHABET_ONLY = /^[A-Za-z0-9+/]*$/;
 /**
  * STXT-SCHEMA-SPEC 9.5: standard Base64 (not URL-safe), padding optional, no leftover bits,
- * never empty. The check is a regular expression plus the leftover-bits rule, never the
- * platform decoder, which silently ignores characters outside the alphabet.
+ * never empty. The shape is checked in linear time — strip the optional trailing padding,
+ * enforce the padding/length rule, verify the core belongs to the standard alphabet — plus
+ * the leftover-bits rule; never the platform decoder, which silently ignores characters
+ * outside the alphabet.
  *
  * @param value value already stripped of blanks.
  * @returns whether it is valid Base64.
  */
 function isValidBase64(value) {
-    if (value.length === 0 || !SHAPE.test(value)) {
+    if (value.length === 0) {
+        return false;
+    }
+    // Strip the optional final padding: 0, 1 or 2 '=' signs, only at the very end of the
+    // value. Three or more, or an '=' anywhere else, is rejected below by the alphabet check.
+    let core = value;
+    let padding = 0;
+    if (value.endsWith("==")) {
+        core = value.slice(0, -2);
+        padding = 2;
+    }
+    else if (value.endsWith("=")) {
+        core = value.slice(0, -1);
+        padding = 1;
+    }
+    if (!ALPHABET_ONLY.test(core)) {
+        return false;
+    }
+    const rest = core.length % 4;
+    // A trailing group of a single character never occurs in Base64. Two '=' close a
+    // two-character group, one '=' a three-character group; with no padding the core is
+    // whole groups plus an optional final group of two or three characters.
+    if (padding === 2 ? rest !== 2 : padding === 1 ? rest !== 3 : rest === 1) {
         return false;
     }
-    const data = value.replace(/=+$/, "");
-    const rest = data.length % 4;
     if (rest === 0) {
         return true;
     }
     // The last character encodes 6 bits; with 2 characters 4 of them are leftover, with 3, 2 of them.
-    const last = ALPHABET.indexOf(data.charAt(data.length - 1));
+    const last = ALPHABET.indexOf(core.charAt(core.length - 1));
     const mask = rest === 2 ? 0x0f : 0x03;
     return (last & mask) === 0;
 }

package/out/schema/type/MARKDOWN.d.ts

@@ -1,6 +1,7 @@
 import { Type } from "../Type";
 /**
  * `MARKDOWN` type. STXT-SCHEMA-SPEC 9.7: for validation purposes it is equivalent to TEXT
- * (any content is valid Markdown); only children are forbidden.
+ * (any content is valid Markdown; only children are forbidden), so it shares its validation
+ * and only the name differs.
  */
 export declare const MARKDOWN: Type;

package/out/schema/type/MARKDOWN.js

@@ -1,20 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MARKDOWN = void 0;
-const InlineNode_1 = require("../../core/InlineNode");
-const ValidationException_1 = require("../../exceptions/ValidationException");
+const TEXT_1 = require("./TEXT");
 /**
  * `MARKDOWN` type. STXT-SCHEMA-SPEC 9.7: for validation purposes it is equivalent to TEXT
- * (any content is valid Markdown); only children are forbidden.
+ * (any content is valid Markdown; only children are forbidden), so it shares its validation
+ * and only the name differs.
  */
 exports.MARKDOWN = {
     getName() {
         return "MARKDOWN";
     },
-    validate(nodeDef, node) {
-        if (node instanceof InlineNode_1.InlineNode && node.getChildren().length > 0) {
-            throw new ValidationException_1.ValidationException(node.getLine(), "CHILDREN_NOT_ALLOWED", `Not allowed children nodes in node ${node.getQualifiedName()}`);
-        }
-    },
+    validate: TEXT_1.TEXT.validate,
 };
 //# sourceMappingURL=MARKDOWN.js.map

package/out/template/ChildLineParser.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChildLineParser = void 0;
 const ValidationException_1 = require("../exceptions/ValidationException");
+const StringUtils_1 = require("../core/StringUtils");
 const ChildLine_1 = require("./ChildLine");
 /** Parses the inline value of a child node inside an `@stxt.template`, shaped as `(min,max) TYPE [values]`. */
 class ChildLineParser {
@@ -16,7 +17,7 @@ class ChildLineParser {
      *         `MIN_GREATER_THAN_MAX` or `VALUE_DUPLICATED` if the line is not valid.
      */
     static parse(rawLine, lineNumber) {
-        if (rawLine.trim().length === 0) {
+        if (StringUtils_1.StringUtils.trim(rawLine).length === 0) {
             return new ChildLine_1.ChildLine(null, null, null, null);
         }
         const m = ChildLineParser.CHILD_LINE_PATTERN.exec(rawLine);
@@ -24,11 +25,11 @@ class ChildLineParser {
             throw new ValidationException_1.ValidationException(lineNumber, "STRUCTURE_LINE_NOT_VALID", `Line not valid: ${rawLine}`);
         }
         // m[1]=count, m[2]=type, m[3]=values
-        let type = m[2]?.trim() ?? "";
+        let type = StringUtils_1.StringUtils.trim(m[2]);
         if (type.length === 0) {
             type = null;
         }
-        const count = (m[1] ?? "").trim();
+        const count = StringUtils_1.StringUtils.trim(m[1]);
         let min = null;
         let max = null;
         if (count.length === 0 || count === "*") {
@@ -56,8 +57,8 @@ class ChildLineParser {
             if (parts.length !== 2) {
                 throw new ValidationException_1.ValidationException(lineNumber, "CARDINALITY_NOT_VALID", `Invalid count ${count} in line: ${rawLine}`);
             }
-            const aNum = ChildLineParser.parseCount(parts[0].trim(), count, rawLine, lineNumber);
-            const bNum = ChildLineParser.parseCount(parts[1].trim(), count, rawLine, lineNumber);
+            const aNum = ChildLineParser.parseCount(StringUtils_1.StringUtils.trim(parts[0]), count, rawLine, lineNumber);
+            const bNum = ChildLineParser.parseCount(StringUtils_1.StringUtils.trim(parts[1]), count, rawLine, lineNumber);
             // Invalid cardinality when min > max (STXT-TEMPLATE-SPEC 7.1)
             if (aNum > bNum) {
                 throw new ValidationException_1.ValidationException(lineNumber, "MIN_GREATER_THAN_MAX", `Min ${aNum} greater than Max ${bNum} in line: ${rawLine}`);
@@ -76,7 +77,7 @@ class ChildLineParser {
             const parts = valuesStr.split(",");
             const list = [];
             for (let part of parts) {
-                part = part.trim();
+                part = StringUtils_1.StringUtils.trim(part);
                 // An empty item ("[a, , b]", "[a, b,]") is an error, as an empty Value: is in a
                 // schema (STXT-TEMPLATE-SPEC 14.14). Only the whole list may be empty ("[]"),
                 // which the template parser reports as VALUES_REQUIRED.
@@ -97,8 +98,7 @@ class ChildLineParser {
             // treated as a real definition/redefinition (ported from stxt-java).
             values = list;
         }
-        // type is string|null in our class
-        return new ChildLine_1.ChildLine(type ?? null, min, max, values);
+        return new ChildLine_1.ChildLine(type, min, max, values);
     }
     // num, min and max must be non-negative integers, with no trailing text (STXT-TEMPLATE-SPEC 7.1)
     static parseCount(num, count, rawLine, lineNumber) {
@@ -109,5 +109,8 @@ class ChildLineParser {
     }
 }
 exports.ChildLineParser = ChildLineParser;
-ChildLineParser.CHILD_LINE_PATTERN = /^\s*(?:\(\s*([^()\s][^)]*?)\s*\)\s*)?([^()[\]]*)?(?:\[\s*([^]*?)\s*\]\s*)?\s*$/;
+// STXT-TEMPLATE-SPEC 6.2/9: the trim in the template grammar is the language blank
+// (U+0020/U+0009) only, never the platform's \s (which also swallows NBSP, U+3000...).
+// So every \s here is [ \t], including inside the negated class.
+ChildLineParser.CHILD_LINE_PATTERN = /^[ \t]*(?:\([ \t]*([^() \t][^)]*?)[ \t]*\)[ \t]*)?([^()[\]]*)?(?:\[[ \t]*([^]*?)[ \t]*\][ \t]*)?[ \t]*$/;
 //# sourceMappingURL=ChildLineParser.js.map

package/out/template/MetaTemplateSchemaProvider.d.ts

@@ -6,9 +6,11 @@ import { SchemaProvider } from "../schema/SchemaProvider";
  */
 export declare class MetaTemplateSchemaProvider implements SchemaProvider {
     private static readonly META_TEXT;
+    /** Compiled once per process and shared between instances, exactly like {@link SchemaProviderMeta}. */
+    private static compiledMeta;
     private readonly meta;
     /**
-     * Parses the meta-template and keeps the schema it produces ready to be served.
+     * Compiles the meta-template the first time and keeps the schema it produces ready to be served.
      *
      * @throws ValidationException with code `META_SCHEMA_INVALID` if the meta-template does not produce exactly one document.
      */

package/out/template/MetaTemplateSchemaProvider.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetaTemplateSchemaProvider = void 0;
 const Parser_1 = require("../core/Parser");
+const Schema_1 = require("../schema/Schema");
+const ParseException_1 = require("../exceptions/ParseException");
 const ValidationException_1 = require("../exceptions/ValidationException");
 const TemplateParser_1 = require("./TemplateParser");
 /**
@@ -10,17 +12,20 @@ const TemplateParser_1 = require("./TemplateParser");
  */
 class MetaTemplateSchemaProvider {
     /**
-     * Parses the meta-template and keeps the schema it produces ready to be served.
+     * Compiles the meta-template the first time and keeps the schema it produces ready to be served.
      *
      * @throws ValidationException with code `META_SCHEMA_INVALID` if the meta-template does not produce exactly one document.
      */
     constructor() {
-        const parser = new Parser_1.Parser();
-        const nodes = parser.parse(MetaTemplateSchemaProvider.META_TEXT);
-        if (nodes.length !== 1) {
-            throw new ValidationException_1.ValidationException(0, "META_SCHEMA_INVALID", `Meta schema must produce exactly 1 document, got ${nodes.length}`);
+        if (!MetaTemplateSchemaProvider.compiledMeta) {
+            const parser = new Parser_1.Parser();
+            const nodes = parser.parse(MetaTemplateSchemaProvider.META_TEXT);
+            if (nodes.length !== 1) {
+                throw new ValidationException_1.ValidationException(ParseException_1.ParseException.NO_LINE, "META_SCHEMA_INVALID", `Meta schema must produce exactly 1 document, got ${nodes.length}`);
+            }
+            MetaTemplateSchemaProvider.compiledMeta = (0, TemplateParser_1.transformTemplateNodeToSchema)(nodes[0]);
         }
-        this.meta = (0, TemplateParser_1.transformTemplateNodeToSchema)(nodes[0]);
+        this.meta = MetaTemplateSchemaProvider.compiledMeta;
     }
     /**
      * Serves the meta-schema of the template language.
@@ -33,13 +38,9 @@ class MetaTemplateSchemaProvider {
      * @returns the meta-schema of the template language, or `null` for any other namespace.
      */
     getSchema(namespace) {
-        if (namespace !== "@stxt.template") {
+        if (namespace !== Schema_1.Schema.TEMPLATE_NAMESPACE) {
             return null;
         }
-        // meta always exists once the constructor finished, but this mirrors the Java version
-        if (!this.meta) {
-            throw new ValidationException_1.ValidationException(0, "META_SCHEMA_NOT_AVAILABLE", "Meta schema not available");
-        }
         return this.meta;
     }
 }

package/out/template/TemplateParser.d.ts

@@ -1,7 +1,6 @@
 import { Node } from "../core/Node";
 import { Schema } from "../schema/Schema";
-/** Namespace of the template language itself, `@stxt.template`. */
-/** Namespace of the template language itself, `@stxt.template`. */
+/** Namespace of the template language itself; the canonical constant is {@link Schema.TEMPLATE_NAMESPACE}. */
 export declare const TEMPLATE_NAMESPACE = "@stxt.template";
 /**
  * Turns the tree of an already parsed `@stxt.template` document into an equivalent {@link Schema}.