@tabnas/parser 0.2.0

package/dist/types.d.ts

@@ -0,0 +1,527 @@
+export declare const OPEN: RuleState;
+export declare const CLOSE: RuleState;
+export declare const BEFORE: RuleStep;
+export declare const AFTER: RuleStep;
+export declare const EMPTY = "";
+export declare const INSPECT: unique symbol;
+export declare const SKIP: unique symbol;
+export declare const STRING = "string";
+export type TabnasParse = (src: any, meta?: any, parent_ctx?: any) => any;
+export type GrammarSetting = {
+    rule?: {
+        alt?: {
+            g?: string | string[];
+        };
+    };
+};
+export type TabnasInternal = {
+    parser: Parser;
+    config: Config;
+    plugins: Plugin[];
+    sub: {
+        lex?: LexSub[];
+        rule?: RuleSub[];
+    };
+    mark: number;
+    merged: Record<string, any>;
+};
+import type { Tabnas } from './tabnas';
+export type { Tabnas };
+export type Plugin = ((tabnas: Tabnas, // Instance to extend.
+plugin_options?: any) => void | Tabnas) & {
+    defaults?: Record<string, any>;
+    options?: Record<string, any>;
+};
+export type TabnasOptions = {
+    plugins?: Plugin[];
+    safe?: {
+        key: boolean;
+    };
+    tag?: string;
+    fixed?: {
+        lex?: boolean;
+        token?: StrMap;
+        check?: LexCheck;
+    };
+    match?: {
+        lex?: boolean;
+        token?: {
+            [name: string]: RegExp | LexMatcher;
+        };
+        value?: {
+            [name: string]: {
+                match: RegExp | LexMatcher;
+                val?: any;
+            };
+        };
+        check?: LexCheck;
+    };
+    tokenSet?: {
+        [name: string]: string[];
+    };
+    space?: {
+        lex?: boolean;
+        chars?: string;
+        check?: LexCheck;
+    };
+    line?: {
+        lex?: boolean;
+        chars?: string;
+        rowChars?: string;
+        single?: boolean;
+        check?: LexCheck;
+    };
+    text?: {
+        lex?: boolean;
+        modify?: ValModifier | ValModifier[];
+        check?: LexCheck;
+    };
+    number?: {
+        lex?: boolean;
+        hex?: boolean;
+        oct?: boolean;
+        bin?: boolean;
+        sep?: string | null;
+        exclude?: RegExp;
+        check?: LexCheck;
+    };
+    comment?: {
+        lex?: boolean;
+        def?: {
+            [name: string]: {
+                line?: boolean;
+                start?: string;
+                end?: string;
+                lex?: boolean;
+                suffix?: string | string[] | LexMatcher;
+                eatline: boolean;
+            } | null | undefined | false;
+        };
+        check?: LexCheck;
+    };
+    string?: {
+        lex?: boolean;
+        chars?: string;
+        multiChars?: string;
+        escapeChar?: string;
+        escape?: {
+            [char: string]: string | null;
+        };
+        allowUnknown?: boolean;
+        escapeStrict?: boolean;
+        replace?: {
+            [char: string]: string | null;
+        };
+        abandon?: boolean;
+        check?: LexCheck;
+    };
+    map?: {
+        extend?: boolean;
+        merge?: (prev: any, curr: any) => any;
+        child?: boolean;
+    };
+    list?: {
+        property: boolean;
+        pair: boolean;
+        child: boolean;
+    };
+    info?: {
+        map?: boolean;
+        list?: boolean;
+        text?: boolean;
+        marker?: string;
+    };
+    value?: {
+        lex?: boolean;
+        def?: {
+            [src: string]: undefined | null | false | {
+                val: any;
+                match?: RegExp;
+                consume?: boolean;
+            };
+        };
+    };
+    ender?: string | string[];
+    plugin?: Record<string, any>;
+    debug?: {
+        get_console?: () => any;
+        maxlen?: number;
+        print?: {
+            config?: boolean;
+            src?: (x: any) => string;
+        };
+    };
+    error?: {
+        [code: string]: string;
+    };
+    errmsg?: {
+        name?: string;
+        suffix?: boolean | string | ((color?: any, spec?: any) => string);
+        link?: string;
+    };
+    hint?: any;
+    lex?: {
+        empty?: boolean;
+        emptyResult?: any;
+        match: {
+            [name: string]: {
+                order: number;
+                make: MakeLexMatcher;
+            };
+        };
+    };
+    parse?: {
+        prepare?: {
+            [name: string]: ParsePrepare;
+        };
+    };
+    rule?: {
+        start?: string;
+        finish?: boolean;
+        maxmul?: number;
+        include?: string;
+        exclude?: string;
+    };
+    result?: {
+        fail: any[];
+    };
+    rewind?: {
+        history?: number;
+    };
+    config?: {
+        modify?: {
+            [plugin_name: string]: (config: Config, options: TabnasOptions) => void;
+        };
+    };
+    parser?: {
+        start?: (// Custom parse entry point.
+        lexer: any, src: string, tabnas: Tabnas, meta?: any, parent_ctx?: any) => any;
+    };
+    standard$?: boolean;
+    defaults$?: boolean;
+    grammar$?: boolean;
+    color?: {
+        active?: boolean;
+        reset?: string;
+        hi?: string;
+        lo?: string;
+        line?: string;
+    };
+};
+import type { Rule, RuleSpec } from './rules';
+export type { Rule, RuleSpec };
+import type { Context } from './context';
+export type { Context };
+import type { Lex } from './lexer';
+export type { Lex };
+export type NextToken = (rule: Rule) => Token;
+export type Config = {
+    safe: {
+        key: boolean;
+    };
+    lex: {
+        match: LexMatcher[];
+        empty: boolean;
+        emptyResult: any;
+    };
+    parse: {
+        prepare: ParsePrepare[];
+    };
+    rule: {
+        start: string;
+        maxmul: number;
+        finish: boolean;
+        include: string[];
+        exclude: string[];
+    };
+    fixed: {
+        lex: boolean;
+        token: TokenMap;
+        ref: Record<string | Tin, Tin | string>;
+        check?: LexCheck;
+    };
+    match: {
+        lex: boolean;
+        value: {
+            [name: string]: {
+                match: RegExp | LexMatcher;
+                val?: any;
+            };
+        };
+        token: MatchMap;
+        check?: LexCheck;
+    };
+    tokenSet: TokenSetMap;
+    tokenSetTins: {
+        [name: string]: {
+            [tin: number]: boolean;
+        };
+    };
+    space: {
+        lex: boolean;
+        chars: Chars;
+        charsBitmap: Uint8Array;
+        check?: LexCheck;
+    };
+    line: {
+        lex: boolean;
+        chars: Chars;
+        charsBitmap: Uint8Array;
+        rowChars: Chars;
+        rowCharsBitmap: Uint8Array;
+        single: boolean;
+        check?: LexCheck;
+    };
+    text: {
+        lex: boolean;
+        modify: ValModifier[];
+        check?: LexCheck;
+    };
+    number: {
+        lex: boolean;
+        hex: boolean;
+        oct: boolean;
+        bin: boolean;
+        sep: boolean;
+        exclude?: RegExp;
+        sepChar?: string | null;
+        check?: LexCheck;
+    };
+    string: {
+        lex: boolean;
+        quoteMap: Chars;
+        quoteBitmap: Uint8Array;
+        escMap: Record<string, any>;
+        escBitmap: Uint8Array;
+        escChar?: string;
+        escCharCode?: number;
+        multiChars: Chars;
+        multiBitmap: Uint8Array;
+        allowUnknown: boolean;
+        escapeStrict: boolean;
+        replaceCodeMap: {
+            [charCode: number]: string;
+        };
+        hasReplace: boolean;
+        abandon: boolean;
+        check?: LexCheck;
+    };
+    value: {
+        lex: boolean;
+        def: {
+            [src: string]: {
+                val: any;
+            };
+        };
+        defre: {
+            name: string;
+            val: (res: any) => any;
+            match: RegExp;
+            consume: boolean;
+        }[];
+    };
+    comment: {
+        lex: boolean;
+        def: {
+            [name: string]: {
+                name: string;
+                line: boolean;
+                start: string;
+                end?: string;
+                lex: boolean;
+                eatline: boolean;
+                suffixes?: string[];
+                suffixFn?: LexMatcher;
+            };
+        };
+        check?: LexCheck;
+    };
+    map: {
+        extend: boolean;
+        merge?: (prev: any, curr: any, rule: Rule, ctx: Context) => any;
+        child: boolean;
+    };
+    list: {
+        property: boolean;
+        pair: boolean;
+        child: boolean;
+    };
+    info: {
+        map: boolean;
+        list: boolean;
+        text: boolean;
+        marker: string;
+    };
+    debug: {
+        get_console: () => any;
+        maxlen: number;
+        print: {
+            config: boolean;
+            src?: (x: any) => string;
+        };
+    };
+    result: {
+        fail: any[];
+    };
+    rewind: {
+        history: number;
+    };
+    error: {
+        [code: string]: string;
+    };
+    errmsg: {
+        name: string;
+        suffix: boolean | string | ((color?: any, spec?: any) => string);
+        link?: string;
+    };
+    hint: any;
+    rePart: any;
+    re: any;
+    tI: number;
+    t: Record<string, Tin>;
+    color: {
+        active: boolean;
+        reset: string;
+        hi: string;
+        lo: string;
+        line: string;
+    };
+};
+import type { Point, Token } from './lexer';
+export type { Point, Token };
+export interface AltSpec {
+    s?: (Tin | Tin[] | null | undefined | string)[] | null | string;
+    p?: string | AltNext | null | false | FuncRef;
+    r?: string | AltNext | null | false | FuncRef;
+    b?: number | AltBack | null | false | FuncRef;
+    c?: AltCond | null;
+    n?: Counters;
+    a?: AltAction | FuncRef | (AltAction | FuncRef)[] | null;
+    h?: AltModifier | null;
+    u?: Record<string, any>;
+    k?: Record<string, any>;
+    g?: string | string[];
+    e?: AltError | FuncRef | null;
+}
+export type AltSpecish = AltSpec | undefined | null | false | 0 | typeof NaN;
+export type ListMods = {
+    append?: boolean;
+    clear?: boolean;
+    move?: number[];
+    delete?: number[];
+    custom?: (alts: AltSpec[]) => null | AltSpec[];
+};
+import type { AltMatch } from './rules';
+export type { AltMatch };
+export type FuncRef = `@${string}`;
+export type FuncRefMap<FT> = Record<FuncRef, FT>;
+export type Counters = {
+    [key: string]: number;
+};
+export type Tin = number & {
+    readonly __brand: 'Tin';
+};
+export declare const asTin: (n: number) => Tin;
+export type TokenMap = {
+    [name: string]: Tin;
+};
+export type TokenSetMap = {
+    [name: string]: Tin[];
+};
+export type TinMap = {
+    [ref: number]: string;
+};
+export type TinSetMap = {
+    [ref: number]: string;
+};
+export type MatchMap = {
+    [name: string]: RegExp | LexMatcher;
+};
+export type Chars = {
+    [char: string]: number;
+};
+export type StrMap = {
+    [name: string]: string;
+};
+export type RuleState = 'o' | 'c';
+export type RuleStep = 'b' | 'a';
+export type LexMatcher = (lex: Lex, rule: Rule, tI?: number) => Token | undefined;
+export type MakeLexMatcher = (cfg: Config, opts: TabnasOptions) => LexMatcher | null | undefined | false;
+export type LexCheck = (lex: Lex) => void | undefined | {
+    done: boolean;
+    token: Token | undefined;
+};
+export type ParsePrepare = (tabnas: Tabnas, ctx: Context, meta?: any) => void;
+export type RuleSpecMap = {
+    [name: string]: RuleSpec;
+};
+export type RuleDefiner = (rs: RuleSpec, p: Parser) => void | RuleSpec;
+export interface NormAltSpec extends AltSpec {
+    s: (Tin | Tin[] | null | undefined)[];
+    p: string | AltNext | null | false;
+    r: string | AltNext | null | false;
+    b: number | AltBack | null | false;
+    S: (number[] | null)[] | null;
+    t: Tin[][];
+    sN: number;
+    c: NormAltCond | null | undefined;
+    g: string[];
+    a: AltAction | null | undefined;
+    e: AltError | null | undefined;
+}
+export type AltCond = ((rule: Rule, ctx: Context, alt: AltMatch) => boolean) | Record<string, any>;
+export type NormAltCond = ((rule: Rule, ctx: Context, alt: AltMatch) => boolean);
+export type AltModifier = (rule: Rule, ctx: Context, alt: AltMatch, next: Rule) => AltMatch;
+export type AltAction = (rule: Rule, ctx: Context, alt: AltMatch) => any;
+export type EagerRegExp = RegExp & {
+    tin$?: number;
+    eager$?: boolean;
+};
+export type AltNext = (rule: Rule, ctx: Context, alt: AltMatch) => string | null | false | 0;
+export type AltBack = (rule: Rule, ctx: Context, alt: AltMatch) => number | null | false;
+export type StateAction = (rule: Rule, ctx: Context, next: Rule, out?: Token | void) => Token | void;
+export type AltError = (rule: Rule, ctx: Context, alt: AltMatch) => Token | undefined;
+export type ValModifier = (val: any, lex: Lex, cfg: Config, opts: TabnasOptions) => string;
+export type LexSub = (tkn: Token, rule: Rule, ctx: Context) => void;
+export type RuleSub = (rule: Rule, ctx: Context) => void;
+import type { Parser } from './parser';
+export type { Parser };
+export type GrammarSpec = {
+    ref?: Record<FuncRef, Function>;
+    v?: number;
+    options?: Record<string, any>;
+    rule?: Record<string, {
+        open?: GrammarAltSpec[] | // OPEN-state alternates (or alts + inject ops).
+        {
+            alts: GrammarAltSpec[];
+            inject: {
+                append?: boolean;
+                delete?: number[];
+                move?: number[];
+            };
+        };
+        close?: GrammarAltSpec[] | // CLOSE-state alternates (or alts + inject ops).
+        {
+            alts: GrammarAltSpec[];
+            inject: {
+                append?: boolean;
+                delete?: number[];
+                move?: number[];
+            };
+        };
+    }>;
+};
+export type GrammarAltSpec = {
+    s?: string | string[];
+    b?: FuncRef | number;
+    p?: FuncRef | string;
+    r?: FuncRef | string;
+    a?: FuncRef | FuncRef[];
+    e?: FuncRef;
+    h?: FuncRef;
+    c?: FuncRef | Record<string, any>;
+    n?: Record<string, number>;
+    u?: Record<string, any>;
+    k?: Record<string, any>;
+    g?: string | string[];
+};

