yini-parser 1.0.2-beta → 1.1.0-beta

package/dist/parseEntry.js

@@ -1,17 +1,92 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseMain = void 0;
+exports._parseMain = void 0;
+const perf_hooks_1 = require("perf_hooks");
 const antlr4_1 = require("antlr4");
 const env_1 = require("./config/env");
+const ASTBuilder_1 = __importDefault(require("./core/ASTBuilder"));
 const ErrorDataHandler_1 = require("./core/ErrorDataHandler");
 const objectBuilder_1 = require("./core/objectBuilder");
-const YINIVisitor_1 = __importDefault(require("./core/YINIVisitor"));
 const YiniLexer_1 = __importDefault(require("./grammar/YiniLexer"));
-const YiniParser_1 = __importDefault(require("./grammar/YiniParser"));
+const YiniParser_1 = __importStar(require("./grammar/YiniParser"));
+const object_1 = require("./utils/object");
 const print_1 = require("./utils/print");
+const string_1 = require("./utils/string");
+const system_1 = require("./utils/system");
+const pkg = require('../package.json');
+/**
+ * @param line Line number as 1-based.
+ * @param col Column number as 0-based.
+ */
+const createGeneralCtx = (line, endColumn, startColumn = undefined) => {
+    const startToken = new antlr4_1.Token();
+    const stopToken = new antlr4_1.Token();
+    const ctx = new YiniParser_1.YiniContext();
+    ctx.start = startToken;
+    ctx.stop = stopToken;
+    ctx.start.line = line; // Note: Line num is 1-based.
+    if (startColumn && startColumn >= 0) {
+        ctx.start.column = startColumn; // Note: Column num is 0-based.
+    }
+    ctx.stop.column = endColumn; // Note: Column num is 0-based.
+    return ctx;
+};
+const parsePossibleStartCol = (errorHandler, recognizer) => {
+    var _a, _b;
+    let possibleStartCol = undefined;
+    try {
+        possibleStartCol = ((_a = recognizer === null || recognizer === void 0 ? void 0 : recognizer._ctx.start) === null || _a === void 0 ? void 0 : _a.column)
+            ? ((_b = recognizer === null || recognizer === void 0 ? void 0 : recognizer._ctx.start) === null || _b === void 0 ? void 0 : _b.column) + 1
+            : undefined;
+    }
+    catch (err) {
+        let msgHint = '';
+        if ((0, system_1.isError)(err)) {
+            msgHint = 'Error: ' + err.message;
+        }
+        else {
+            msgHint = 'Thrown value:' + JSON.stringify(err);
+        }
+        errorHandler.pushOrBail(null, 'Internal-Error', 'Catched error of possibleStartCol in parser grammar listener.', msgHint);
+    }
+    return possibleStartCol;
+};
 class MyParserErrorListener {
     constructor(errorHandler) {
         this.errors = [];
@@ -19,10 +94,17 @@ class MyParserErrorListener {
     }
     syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
         (0, print_1.debugPrint)('ANTLR parser cached an error');
-        this.errors.push(`Line ${line}:${charPositionInLine} ${msg}`);
-        const msgWhat = `Syntax error, at line: ${line}`;
-        const msgWhy = `At about column ${1 + charPositionInLine} ${msg}`;
-        this.errorHandler.pushOrBail(null, 'Syntax-Error', msgWhat, msgWhy);
+        const col = charPositionInLine + 1;
+        const possibleStartCol = parsePossibleStartCol(this.errorHandler, recognizer);
+        const msgWhat = `Syntax error`;
+        // Try to map message:
+        // From: "mismatched input '/END' expecting <EOF>"
+        // To:   "Found '/END', but expected the end of the document."
+        // const msgWhy = `${capitalizeFirst(msg)}`
+        const msgWhy = `Details: ${msg}`;
+        const ctx = createGeneralCtx(line, charPositionInLine, possibleStartCol); // So we can show line/col in error message.
+        // Note, after pushing processing may continue or exit, depending on the error and/or the bail threshold.
+        this.errorHandler.pushOrBail(ctx, 'Syntax-Error', msgWhat, msgWhy);
     }
     // The following are required for the interface, but can be left empty.
     reportAmbiguity(...args) { }
@@ -36,26 +118,46 @@ class MyLexerErrorListener {
     }
     syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e) {
         // Handle the error as you want:
-        (0, print_1.debugPrint)('ANTLR parser cached an error');
-        this.errors.push(`Line ${line}:${charPositionInLine} ${msg}`);
-        const msgWhat = `Syntax error, at line: ${line}`;
-        const msgWhy = `At about column ${1 + charPositionInLine} ${msg}`;
-        this.errorHandler.pushOrBail(null, 'Syntax-Error', msgWhat, msgWhy);
+        (0, print_1.debugPrint)('ANTLR lexer cached an error');
+        const col = charPositionInLine + 1;
+        const possibleStartCol = parsePossibleStartCol(this.errorHandler, recognizer);
+        // const msgWhat = `Syntax error at line ${line}, column ${col}:`
+        const msgWhat = `Syntax error`;
+        // Try to map message:
+        // From: "mismatched input '/END' expecting <EOF>"
+        // To:   "Found '/END', but expected the end of the document."
+        // const msgWhy = `${capitalizeFirst(msg)}`
+        const msgWhy = `Details: ${msg}`;
+        // const msgHint = ``
+        const ctx = createGeneralCtx(line, charPositionInLine, possibleStartCol); // So we can show line/col in error message.
+        // Note, after pushing processing may continue or exit, depending on the error and/or the bail threshold.
+        this.errorHandler.pushOrBail(ctx, 'Syntax-Error', msgWhat, msgWhy);
     }
 }
