yini-parser 1.0.0-alpha.1 → 1.0.0-alpha.2

package/dist/grammar/YiniParser.d.ts

@@ -0,0 +1,284 @@
+import { ATN, DFA, FailedPredicateException, Parser, ParserRuleContext, TerminalNode, TokenStream } from 'antlr4';
+import YiniParserVisitor from "./YiniParserVisitor.js";
+export default class YiniParser extends Parser {
+    static readonly YINI_MARKER = 1;
+    static readonly SECTION_HEAD = 2;
+    static readonly TERMINAL_TOKEN = 3;
+    static readonly SS = 4;
+    static readonly EUR = 5;
+    static readonly CARET = 6;
+    static readonly TILDE = 7;
+    static readonly GT = 8;
+    static readonly LT = 9;
+    static readonly EQ = 10;
+    static readonly HASH = 11;
+    static readonly COMMA = 12;
+    static readonly COLON = 13;
+    static readonly OB = 14;
+    static readonly CB = 15;
+    static readonly OC = 16;
+    static readonly CC = 17;
+    static readonly PLUS = 18;
+    static readonly DOLLAR = 19;
+    static readonly PC = 20;
+    static readonly AT = 21;
+    static readonly SEMICOLON = 22;
+    static readonly BOOLEAN_FALSE = 23;
+    static readonly BOOLEAN_TRUE = 24;
+    static readonly NULL = 25;
+    static readonly EMPTY_OBJECT = 26;
+    static readonly EMPTY_LIST = 27;
+    static readonly SHEBANG = 28;
+    static readonly NUMBER = 29;
+    static readonly KEY = 30;
+    static readonly IDENT = 31;
+    static readonly IDENT_BACKTICKED = 32;
+    static readonly STRING = 33;
+    static readonly TRIPLE_QUOTED_STRING = 34;
+    static readonly SINGLE_OR_DOUBLE = 35;
+    static readonly R_AND_C_STRING = 36;
+    static readonly HYPER_STRING = 37;
+    static readonly ESC_SEQ = 38;
+    static readonly ESC_SEQ_BASE = 39;
+    static readonly NL = 40;
+    static readonly SINGLE_NL = 41;
+    static readonly WS = 42;
+    static readonly BLOCK_COMMENT = 43;
+    static readonly COMMENT = 44;
+    static readonly LINE_COMMENT = 45;
+    static readonly INLINE_COMMENT = 46;
+    static readonly IDENT_INVALID = 47;
+    static readonly EOF: number;
+    static readonly RULE_yini = 0;
+    static readonly RULE_section = 1;
+    static readonly RULE_terminal_line = 2;
+    static readonly RULE_section_members = 3;
+    static readonly RULE_member = 4;
+    static readonly RULE_member_colon_list = 5;
+    static readonly RULE_value = 6;
+    static readonly RULE_object_literal = 7;
+    static readonly RULE_objectMemberList = 8;
+    static readonly RULE_objectMember = 9;
+    static readonly RULE_list = 10;
+    static readonly RULE_list_in_brackets = 11;
+    static readonly RULE_elements = 12;
+    static readonly RULE_element = 13;
+    static readonly RULE_number_literal = 14;
+    static readonly RULE_null_literal = 15;
+    static readonly RULE_string_literal = 16;
+    static readonly RULE_string_concat = 17;
+    static readonly RULE_boolean_literal = 18;
+    static readonly literalNames: (string | null)[];
+    static readonly symbolicNames: (string | null)[];
+    static readonly ruleNames: string[];
+    get grammarFileName(): string;
+    get literalNames(): (string | null)[];
+    get symbolicNames(): (string | null)[];
+    get ruleNames(): string[];
+    get serializedATN(): number[];
+    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
+    constructor(input: TokenStream);
+    yini(): YiniContext;
+    section(): SectionContext;
+    terminal_line(): Terminal_lineContext;
+    section_members(): Section_membersContext;
+    member(): MemberContext;
+    member_colon_list(): Member_colon_listContext;
+    value(): ValueContext;
+    object_literal(): Object_literalContext;
+    objectMemberList(): ObjectMemberListContext;
+    objectMember(): ObjectMemberContext;
+    list(): ListContext;
+    list_in_brackets(): List_in_bracketsContext;
+    elements(): ElementsContext;
+    element(): ElementContext;
+    number_literal(): Number_literalContext;
+    null_literal(): Null_literalContext;
+    string_literal(): String_literalContext;
+    string_concat(): String_concatContext;
+    boolean_literal(): Boolean_literalContext;
+    static readonly _serializedATN: number[];
+    private static __ATN;
+    static get _ATN(): ATN;
+    static DecisionsToDFA: DFA[];
+}
+export declare class YiniContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    SHEBANG(): TerminalNode;
+    INLINE_COMMENT_list(): TerminalNode[];
+    INLINE_COMMENT(i: number): TerminalNode;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    YINI_MARKER(): TerminalNode;
+    section_list(): SectionContext[];
+    section(i: number): SectionContext;
+    terminal_line(): Terminal_lineContext;
+    EOF(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class SectionContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    section_members(): Section_membersContext;
+    SECTION_HEAD(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class Terminal_lineContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    TERMINAL_TOKEN(): TerminalNode;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    INLINE_COMMENT(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class Section_membersContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    member_list(): MemberContext[];
+    member(i: number): MemberContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class MemberContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    KEY(): TerminalNode;
+    EQ(): TerminalNode;
+    WS_list(): TerminalNode[];
+    WS(i: number): TerminalNode;
+    value(): ValueContext;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    member_colon_list(): Member_colon_listContext;
+    SECTION_HEAD(): TerminalNode;
+    section_members(): Section_membersContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class Member_colon_listContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    KEY(): TerminalNode;
+    COLON(): TerminalNode;
+    WS(): TerminalNode;
+    elements(): ElementsContext;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class ValueContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    null_literal(): Null_literalContext;
+    string_literal(): String_literalContext;
+    number_literal(): Number_literalContext;
+    boolean_literal(): Boolean_literalContext;
+    list_in_brackets(): List_in_bracketsContext;
+    object_literal(): Object_literalContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class Object_literalContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    OC(): TerminalNode;
+    objectMemberList(): ObjectMemberListContext;
+    CC(): TerminalNode;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    EMPTY_OBJECT(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class ObjectMemberListContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    objectMember_list(): ObjectMemberContext[];
+    objectMember(i: number): ObjectMemberContext;
+    COMMA_list(): TerminalNode[];
+    COMMA(i: number): TerminalNode;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    EMPTY_OBJECT(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class ObjectMemberContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    KEY(): TerminalNode;
+    EQ(): TerminalNode;
+    value(): ValueContext;
+    WS(): TerminalNode;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class ListContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    elements(): ElementsContext;
+    list_in_brackets(): List_in_bracketsContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class List_in_bracketsContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    OB(): TerminalNode;
+    elements(): ElementsContext;
+    CB(): TerminalNode;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    EMPTY_LIST(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class ElementsContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    element(): ElementContext;
+    COMMA(): TerminalNode;
+    elements(): ElementsContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class ElementContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    value(): ValueContext;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    list_in_brackets(): List_in_bracketsContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class Number_literalContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    NUMBER(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class Null_literalContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    NULL(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class String_literalContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    STRING(): TerminalNode;
+    string_concat_list(): String_concatContext[];
+    string_concat(i: number): String_concatContext;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class String_concatContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    PLUS(): TerminalNode;
+    STRING(): TerminalNode;
+    NL_list(): TerminalNode[];
+    NL(i: number): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}
+export declare class Boolean_literalContext extends ParserRuleContext {
+    constructor(parser?: YiniParser, parent?: ParserRuleContext, invokingState?: number);
+    BOOLEAN_FALSE(): TerminalNode;
+    BOOLEAN_TRUE(): TerminalNode;
+    get ruleIndex(): number;
+    accept<Result>(visitor: YiniParserVisitor<Result>): Result;
+}

package/dist/grammar/YiniParserVisitor.d.ts

@@ -0,0 +1,143 @@
+import { ParseTreeVisitor } from 'antlr4';
+import { YiniContext } from "./YiniParser.js";
+import { SectionContext } from "./YiniParser.js";
+import { Terminal_lineContext } from "./YiniParser.js";
+import { Section_membersContext } from "./YiniParser.js";
+import { MemberContext } from "./YiniParser.js";
+import { Member_colon_listContext } from "./YiniParser.js";
+import { ValueContext } from "./YiniParser.js";
+import { Object_literalContext } from "./YiniParser.js";
+import { ObjectMemberListContext } from "./YiniParser.js";
+import { ObjectMemberContext } from "./YiniParser.js";
+import { ListContext } from "./YiniParser.js";
+import { List_in_bracketsContext } from "./YiniParser.js";
+import { ElementsContext } from "./YiniParser.js";
+import { ElementContext } from "./YiniParser.js";
+import { Number_literalContext } from "./YiniParser.js";
+import { Null_literalContext } from "./YiniParser.js";
+import { String_literalContext } from "./YiniParser.js";
+import { String_concatContext } from "./YiniParser.js";
+import { Boolean_literalContext } from "./YiniParser.js";
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by `YiniParser`.
+ *
+ * @param <Result> The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ */
+export default class YiniParserVisitor<Result> extends ParseTreeVisitor<Result> {
+    /**
+     * Visit a parse tree produced by `YiniParser.yini`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitYini?: (ctx: YiniContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.section`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSection?: (ctx: SectionContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.terminal_line`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitTerminal_line?: (ctx: Terminal_lineContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.section_members`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSection_members?: (ctx: Section_membersContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.member`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMember?: (ctx: MemberContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.member_colon_list`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMember_colon_list?: (ctx: Member_colon_listContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.value`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitValue?: (ctx: ValueContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.object_literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitObject_literal?: (ctx: Object_literalContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.objectMemberList`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitObjectMemberList?: (ctx: ObjectMemberListContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.objectMember`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitObjectMember?: (ctx: ObjectMemberContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.list`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitList?: (ctx: ListContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.list_in_brackets`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitList_in_brackets?: (ctx: List_in_bracketsContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.elements`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitElements?: (ctx: ElementsContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.element`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitElement?: (ctx: ElementContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.number_literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitNumber_literal?: (ctx: Number_literalContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.null_literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitNull_literal?: (ctx: Null_literalContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.string_literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitString_literal?: (ctx: String_literalContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.string_concat`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitString_concat?: (ctx: String_concatContext) => Result;
+    /**
+     * Visit a parse tree produced by `YiniParser.boolean_literal`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitBoolean_literal?: (ctx: Boolean_literalContext) => Result;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { default } from './YINI';

package/dist/parseEntry.d.ts

@@ -0,0 +1,2 @@
+import { IParseMainOptions } from './core/types';
+export declare const parseMain: (yiniContent: string, options?: IParseMainOptions) => any;

package/dist/parsers/extractHeaderParts.d.ts

@@ -0,0 +1,31 @@
+import { ErrorDataHandler } from '../core/ErrorDataHandler';
+import { SectionContext } 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
+ * marker will be identified. E.g. does the header start with '^^^' or '^3'
+ * and then some identifier.
+ *
+ * Below, copied from YINI Specification v1.0.0 Beta 7.
+ * Form 1: Identifier of Simple Form:
+ * - Keys must be non-empty.
+ * - Keys are case-sensitive (`Title` and `title` are different).
+ * - Can only contain letters (a-z or A-Z), digits (0-9) and underscores `_`.
+ * - Must begin with a letter or an underscore `_`.
+ * - Note: Cannot contain hyphens (`-`) or periods (`.`).
+ *
+ * Form 2: Backticked Identifier:
+ * - A phrase is a name wrapped in backticks  ``` ` ```.
+ * - 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 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) => {
+    strMarkerChars: string;
+    strSectionName: string;
+    strNumberPart: string;
+    isBacktickedName: boolean;
+};
+export default extractHeaderParts;

package/dist/parsers/extractSignificantYiniLine.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Extract significant YINI line from YINI content (that may be surrounded by comments.).
+ * @param rawYiniContent For example:
+ *     // This whole line is a comment.
+ *     ^SectionName# This part is a comment.
+ *     // This whole line is a comment.
+ * @returns Will filter out any comments (before or after) and return only one single significant YINI line.
+ */
+export declare const extractYiniLine: (rawYiniContent: string) => string;

package/dist/parsers/parseBoolean.d.ts

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

package/dist/parsers/parseNull.d.ts

@@ -0,0 +1,2 @@
+declare const parseNullLiteral: (txt: string) => null;
+export default parseNullLiteral;

package/dist/parsers/parseNumber.d.ts

@@ -0,0 +1,6 @@
+import { TDataType } from '../core/YINIVisitor';
+declare const parseNumberLiteral: (txt: string) => {
+    type: TDataType;
+    value: number;
+};
+export default parseNumberLiteral;

package/dist/parsers/parseSectionHeader.d.ts

@@ -0,0 +1,13 @@
+import { ErrorDataHandler } from '../core/ErrorDataHandler';
+import { TSectionHeaderType } from '../core/types';
+import { SectionContext } from '../grammar/YiniParser';
+/**
+ * Extract ...
+ * @param rawLine Raw line with the section header.
+ */
+declare const parseSectionHeader: (rawLine: string, errorHandler: ErrorDataHandler, ctx: null | SectionContext) => {
+    markerType: TSectionHeaderType;
+    sectionName: string;
+    sectionLevel: number;
+};
+export default parseSectionHeader;

package/dist/parsers/parseString.d.ts

@@ -0,0 +1,2 @@
+declare const parseStringLiteral: (raw: string) => string;
+export default parseStringLiteral;

package/dist/utils/pathAndFileName.d.ts

@@ -0,0 +1,5 @@
+/**
+ * This file contains general path and file name helper functions (utils).
+ * @note More specific YINI helper functions should go into yiniHelpers.ts-file.
+ */
+export declare const getFileNameExtension: (fullPath: string) => string;

package/dist/utils/string.d.ts

@@ -0,0 +1,42 @@
+/**
+ * This file contains general string helper functions (utils).
+ * @note More specific YINI helper functions should go into yiniHelpers.ts-file.
+ */
+/**
+ * Splits a string into an array of lines, handling both LF and CRLF newlines.
+ * @param content The input string.
+ * @returns Array of lines (strings).
+ */
+export declare function splitLines(content: string): string[];
+/**
+ * If a string starts and ends with a backtick `, if so trims the
+ * first and last character (the backticks).
+ */
+export declare const trimBackticks: (str: string) => string;
+/**
+ * Returns true if the provided string is enclosed in backticks, e.g. `name`.
+ */
+export declare const isEnclosedInBackticks: (str: string) => boolean;
+/**
+ * Check if the character is A-Z or a-z.
+ * @note The string must be of length 1.
+ * @param character A character in a string.
+ */
+export declare const isAlpha: (character: string) => boolean;
+/**
+ * Check if the character is a digit (number): 0-9.
+ * @note The string must be of length 1.
+ * @param character A character in a string.
+ */
+export declare const isDigit: (character: string) => boolean;
+/**
+ * @returns Returns the beginning up to (but not including) any first
+ * encountered newline.
+ * @note If no newline is found, returns the whole string.
+ * @example
+ *     `SectionName1
+ *     //value = 11`
+ *     => 'SectionName1'
+ * @deprecated This seems not useful anymore, use stripCommentsAndAfter(..) instead.
+ */
+export declare const stripNLAndAfter: (line: string) => string;

package/dist/utils/system.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This file contains general system helper functions (utils).
+ * @note More specific YINI helper functions should go into yiniHelpers.ts-file.
+ */
+export declare const debugPrint: (str?: any) => void;
+export declare const devPrint: (str?: any) => void;
+export declare const printObject: (obj: any) => void;

package/dist/yiniHelpers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * This file contains specific YINI helper functions (utils).
+ * @note More general helper functions should go into the dir "src/utils/".
+ */
+/**
+ * Check if the character is a section marker character.
+ * @param character A character in a string.
+ * @note The string must be of length 1.
+ * @throws Will throw if not exactly of length 1.
+ */
+export declare const isMarkerCharacter: (character: string) => boolean;
+/**
+ * @returns Returns the beginning up to (but not including) any comments
+ * starting with //, #, ; or --.
+ * @throws Will throw if consisting more than 1 lines.
+ */
+export declare const stripCommentsAndAfter: (line: string) => string;
+/**
+ * Checks if a string conforms to the identifier rules for section headers and
+ * member key names as defined by the YINI specification, following
+ * the ANTLR4 lexer rule:
+ * IDENT: ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '0'..'9' | '_')*
+
+* @throws Will only throw if blank string.
+ *
+ * @satisfies Should satisfy YINI spec 7, chapter: 3.4. Identifiers, Form 1:
+ * Identifier of Simple Form.
+ * @link https://github.com/YINI-lang/YINI-spec/blob/develop/YINI-Specification.md#34-identifiers
+ */
+export declare const isValidSimpleIdent: (str: string) => boolean;
+/**
+ * Checks if a string is a valid backticked phrase/identifier:
+ * - Wrapped in backticks.
+ * - No raw tabs, newlines, or control characters (U+0000–U+001F), except as
+ *   escaped sequences (e.g., \n).
+ * - May contain ordinary spaces.
+ * @note Empty is allowed: ``, as in spec (due to conform with the JSON empty key "").
+ * @throws Will only throw if missing enclosed backtick(s).
+ *
+ * @satisfies Should satisfy YINI spec 7, chapter: 3.4. Identifiers, Form 2:
+ * Backticked Identifier.
+ * @link https://github.com/YINI-lang/YINI-spec/blob/develop/YINI-Specification.md#34-identifiers
+ */
+export declare const isValidBacktickedIdent: (str: string) => boolean;

package/package.json

@@ -1,18 +1,28 @@
 {
     "name": "yini-parser",
-    "version": "1.0.0-alpha.1",
+    "version": "1.0.0-alpha.2",
     "description": "YINI parser for JavaScript/TypeScript, an INI-inspired configuration format, meant to be readable, and easy to use.",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
+    "keywords": [
+        "read",
+        "yini",
+        "config",
+        "ini",
+        "parser",
+        "file",
+        "parse",
+        "configuration"
+    ],
+    "homepage": "https://m4se.com/yini-lang.org/",
+    "license": "Apache-2.0",
     "files": [
         "dist/",
-        "index.js",
-        "index.d.ts",
         "package.json",
         "README.md",
         "LICENSE",
         "CHANGELOG.md"
     ],
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
     "exports": {
         ".": {
             "import": "./dist/index.js",
@@ -22,20 +32,8 @@
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/YOUR_USERNAME/yini-parser.git"
+        "url": "https://github.com/YINI-lang/yini-parser-typescript.git"
     },
-    "keywords": [
-        "read",
-        "yini",
-        "config",
-        "ini",
-        "parser",
-        "file",
-        "parse",
-        "configuration"
-    ],
-    "author": "Marko K. Seppänen",
-    "license": "Apache-2.0",
     "private": false,
     "scripts": {
         "start": "cross-env NODE_ENV=production APP_ENV=production node dist/index.js",
@@ -60,6 +58,7 @@
         "build": "tsc -p ./tsconfig.json",
         "prepublishOnly": "npm run lint && npm test && npm run build"
     },
+    "author": "Marko K. Seppänen",
     "dependencies": {
         "antlr4": "^4.13.2"
     },