package/dist/types.js

@@ -0,0 +1,24 @@
+"use strict";
+/* Copyright (c) 2013-2026 Richard Rodger, MIT License */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asTin = exports.STRING = exports.SKIP = exports.INSPECT = exports.EMPTY = exports.AFTER = exports.BEFORE = exports.CLOSE = exports.OPEN = void 0;
+/*  types.ts
+ *  Type and constant definitions.
+ */
+exports.OPEN = 'o';
+exports.CLOSE = 'c';
+exports.BEFORE = 'b';
+exports.AFTER = 'a';
+exports.EMPTY = '';
+exports.INSPECT = Symbol.for('nodejs.util.inspect.custom');
+// Sentinel value that acts as `undefined` in deep merge — the base value
+// is preserved.  Represented as "@SKIP" in grammar options.
+exports.SKIP = Symbol.for('tabnas.SKIP');
+// Empty rule used as a no-value placeholder.
+// export const NONE = ({ name: 'none', state: OPEN } as Rule)
+exports.STRING = 'string';
+// Convenience cast for the few code paths that legitimately need to
+// construct a Tin from a raw counter (tokenize, the test scaffold).
+const asTin = (n) => n;
+exports.asTin = asTin;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";AAAA,yDAAyD;;;AAEzD;;GAEG;AAEU,QAAA,IAAI,GAAc,GAAG,CAAA;AACrB,QAAA,KAAK,GAAc,GAAG,CAAA;AACtB,QAAA,MAAM,GAAa,GAAG,CAAA;AACtB,QAAA,KAAK,GAAa,GAAG,CAAA;AACrB,QAAA,KAAK,GAAG,EAAE,CAAA;AACV,QAAA,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAA;AAE/D,yEAAyE;AACzE,4DAA4D;AAC/C,QAAA,IAAI,GAAkB,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;AAE5D,6CAA6C;AAC7C,8DAA8D;AAEjD,QAAA,MAAM,GAAG,QAAQ,CAAA;AAsiB9B,oEAAoE;AACpE,oEAAoE;AAC7D,MAAM,KAAK,GAAG,CAAC,CAAS,EAAO,EAAE,CAAC,CAAQ,CAAA;AAApC,QAAA,KAAK,SAA+B"}

