yini-parser 1.6.0 → 1.6.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 1.6.1 - 2026 June  
+- **Fixed:** Aligned parser behavior with the external `yini-test` conformance suite for shebang-like comment lines, misplaced `@yini` directives, and triple-quoted string line endings.
+- **Fixed:** `#!` lines after an opening `@yini` marker are now treated as comment trivia, while `@yini` directives after document content are reported as syntax errors in both lenient and strict mode.
+- **Fixed:** Triple-quoted raw and Classic strings now normalize physical `CRLF`/`CR` line endings to `LF`, producing stable output across platforms.
+- **Fixed:** Diagnostic line numbers no longer shift by one after a valid shebang line; strict-mode trailing-comma errors now point to the actual physical source line.
+- **Fixed:** Removed the outdated warning `Warning: Strict initialMode is not yet fully implemented.` Strict mode is now implemented against the latest YINI Specification RC 6.
+- **Improved:** Parse errors now use a concise `YiniParseError`, and missing `/END` messages clearly explain that `/END` is required in strict mode but optional in the default lenient mode.
+
 ## 1.6.0 - 2026 May
 - **Improved:** Reduced the published npm package contents by excluding development-only build output, internal tool output, and duplicate `dist/src` declaration files from the package tarball.
 - **Added:** Implemented a `yini-test` adapter (`tools/yini-test-adapter.ts`) for testing this parser against an external conformance corpus. The `yini-test` corpus/test runner is planned to be made public and released separately in the future.

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2024 Gothenburg, Marko K. S. (Sweden via Finland).
+   Copyright 2026 Marko K. Seppänen
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -71,6 +71,20 @@ console.log(config.App.name)              // My App
 console.log(config.App.Features.caching)  // true
 ```
 
+### Modes and `/END`
+
+`yini-parser` runs in lenient mode by default. In lenient mode, the document terminator `/END` is optional.
+
+Strict mode requires `/END` unless you explicitly override `requireDocTerminator`:
+
+```ts
+const config = YINI.parseFile('./config.yini', {
+  strictMode: true,
+})
+```
+
+If strict mode reports a missing `/END`, either add `/END` as the final significant line or parse with the default lenient mode.
+
 See the [YINI specification and documentation](https://yini-lang.org/refs/specification?utm_source=github&utm_medium=referral&utm_campaign=yini_parser_ts&utm_content=readme).
 
 ---
@@ -298,6 +312,8 @@ When reporting parser behavior, it is helpful to include:
 
 This parser is covered by smoke, integration, and regression tests across lenient, strict, and metadata-enabled modes.
 
+It has also been run against `yini-test-suite` v0.3.0, the external [YINI conformance test suite](https://github.com/YINI-lang/yini-test-suite), with all TypeScript parser cases passing.
+
 ---
 
 ## Links

package/dist/YINI.js

@@ -137,6 +137,9 @@ class YINI {
             text.includes('active parser mode')) {
             return 'YINI_MODE_MISMATCH';
         }
+        if (text.includes('directive') && text.includes('wrong place')) {
+            return 'misplaced-directive';
+        }
         if (text.includes('invalid escape sequence')) {
             return 'invalid-escape-sequence';
         }

package/dist/core/astBuilder.js

@@ -289,7 +289,7 @@ class ASTBuilder extends YiniParserVisitor_1.default {
             (0, print_1.debugPrint)('-> Entered visitDirective(..)');
             const rawText = (0, yiniHelpers_1.stripCommentsAndAfter)(ctx.getText().trim());
             if (this.mapSectionNamePaths.size || this._numOfMembers) {
-                this.errorHandler.pushOrBail((0, errorDataHandler_1.toErrorLocation)(ctx), this.isStrict ? 'Syntax-Error' : 'Syntax-Warning', `Found a directive statement in the wrong place ${this.isStrict ? '(strict mode)' : '(lenient mode)'}`, `Directive '${rawText}' must appear only at the beginning of the document, before any sections or members.`, 'Move the directive to the top of the file, after a possible shebang, comments, or whitespace.');
+                this.errorHandler.pushOrBail((0, errorDataHandler_1.toErrorLocation)(ctx), 'Syntax-Error', 'Found a directive statement in the wrong place', `Directive '${rawText}' must appear only at the beginning of the document, before any sections or members.`, 'Move the directive to the top of the file, after a possible shebang, comments, or whitespace.');
             }
             const yiniDirective = ctx.yini_directive?.();
             if (yiniDirective) {
@@ -1142,12 +1142,12 @@ class ASTBuilder extends YiniParserVisitor_1.default {
         const terminatorPolicy = this.options.rules.requireDocTerminator;
         if (isMissingTerminator && terminatorPolicy === 'required') {
             // Note, after pushing processing may continue or exit, depending on the error and/or the bail threshold.
-            this.errorHandler.pushOrBail(undefined, 'Syntax-Error', "Missing '/END' at end of document.", "The document terminator '/END' (case-insensitive) is required at the end of the document.", "Add '/END' as the final significant line, or change requireDocTerminator to 'optional' or 'warn-if-missing'.");
+            this.errorHandler.pushOrBail(undefined, 'Syntax-Error', "Missing '/END' at end of document.", "The document terminator '/END' (case-insensitive) is required at the end of the document.", "Add '/END' as the final significant line, parse in lenient mode, or change requireDocTerminator to 'optional' or 'warn-if-missing'.");
         }
         else if (isMissingTerminator &&
             terminatorPolicy === 'warn-if-missing') {
             // Note, after pushing processing may continue or exit, depending on the error and/or the bail threshold.
-            this.errorHandler.pushOrBail(undefined, 'Syntax-Warning', "Missing '/END' at end of document.", "The document terminator '/END' (case-insensitive) appears to be missing at the end of the document.", "Add '/END' as the final significant line, or change requireDocTerminator to 'optional'.");
+            this.errorHandler.pushOrBail(undefined, 'Syntax-Warning', "Missing '/END' at end of document.", "The document terminator '/END' (case-insensitive) appears to be missing at the end of the document.", "Add '/END' as the final significant line, parse in lenient mode, or change requireDocTerminator to 'optional'.");
         }
         this.ast.numOfSections = this.mapSectionNamePaths.size;
         this.ast.numOfMembers = this._numOfMembers;

package/dist/core/errorDataHandler.d.ts

@@ -1,6 +1,28 @@
 import { IssuePayload } from '../types';
 import { IErrorLocationInput, TBailSensitivityLevel, TIssueType, TSubjectType } from './internalTypes';
 export declare const toErrorLocation: (ctx: any) => IErrorLocationInput | undefined;
+export interface YiniParseErrorDetails {
+    type: TIssueType;
+    typeKey: string;
+    sourceType: TSubjectType;
+    fileName?: string;
+    line?: number;
+    column?: number;
+    message: string;
+    advice?: string;
+    hint?: string;
+}
+export declare class YiniParseError extends Error {
+    readonly type: TIssueType;
+    readonly typeKey: string;
+    readonly sourceType: TSubjectType;
+    readonly fileName?: string;
+    readonly line?: number;
+    readonly column?: number;
+    readonly advice?: string;
+    readonly hint?: string;
+    constructor(details: YiniParseErrorDetails);
+}
 /**
  * This class handles all error/notice reporting and processes exit/throwing.
  */
@@ -36,6 +58,7 @@ export declare class ErrorDataHandler {
     isSilent?: boolean, // Suppress all output (even errors, exit code only).
     isThrowOnError?: boolean);
     private makeIssue;
+    private throwParseError;
     /**
      * After pushing processing may continue or exit, depending on the error
      * and/or the bail threshold (that can be optionally set by the user).

package/dist/core/errorDataHandler.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorDataHandler = exports.toErrorLocation = void 0;
+exports.ErrorDataHandler = exports.YiniParseError = exports.toErrorLocation = void 0;
 // src/core/errorDataHandler.ts
 const env_1 = require("../config/env");
 const print_1 = require("../utils/print");
@@ -29,6 +29,66 @@ const issueTitle = [
     'Notice:',
     'Info:',
 ];
+class YiniParseError extends Error {
+    constructor(details) {
+        super(formatThrownMessage(details));
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = getErrorName(details.type);
+        this.type = details.type;
+        this.typeKey = details.typeKey;
+        this.sourceType = details.sourceType;
+        this.fileName = details.fileName;
+        this.line = details.line;
+        this.column = details.column;
+        this.advice = details.advice;
+        this.hint = details.hint;
+        // Node prints `error.stack` for uncaught errors. Keep parser failures
+        // focused on the user's document instead of internal parser frames.
+        this.stack = `${this.name}: ${this.message}`;
+    }
+}
+exports.YiniParseError = YiniParseError;
+const getErrorName = (type) => {
+    switch (type) {
+        case 'Syntax-Error':
+        case 'Syntax-Warning':
+            return 'YiniSyntaxError';
+        case 'Internal-Error':
+        case 'Fatal-Error':
+            return 'YiniInternalError';
+        default:
+            return 'YiniParseError';
+    }
+};
+const formatThrownMessage = (details) => {
+    const lines = [];
+    const location = formatThrownLocation(details);
+    const title = details.type.replace(/-/g, ' ');
+    lines.push(location
+        ? `${title} in ${location}: ${details.message}`
+        : `${title}: ${details.message}`);
+    if (details.advice) {
+        lines.push(details.advice);
+    }
+    if (details.hint) {
+        lines.push(`Hint: ${details.hint}`);
+    }
+    return lines.join('\n');
+};
+const formatThrownLocation = (details) => {
+    if (details.sourceType === 'None/Ignore')
+        return '';
+    let location = details.sourceType === 'File'
+        ? details.fileName || 'YINI file'
+        : 'inline YINI content';
+    if (details.line !== undefined) {
+        location += `:${details.line}`;
+        if (details.column !== undefined) {
+            location += `:${details.column}`;
+        }
+    }
+    return location;
+};
 /**
  * This class handles all error/notice reporting and processes exit/throwing.
  */
@@ -77,6 +137,19 @@ class ErrorDataHandler {
         (0, env_1.isDebug)() && console.log(issue);
         return issue;
     }
+    throwParseError(type, issue, msgWhatInclLineNum) {
+        throw new YiniParseError({
+            type,
+            typeKey: issue.typeKey,
+            sourceType: this.subjectType,
+            fileName: this.fileName,
+            line: issue.line,
+            column: issue.column,
+            message: msgWhatInclLineNum,
+            advice: issue.advice,
+            hint: issue.hint,
+        });
+    }
     /**
      * After pushing processing may continue or exit, depending on the error
      * and/or the bail threshold (that can be optionally set by the user).
@@ -126,7 +199,10 @@ class ErrorDataHandler {
         switch (type) {
             case 'Internal-Error':
                 this.numInternalErrors++;
-                this.errors.push(this.makeIssue(lineNum, colNum, type, msgWhat, msgWhy, msgHint));
+                {
+                    const issue = this.makeIssue(lineNum, colNum, type, msgWhat, msgWhy, msgHint);
+                    this.errors.push(issue);
+                }
                 this.emitInternalError(loc, msgWhatInclLineNum, msgWhy, msgHint);
                 if (this.persistThreshold === '1-Abort-on-Errors' ||
                     this.persistThreshold === '2-Abort-Even-on-Warnings') {
@@ -134,16 +210,16 @@ class ErrorDataHandler {
                         (0, print_1.debugPrint)('Skipped throwing');
                     }
                     else {
-                        const thrownMsg = msgWhy
-                            ? `Internal-Error: ${msgWhatInclLineNum}. ${msgWhy}`
-                            : `Internal-Error: ${msgWhatInclLineNum}`;
-                        throw new Error(thrownMsg);
+                        this.throwParseError(type, this.errors[this.errors.length - 1], msgWhatInclLineNum);
                     }
                 }
                 break;
             case 'Syntax-Error':
                 this.numSyntaxErrors++;
-                this.errors.push(this.makeIssue(lineNum, colNum, type, msgWhat, msgWhy, msgHint));
+                {
+                    const issue = this.makeIssue(lineNum, colNum, type, msgWhat, msgWhy, msgHint);
+                    this.errors.push(issue);
+                }
                 this.emitSyntaxError(loc, msgWhatInclLineNum, msgWhy, msgHint);
                 if (this.persistThreshold === '1-Abort-on-Errors' ||
                     this.persistThreshold === '2-Abort-Even-on-Warnings') {
@@ -151,16 +227,16 @@ class ErrorDataHandler {
                         (0, print_1.debugPrint)('Skipped throwing');
                     }
                     else {
-                        const thrownMsg = msgWhy
-                            ? `Syntax-Error: ${msgWhatInclLineNum}. ${msgWhy}`
-                            : `Syntax-Error: ${msgWhatInclLineNum}`;
-                        throw new Error(thrownMsg);
+                        this.throwParseError(type, this.errors[this.errors.length - 1], msgWhatInclLineNum);
                     }
                 }
                 break;
             case 'Syntax-Warning':
                 this.numSyntaxWarnings++;
-                this.warnings.push(this.makeIssue(lineNum, colNum, type, msgWhat, msgWhy, msgHint));
+                {
+                    const issue = this.makeIssue(lineNum, colNum, type, msgWhat, msgWhy, msgHint);
+                    this.warnings.push(issue);
+                }
                 if (!this.isQuiet) {
                     this.emitSyntaxWarning(loc, msgWhatInclLineNum, msgWhy, msgHint);
                 }
@@ -169,10 +245,7 @@ class ErrorDataHandler {
                         (0, print_1.debugPrint)('Skipped throwing');
                     }
                     else {
-                        const thrownMsg = msgWhy
-                            ? `Syntax-Error: ${msgWhatInclLineNum}. ${msgWhy}`
-                            : `Syntax-Error: ${msgWhatInclLineNum}`;
-                        throw new Error(thrownMsg);
+                        this.throwParseError(type, this.warnings[this.warnings.length - 1], msgWhatInclLineNum);
                     }
                 }
                 break;
@@ -200,10 +273,7 @@ class ErrorDataHandler {
                 // In test, throw an error instead of bailing/exiting.
                 // IMPORTANT: Never exit with exit code since this is a library!
                 {
-                    const thrownMsg = msgWhy
-                        ? `Internal-Error: ${msgWhatInclLineNum}. ${msgWhy}`
-                        : `Internal-Error: ${msgWhatInclLineNum}`;
-                    throw new Error(thrownMsg);
+                    this.throwParseError('Internal-Error', this.errors[this.errors.length - 1], msgWhatInclLineNum);
                 }
         }
     }

package/dist/core/pipeline/pipeline.js

@@ -196,8 +196,6 @@ const runPipeline = (yiniContent, coreOptions, runtimeInfo, _meta_userOpts) => {
     (0, env_1.isDebug)() && console.debug(finalJSResult);
     (0, print_1.debugPrint)();
     if (coreOptions.rules.initialMode === 'strict') {
-        // Note, after pushing processing may continue or exit, depending on the error and/or the bail threshold.
-        errorHandler.pushOrBail(undefined, 'Syntax-Warning', 'Warning: Strict initialMode is not yet fully implemented.', 'Some validation rules may still be missing or incomplete.');
         if (coreOptions.bailSensitivity === '0-Ignore-Errors') {
             if (coreOptions.isDiagnosticOutputEnabled &&
                 !coreOptions.isQuiet &&

package/dist/core/runtime.js

@@ -65,21 +65,6 @@ class YiniRuntime {
     runParse(yiniContent, arg2, // strictMode | options
     failLevel = 'auto', includeMetadata = false) {
         (0, print_1.debugPrint)('-> Entered runParse(..) in YiniRuntime class\n');
-        // Handle optional UTF-8 BOM content of file.
-        if (yiniContent.startsWith('\uFEFF')) {
-            // (!) NOTE: slice(1) only because UTF-8 BOM appears as one single Unicode code characte, even though it is 3 bytes (EF BB BF) on disk.
-            yiniContent = yiniContent.slice(1);
-            (0, print_1.devPrint)('runParse(..): BOM was detected and stripped BOM in UTF-8 content');
-        }
-        // Handle optional shebang line (if line starts with "#!").
-        if (yiniContent.startsWith('#!')) {
-            const newlineIndex = yiniContent.indexOf('\n');
-            (0, print_1.devPrint)('runParse(..): Shebang detected at first line, stripped line 1.');
-            if (newlineIndex < 2) {
-                throw new Error('Syntax-Error: Unexpected YINI input');
-            }
-            yiniContent = yiniContent.slice(newlineIndex + 1);
-        }
         // Runtime guard to catch illegal/ambiguous calls coming from JS or any-cast code
         if ((0, optionsFunctions_1.isOptionsObjectForm)(arg2) &&
             (failLevel !== 'auto' || includeMetadata !== false)) {
@@ -111,6 +96,7 @@ class YiniRuntime {
         }
         const originalContent = yiniContent;
         yiniContent = (0, validateShebangPlacement_1.stripBomAndValidShebang)(yiniContent);
+        yiniContent = (0, validateShebangPlacement_1.normalizeShebangCommentLines)(yiniContent);
         if (originalContent.startsWith('\uFEFF')) {
             (0, print_1.devPrint)('runParse(..): BOM was detected and stripped from UTF-8 content.');
         }

package/dist/index.d.ts

@@ -28,6 +28,8 @@ export declare const parseFile: typeof YINI.parseFile;
 export declare const parseForTooling: typeof YINI.parseForTooling;
 export declare const getTabSize: typeof YINI.getTabSize;
 export declare const setTabSize: typeof YINI.setTabSize;
+export { YiniParseError } from './core/errorDataHandler';
+export type { YiniParseErrorDetails } from './core/errorDataHandler';
 /**
  * Public type exports for the YINI parser.
  *

package/dist/index.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setTabSize = exports.getTabSize = exports.parseForTooling = exports.parseFile = exports.parse = void 0;
+exports.YiniParseError = exports.setTabSize = exports.getTabSize = exports.parseForTooling = exports.parseFile = exports.parse = void 0;
 /*
     This file is a pure barrel file.
 
@@ -50,4 +50,6 @@ exports.parseFile = YINI_1.default.parseFile;
 exports.parseForTooling = YINI_1.default.parseForTooling;
 exports.getTabSize = YINI_1.default.getTabSize;
 exports.setTabSize = YINI_1.default.setTabSize;
+var errorDataHandler_1 = require("./core/errorDataHandler");
+Object.defineProperty(exports, "YiniParseError", { enumerable: true, get: function () { return errorDataHandler_1.YiniParseError; } });
 //# sourceMappingURL=index.js.map

package/dist/parsers/parseString.js

@@ -147,17 +147,19 @@ const parseClassicEscapes = (input, isAllowRealLineBreaks = false) => {
     }
     return result;
 };
+const normalizeRealLineBreaks = (value) => value.replace(/\r\n?/g, '\n');
 const parseStringLiteral = ({ strKind, value }) => {
     switch (strKind) {
         case 'raw':
-        case 'triple-raw':
             // Raw strings preserve content exactly as provided by the lexer.
             // Single-line raw string constraints are enforced by the lexer.
             return value;
+        case 'triple-raw':
+            return normalizeRealLineBreaks(value);
         case 'classic':
             return parseClassicEscapes(value, false);
         case 'triple-classic':
-            return parseClassicEscapes(value, true);
+            return parseClassicEscapes(normalizeRealLineBreaks(value), true);
         default:
             throw new CYiniStringParseError(`Unknown string kind: ${strKind}`);
     }

package/dist/parsers/validateShebangPlacement.d.ts

@@ -1,3 +1,4 @@
 import { IPreflightIssue } from '../core/internalTypes';
 export declare const getShebangPlacementIssue: (input: string, strictMode: boolean) => IPreflightIssue | undefined;
+export declare const normalizeShebangCommentLines: (input: string) => string;
 export declare const stripBomAndValidShebang: (input: string) => string;

package/dist/parsers/validateShebangPlacement.js

@@ -1,10 +1,51 @@
 "use strict";
 // src/parsers/validateShebangPlacement.ts
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stripBomAndValidShebang = exports.getShebangPlacementIssue = void 0;
+exports.stripBomAndValidShebang = exports.normalizeShebangCommentLines = exports.getShebangPlacementIssue = void 0;
+const isLineTriviaBeforeContent = (line) => {
+    const trimmed = line.trimStart();
+    return (trimmed === '' ||
+        trimmed.startsWith('//') ||
+        trimmed.startsWith(';') ||
+        trimmed.startsWith('--') ||
+        trimmed.startsWith('# ') ||
+        trimmed.startsWith('#\t'));
+};
+const isYiniDirectiveLine = (line) => /^\s*@yini(?:\s|$)/i.test(line);
+const getShebangCommentLines = (input) => {
+    const text = input.startsWith('\uFEFF') ? input.slice(1) : input;
+    const lines = text.split(/\r?\n/);
+    const commentLines = new Set();
+    let seenYiniDirective = false;
+    let seenContent = false;
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (index === 0 && line.startsWith('#!')) {
+            continue;
+        }
+        if (line.startsWith('#!')) {
+            if (seenYiniDirective && !seenContent) {
+                commentLines.add(index);
+                continue;
+            }
+            seenContent = true;
+            continue;
+        }
+        if (isLineTriviaBeforeContent(line)) {
+            continue;
+        }
+        if (!seenContent && isYiniDirectiveLine(line)) {
+            seenYiniDirective = true;
+            continue;
+        }
+        seenContent = true;
+    }
+    return commentLines;
+};
 const getShebangPlacementIssue = (input, strictMode) => {
     const text = input.startsWith('\uFEFF') ? input.slice(1) : input;
     const lines = text.split(/\r?\n/);
+    const shebangCommentLines = getShebangCommentLines(input);
     for (let index = 0; index < lines.length; index++) {
         const line = lines[index];
         const trimmedStart = line.trimStart();
@@ -16,6 +57,9 @@ const getShebangPlacementIssue = (input, strictMode) => {
         if (isFirstLine && startsAtFirstColumn) {
             return undefined;
         }
+        if (shebangCommentLines.has(index)) {
+            continue;
+        }
         const message = 'Misplaced shebang-like sequence. A shebang is only recognized when #! is the first two non-BOM characters of the document.';
         const lineNumber = index + 1;
         const columnNumber = line.length - trimmedStart.length + 1;
@@ -34,6 +78,23 @@ const getShebangPlacementIssue = (input, strictMode) => {
     return undefined;
 };
 exports.getShebangPlacementIssue = getShebangPlacementIssue;
+const normalizeShebangCommentLines = (input) => {
+    const shebangCommentLines = getShebangCommentLines(input);
+    if (shebangCommentLines.size === 0) {
+        return input;
+    }
+    const parts = input.split(/(\r\n|\n|\r)/);
+    const result = [];
+    let lineIndex = 0;
+    for (let index = 0; index < parts.length; index += 2) {
+        const line = parts[index] ?? '';
+        const eol = parts[index + 1] ?? '';
+        result.push(shebangCommentLines.has(lineIndex) ? line.replace(/^#!/, '//') : line, eol);
+        lineIndex++;
+    }
+    return result.join('');
+};
+exports.normalizeShebangCommentLines = normalizeShebangCommentLines;
 const stripBomAndValidShebang = (input) => {
     let text = input;
     if (text.startsWith('\uFEFF')) {
@@ -46,7 +107,9 @@ const stripBomAndValidShebang = (input) => {
     if (newlineIndex < 0) {
         return '';
     }
-    return text.slice(newlineIndex + 1);
+    // Keep the newline so downstream parser locations still match the
+    // original source line numbers after ignoring the shebang content.
+    return text.slice(newlineIndex);
 };
 exports.stripBomAndValidShebang = stripBomAndValidShebang;
 //# sourceMappingURL=validateShebangPlacement.js.map

package/examples/basic.yini

@@ -4,6 +4,7 @@
 title = 'My App'
 items = 10
 debug = ON
+isDarkTheme = ON
 
 ^ Server
 host = "localhost"

package/examples/parse-example.ts

@@ -11,6 +11,7 @@ import YINI from 'yini-parser'
 const configPath = path.resolve(__dirname, './basic.yini')
 
 // Parse the YINI config file.
+// By default the parser runs in lenient mode, where '/END' is optional.
 const config = YINI.parseFile(configPath)
 
 // Output some example values.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "yini-parser",
-    "version": "1.6.0",
+    "version": "1.6.1",
     "description": "Official Node.js (TypeScript) parser for YINI, an INI-inspired, indentation-insensitive configuration format with clear nested sections and explicit structure.",
     "keywords": [
         "yini",