-const parseMain = (yiniContent, options = {
+/** Single source of truth. */
+const _parseMain = (yiniContent, 
+// options: IParseMainOptions = {
+options = {
     isStrict: false,
-    bailSensitivityLevel: 0,
+    bailSensitivity: 0,
     isIncludeMeta: false,
     isWithDiagnostics: false,
     isWithTiming: false,
-}) => {
+    isKeepUndefinedInMeta: false,
+    isRequireDocTerminator: false,
+}, runtimeInfo) => {
     (0, print_1.debugPrint)();
     (0, print_1.debugPrint)('-> Entered parseMain(..) in parseEntry');
-    (0, print_1.debugPrint)('     isStrict mode = ' + options.isStrict);
-    (0, print_1.debugPrint)('bailSensitivityLevel = ' + options.bailSensitivityLevel);
+    (0, print_1.debugPrint)('         isStrict mode = ' + options.isStrict);
+    (0, print_1.debugPrint)('       bailSensitivity = ' + options.bailSensitivity);
+    (0, print_1.debugPrint)('         isIncludeMeta = ' + options.isIncludeMeta);
+    (0, print_1.debugPrint)('     isWithDiagnostics = ' + options.isWithDiagnostics);
+    (0, print_1.debugPrint)('          isWithTiming = ' + options.isWithTiming);
+    (0, print_1.debugPrint)('  requireDocTerminator = ' + options.isRequireDocTerminator);
+    (0, print_1.debugPrint)('runtimeInfo.sourceType = ' + runtimeInfo.sourceType);
+    (0, print_1.debugPrint)('  runtimeInfo.fileName = ' + runtimeInfo.fileName);
     let persistThreshold;
-    switch (options.bailSensitivityLevel) {
+    switch (options.bailSensitivity) {
         case 0:
             persistThreshold = '0-Ignore-Errors';
             break;
@@ -65,23 +167,57 @@ const parseMain = (yiniContent, options = {
         default:
             persistThreshold = '2-Abort-Even-on-Warnings';
     }
+    const errorHandler = new ErrorDataHandler_1.ErrorDataHandler(runtimeInfo.sourceType, persistThreshold, runtimeInfo.fileName);
+    if (yiniContent.trim() === '') {
+        const isFileSourceType = (runtimeInfo === null || runtimeInfo === void 0 ? void 0 : runtimeInfo.sourceType) === 'File';
+        // Note, after pushing processing may continue or exit, depending on the error and/or the bail threshold.
+        errorHandler.pushOrBail(null, 'Syntax-Error', 'Empty YINI document.', `The input is blank or contains only whitespace in the ${isFileSourceType ? 'YINI file' : 'YINI inline content'}.`, `Tip: Add at least one section '^ SectionName' or a key-value pair 'key = value' to make it a valid YINI file.`);
+    }
+    //---------------------------------------------
+    // Note: Only computed when isWithTiming.
+    let timeStartMs = 0;
+    let timeEnd1Ms = 0;
+    let timeEnd2Ms = 0;
+    let timeEnd3Ms = 0;
+    let timeEnd4Ms = 0;
+    //---------------------------------------------
+    //---------------------------------------------
+    // Note: Should ALWAYS be computed.
+    let runStartedAt = '';
+    let runFinishedAt = '';
+    let durationMs = 0;
+    //---------------------------------------------
     (0, env_1.isDebug)() && console.log();
-    (0, print_1.debugPrint)('=== Phase 1 ===================================================');
+    (0, print_1.debugPrint)('=== Phase 1 - Lexing ===================================================');
+    // -----------------------------
+    // Below block should always be done despite isWithTiming to compute
+    // total time and runStartedAt that should always be computed.
+    {
+        timeStartMs = perf_hooks_1.performance.now();
+        runStartedAt = new Date().toISOString();
+    }
+    // -----------------------------
     const inputStream = antlr4_1.CharStreams.fromString(yiniContent);
     const lexer = new YiniLexer_1.default(inputStream);
-    const tokenStream = new antlr4_1.CommonTokenStream(lexer);
-    const parser = new YiniParser_1.default(tokenStream);
-    const errorHandler = new ErrorDataHandler_1.ErrorDataHandler(persistThreshold);
     // Remove the default ConsoleErrorListener
     lexer.removeErrorListeners(); // Removes the default lexer console error output.
     const lexerErrorListener = new MyLexerErrorListener(errorHandler);
     lexer.addErrorListener(lexerErrorListener);
+    const tokenStream = new antlr4_1.CommonTokenStream(lexer);
+    // Important: force tokenization here so lexing is measured separately.
+    tokenStream.fill();
+    (0, print_1.debugPrint)('--- Parsing done. ---');
+    (0, print_1.debugPrint)('=== Ended phase 1 =============================================');
+    (0, env_1.isDebug)() && console.log();
+    (0, print_1.debugPrint)('=== Phase 2 - Parsing ===================================================');
+    if (options.isWithTiming) {
+        timeEnd1Ms = perf_hooks_1.performance.now();
+    }
+    const parser = new YiniParser_1.default(tokenStream);
     // const errorListener = new MyParserErrorListener(errorHandler)
     parser.removeErrorListeners(); // Removes the default parser console error output.
     const parserErrorListener = new MyParserErrorListener(errorHandler);
     parser.addErrorListener(parserErrorListener);
-    (0, print_1.debugPrint)();
-    (0, print_1.debugPrint)('--- Starting parsing... ---');
     const parseTree = parser.yini(); // The function yini() is the start rule.
     if (parserErrorListener.errors.length > 0 ||
         lexerErrorListener.errors.length > 0) {
@@ -89,85 +225,218 @@ const parseMain = (yiniContent, options = {
         if ((0, env_1.isDebug)()) {
             // Handle or display syntax errors
             console.error('Syntax errors detected:', parserErrorListener.errors, lexerErrorListener.errors);
-            //process.exit(1)
         }
     }
-    (0, print_1.debugPrint)('--- Parsing done. ---');
-    (0, print_1.debugPrint)('=== Ended phase 1 =============================================');
+    (0, print_1.debugPrint)('=== Ended phase 2 =============================================');
     (0, env_1.isDebug)() && console.log();
-    (0, print_1.debugPrint)('=== Phase 2 ===================================================');
-    //    const errorHandler = new ErrorDataHandler(persistThreshold)
-    const visitor = new YINIVisitor_1.default(errorHandler, options.isStrict);
-    const syntaxTreeC = visitor.visit(parseTree);
+    (0, print_1.debugPrint)('=== Phase 3 - AST Model build & validation ===================================================');
+    if (options.isWithTiming) {
+        timeEnd2Ms = perf_hooks_1.performance.now();
+    }
+    const builder = new ASTBuilder_1.default(errorHandler, options, runtimeInfo.sourceType, runtimeInfo.fileName || null);
+    const ast = builder.buildAST(parseTree);
+    if (ast.numOfMembers === 0 && ast.numOfSections === 0) {
+        // Note, after pushing processing may continue or exit, depending on the error and/or the bail threshold.
+        errorHandler.pushOrBail(null, 'Syntax-Error', 'No meaningful content.', `No sections or members found in the ${ast.sourceType === 'File' ? 'YINI file' : 'YINI inline content'}.`, `${ast.sourceType === 'File' ? 'A valid YINI file' : 'Any valid YINI inline content'} must contain at least one section '^ SectionName' or a key–value pair 'key = value' to make it a valid YINI file.`);
+    }
     if ((0, env_1.isDebug)()) {
         console.log();
         console.log('**************************************************************************');
-        console.log('*** syntaxTreeContainer: *************************************************');
-        (0, print_1.printObject)(syntaxTreeC);
+        console.log('*** AST *************************************************');
+        (0, print_1.printObject)(ast);
         console.log('**************************************************************************');
         console.log('**************************************************************************');
         console.log();
     }
-    (0, print_1.debugPrint)('=== Ended phase 2 =============================================');
+    (0, print_1.debugPrint)('=== Ended phase 3 =============================================');
     (0, env_1.isDebug)() && console.log();
-    (0, print_1.debugPrint)('=== Phase 3 ===================================================');
+    (0, print_1.debugPrint)('=== Phase 4 - Object Building Construction / Binding / Evaluation) ===================================================');
+    if (options.isWithTiming) {
+        timeEnd3Ms = perf_hooks_1.performance.now();
+    }
     // Construct.
-    const finalJSResult = (0, objectBuilder_1.constructFinalObject)(syntaxTreeC, errorHandler);
-    (0, print_1.debugPrint)('=== Ended phase 3 =============================================');
+    // const finalJSResult = constructFinalObject(syntaxTreeC, errorHandler)
+    // const finalJSResult = builder.build(parseTree)
+    // const finalJSResult = ast //NOTE: ONLY TEMP so code runs
+    const finalJSResult = (0, objectBuilder_1.astToObject)(ast, errorHandler);
+    (0, print_1.debugPrint)('=== Ended phase 4 =============================================');
+    // -----------------------------
+    // Below block should always be done despite isWithTiming to compute
+    // total time and runStartedAt that should always be computed.
+    {
+        timeEnd4Ms = perf_hooks_1.performance.now();
+        durationMs = timeEnd4Ms - timeStartMs;
+        runFinishedAt = new Date().toISOString();
+    }
+    // -----------------------------
     (0, print_1.debugPrint)('visitor.visit(..): finalJSResult:');
     (0, env_1.isDebug)() && console.debug(finalJSResult);
     (0, print_1.debugPrint)();
     if (options.isStrict) {
-        //throw Error('ERROR: Strict-mode not yet implemented')
-        errorHandler.pushOrBail(null, 'Syntax-Warning', 'WARNING: Strict-mode not yet fully implemented', '', '');
+        // Note, after pushing processing may continue or exit, depending on the error and/or the bail threshold.
+        errorHandler.pushOrBail(null, 'Syntax-Warning', 'Warning: Strict mode is not yet fully implemented.', 'Some validation rules may still be missing or incomplete.');
     }
     else {
         (0, print_1.debugPrint)('visitor.visit(..): finalJSResult:');
         (0, env_1.isDebug)() && console.debug(finalJSResult);
     }
-    // Construct meta data.
-    const metaData = {
-        strictMode: options.isStrict,
-        hasTerminal: syntaxTreeC._hasTerminal,
-        sections: syntaxTreeC._meta_numOfSections,
-        members: syntaxTreeC._meta_numOfMembers,
-        sectionChains: syntaxTreeC._meta_numOfChains,
-        keysParsed: null,
-        timing: {
-            totalMs: null,
-            phase1Ms: null,
-            phase2Ms: null,
-            phase3Ms: null,
-        },
-    };
-    if (options.isWithDiagnostics) {
-        // Attach optional diagnostics.
-        metaData.diagnostics = {
-            bailSensitivityLevel: options.bailSensitivityLevel,
-            errors: errorHandler.getNumOfErrors(),
-            warnings: errorHandler.getNumOfWarnings(),
-            infoAndNotices: errorHandler.getNumOfInfoAndNotices(),
-            envs: {
-                NODE_ENV: process.env.NODE_ENV,
-                APP_ENV: process.env.APP_ENV,
-                libNodeEnv: env_1.localNodeEnv,
-                libAppEnv: env_1.localAppEnv,
+    const constructResultMetaData = () => {
+        // --- Construct meta information -------------------------------------
+        const to3 = (n) => Number.parseFloat(n.toFixed(3));
+        // Construct meta data.
+        const metaData = {
+            parserVersion: pkg.version,
+            mode: options.isStrict ? 'strict' : 'lenient',
+            orderPreserved: true,
+            totalErrors: errorHandler.getNumOfErrors(),
+            totalWarnings: errorHandler.getNumOfWarnings(),
+            totalMessages: errorHandler.getNumOfAllMessages(),
+            runStartedAt,
+            runFinishedAt,
+            durationMs: to3(durationMs),
+            source: {
+                sourceType: (0, string_1.toLowerSnakeCase)(ast.sourceType),
+                fileName: ast.fileName,
+                hasDocumentTerminator: ast.terminatorSeen,
+                hasYiniMarker: ast.yiniMarkerSeen,
+                lineCount: runtimeInfo.lineCount,
+                byteSize: runtimeInfo.fileByteSize,
+                sha256: runtimeInfo.sha256,
             },
-            libFlags: {
-                isDev: (0, env_1.isDev)(),
-                isDebug: (0, env_1.isDebug)(),
+            structure: {
+                maxDepth: ast.maxDepth,
+                sectionCount: ast.numOfSections,
+                memberCount: ast.numOfMembers,
+                keysParsedCount: null,
+                // objectCount: null,
+                // listCount: null,
+                sectionNamePaths: ast.sectionNamePaths,
             },
+            metaSchemaVersion: '1.0.0',
         };
-    }
-    if (options.isWithTiming) {
-        // Attach optional timing data.
-        metaData.timing = {
-            totalMs: null,
-            phase1Ms: null,
-            phase2Ms: null,
-            phase3Ms: null,
-        };
-    }
+        // Attach optional diagnostics.
+        if (options.isWithDiagnostics) {
+            const mapLevelKey = (level) => {
+                switch (level) {
+                    case 0:
+                        return 'ignore_errors';
+                    case 1:
+                        return 'abort_on_errors';
+                    case 2:
+                        return 'abort_on_warnings';
+                }
+            };
+            const mapLevelLabel = (level) => {
+                switch (level) {
+                    case 0:
+                        return '0-Ignore-Errors';
+                    case 1:
+                        return '1-Abort-on-Errors';
+                    case 2:
+                        return '2-Abort-Even-on-Warnings';
+                }
+            };
+            const mapLevelDescription = (level) => {
+                switch (level) {
+                    case 0:
+                        return 'Continue despite errors.';
+                    case 1:
+                        return 'Abort when errors occur.';
+                    case 2:
+                        return 'Abort when errors or warnings occur.';
+                }
+                return null;
+            };
+            metaData.diagnostics = {
+                failLevel: {
+                    preferredLevel: runtimeInfo.preferredBailSensitivity,
+                    levelUsed: options.bailSensitivity,
+                    levelKey: mapLevelKey(options.bailSensitivity),
+                    levelLabel: mapLevelLabel(options.bailSensitivity),
+                    levelDescription: (mapLevelDescription(options.bailSensitivity)),
+                },
+                errors: {
+                    errorCount: errorHandler.getNumOfErrors(),
+                    payload: errorHandler.getErrors(),
+                },
+                warnings: {
+                    warningCount: errorHandler.getNumOfWarnings(),
+                    payload: errorHandler.getWarnings(),
+                },
+                notices: {
+                    noticeCount: errorHandler.getNumOfNotices(),
+                    payload: errorHandler.getNotices(),
+                },
+                infos: {
+                    infoCount: errorHandler.getNumOfInfos(),
+                    payload: errorHandler.getInfos(),
+                },
+                environment: {
+                    NODE_ENV: process.env.NODE_ENV,
+                    APP_ENV: process.env.APP_ENV,
+                    lib: {
+                        nodeEnv: env_1.localNodeEnv,
+                        appEnv: env_1.localAppEnv,
+                        flags: { isDev: (0, env_1.isDev)(), isDebug: (0, env_1.isDebug)() },
+                    },
+                },
+                optionsUsed: {
+                    // NOTE: (!) These MUST user options.
+                    strictMode: options.isStrict,
+                    failLevel: options.bailSensitivity,
+                    includeMetaData: options.isIncludeMeta,
+                    includeDiagnostics: options.isWithDiagnostics,
+                    includeTiming: options.isWithTiming,
+                    preserveUndefinedInMeta: options.isKeepUndefinedInMeta,
+                    requireDocTerminator: options.isRequireDocTerminator,
+                },
+            };
+        }
+        // Attach optional durations timing data.
+        if (options.isWithTiming) {
+            metaData.timing = {
+                total: !options.isWithTiming
+                    ? null
+                    : {
+                        timeMs: to3(durationMs), // durationMs = timeEnd4Ms - timeStartMs
+                        name: runtimeInfo.sourceType === 'Inline'
+                            ? 'Total'
+                            : 'Total (excluding phase0 (I/O))',
+                    },
+                phase0: !options.isWithTiming || runtimeInfo.sourceType === 'Inline'
+                    ? undefined
+                    : {
+                        timeMs: to3(runtimeInfo.timeIoMs),
+                        name: 'I/O',
+                    },
+                phase1: !options.isWithTiming
+                    ? null
+                    : {
+                        timeMs: to3(timeEnd1Ms - timeStartMs),
+                        name: 'Lexing',
+                    },
+                phase2: !options.isWithTiming
+                    ? null
+                    : {
+                        timeMs: to3(timeEnd2Ms - timeEnd1Ms),
+                        name: 'Parsing',
+                    },
+                phase3: !options.isWithTiming
+                    ? null
+                    : {
+                        timeMs: to3(timeEnd3Ms - timeEnd2Ms),
+                        name: 'AST Building',
+                    },
+                phase4: !options.isWithTiming
+                    ? null
+                    : {
+                        timeMs: to3(timeEnd4Ms - timeEnd3Ms),
+                        name: 'Object Building',
+                    },
+            };
+        }
+        return metaData;
+    };
     (0, print_1.debugPrint)('getNumOfErrors(): ' + errorHandler.getNumOfErrors());
     if (errorHandler.getNumOfErrors()) {
         console.log();
@@ -177,9 +446,11 @@ const parseMain = (yiniContent, options = {
     if (options.isIncludeMeta) {
         return {
             result: finalJSResult,
-            meta: metaData,
+            meta: !options.isKeepUndefinedInMeta
+                ? (0, object_1.removeUndefinedDeep)(constructResultMetaData())
+                : constructResultMetaData(),
         };
     }
     return finalJSResult;
 };
-exports.parseMain = parseMain;
+exports._parseMain = _parseMain;

package/dist/parsers/extractHeaderParts.d.ts

@@ -1,5 +1,5 @@
 import { ErrorDataHandler } from '../core/ErrorDataHandler';
-import { SectionContext } from '../grammar/YiniParser';
+import { StmtContext } from '../grammar/YiniParser';
 /**
  * Check and identify the section header parts via tokenizing the parts and return them as strings.
  * @param rawHeaderLine Raw line with the section header where the header
@@ -19,10 +19,11 @@ import { SectionContext } from '../grammar/YiniParser';
  * - Backticked identifiers must be on a single line and must not contain tabs or new lines unless using escaping codes, except for ordinary spaces.
  * - Special control characters (U+0000–U+001F) must be escaped.
  *
+ * @note Implemented without regexp to keep it less cryptic, etc.
  * @note Returns the parts as strings; each part needs to be analyzed separately against the contraints in the specifications.
  * @returns An object with the identified header parts: marker characters, parsed name, and parsed level string.
  */
-declare const extractHeaderParts: (rawLine: string, errorHandler?: ErrorDataHandler | null, ctx?: SectionContext | null) => {
+declare const extractHeaderParts: (rawLine: string, errorHandler?: ErrorDataHandler | null, ctx?: StmtContext | null) => {
     strMarkerChars: string;
     strSectionName: string;
     strNumberPart: string;

package/dist/parsers/extractHeaderParts.js

@@ -22,6 +22,7 @@ const extractSignificantYiniLine_1 = require("./extractSignificantYiniLine");
  * - Backticked identifiers must be on a single line and must not contain tabs or new lines unless using escaping codes, except for ordinary spaces.
  * - Special control characters (U+0000–U+001F) must be escaped.
  *
+ * @note Implemented without regexp to keep it less cryptic, etc.
  * @note Returns the parts as strings; each part needs to be analyzed separately against the contraints in the specifications.
  * @returns An object with the identified header parts: marker characters, parsed name, and parsed level string.
  */

package/dist/parsers/parseBoolean.d.ts

@@ -1,5 +1,5 @@
 /**
  * Extract boolean literal.
  */
-declare const parseBooleanLiteral: (txt: string) => boolean;
+declare const parseBooleanLiteral: (text: string) => boolean;
 export default parseBooleanLiteral;

package/dist/parsers/parseBoolean.js

@@ -4,8 +4,9 @@ const print_1 = require("../utils/print");
 /**
  * Extract boolean literal.
  */
-const parseBooleanLiteral = (txt) => {
+const parseBooleanLiteral = (text) => {
     (0, print_1.debugPrint)('-> Entered parseBooleanLiteral(..)');
+    const txt = text.trim().toLowerCase();
     const value = !!(txt === 'true' || txt === 'yes' || txt === 'on');
     return value;
 };

package/dist/parsers/parseNumber.d.ts

@@ -1,6 +1,11 @@
-import { TDataType } from '../core/YINIVisitor';
+/**
+ * @property {string | undefined} [tag]
+ *           This parameter is for debugging only. Its
+ *           contents may change at any time and should not
+ *           be relied upon for any significant purpose.
+ */
 declare const parseNumberLiteral: (txt: string) => {
-    type: TDataType;
-    value: number;
+    tag: string | undefined;
+    value: number | undefined;
 };
 export default parseNumberLiteral;