package/dist/utility.d.ts

@@ -0,0 +1,80 @@
+import type { Tabnas, TabnasOptions, Chars, Config, Context, Lex, RuleSpec, Tin, ListMods } from './types';
+declare const keys: (x: any) => string[];
+declare const values: <T>(x: {
+    [key: string]: T;
+} | undefined | null) => T[];
+declare const entries: <T>(x: {
+    [key: string]: T;
+} | undefined | null) => [string, T][];
+declare const assign: (x: any, ...r: any[]) => any;
+declare const isarr: (x: any) => x is any[];
+declare const defprop: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+declare const omap: (o: any, f?: (e: any) => any) => any;
+declare const S: {
+    indent: string;
+    logindent: string;
+    space: string;
+    gap: string;
+    Object: string;
+    Array: string;
+    object: string;
+    string: string;
+    function: string;
+    unexpected: string;
+    map: string;
+    list: string;
+    elem: string;
+    pair: string;
+    val: string;
+    node: string;
+    no_re_flags: string;
+    unprintable: string;
+    invalid_ascii: string;
+    invalid_unicode: string;
+    invalid_lex_state: string;
+    unterminated_string: string;
+    unterminated_comment: string;
+    lex: string;
+    parse: string;
+    error: string;
+    none: string;
+    imp_map: string;
+    imp_list: string;
+    imp_null: string;
+    end: string;
+    open: string;
+    close: string;
+    rule: string;
+    stack: string;
+    nUll: string;
+    name: string;
+    make: string;
+    colon: string;
+    step: string;
+};
+declare function configure(tabnas: Tabnas, incfg: Config | undefined, opts: TabnasOptions): Config;
+declare function tokenize<R extends string | Tin, T extends R extends Tin ? string : Tin>(ref: R, cfg: Config, tabnas?: any): T;
+declare function findTokenSet<R extends string | Tin, T extends R extends Tin ? string : Tin>(ref: R, cfg: Config): T;
+declare function mesc(s: string, _?: any): any;
+declare function regexp(flags: string | null, ...parts: (string | (String & {
+    esc?: boolean;
+}))[]): RegExp;
+declare function escre(s: string | undefined): string;
+declare function deep(base?: any, ...rest: any): any;
+declare function badlex(lex: Lex, BD: Tin, ctx: Context): Lex;
+declare function makelog(ctx: Context, meta: any): ((...rest: any) => void) | undefined;
+declare function srcfmt(config: Config): (s: any) => string;
+declare function str(o: any, len?: number): string;
+declare function snip(s: any, len?: number): string;
+declare function clone(class_instance: any): any;
+declare function charset(...parts: (string | object | boolean | undefined)[]): Chars;
+declare function charsBitmap(...parts: (string | object | boolean | undefined)[]): Uint8Array;
+declare function clean<T>(o: T): T;
+declare function filterRules(rs: RuleSpec, cfg: Config): RuleSpec;
+declare function modlist(list: any[], mods?: ListMods): any[];
+declare function parserwrap(parser: any): {
+    start: (src: string, tabnas: Tabnas, meta?: any, parent_ctx?: any) => any;
+};
+declare function getpath(root: any, path: string | string[]): any;
+declare function resolveFuncRefs(obj: any, ref?: Record<string, Function>): any;
+export { S, assign, badlex, charset, charsBitmap, clean, clone, configure, deep, defprop, entries, escre, filterRules, getpath, isarr, makelog, mesc, regexp, snip, srcfmt, tokenize, parserwrap, str, omap, keys, values, findTokenSet, modlist, resolveFuncRefs, };