tagset-parser 0.0.0

package/lib/esm/generated/TagSetVisitor.js

@@ -0,0 +1,64 @@
+import { AbstractParseTreeVisitor } from "antlr4ng";
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by `TagSetParser`.
+ *
+ * @param <Result> The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ */
+export class TagSetVisitor extends AbstractParseTreeVisitor {
+    /**
+     * Visit a parse tree produced by `TagSetParser.program`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitProgram;
+    /**
+     * Visit a parse tree produced by `TagSetParser.line`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLine;
+    /**
+     * Visit a parse tree produced by `TagSetParser.setDecl`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSetDecl;
+    /**
+     * Visit a parse tree produced by `TagSetParser.labelPart`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLabelPart;
+    /**
+     * Visit a parse tree produced by `TagSetParser.itemDecl`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitItemDecl;
+    /**
+     * Visit a parse tree produced by `TagSetParser.sugarDecl`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSugarDecl;
+    /**
+     * Visit a parse tree produced by `TagSetParser.pattern`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPattern;
+    /**
+     * Visit a parse tree produced by `TagSetParser.valueList`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitValueList;
+    /**
+     * Visit a parse tree produced by `TagSetParser.valueItem`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitValueItem;
+}

package/lib/esm/index.js

@@ -0,0 +1 @@
+export { parse } from './parser.js';

package/lib/esm/parser.js

@@ -0,0 +1,14 @@
+import { CharStream, CommonTokenStream } from 'antlr4ng';
+import { TagSetLexer } from './generated/TagSetLexer.js';
+import { TagSetParser } from './generated/TagSetParser.js';
+import { TagSetASTVisitor } from './visitor.js';
+export function parse(input) {
+    const chars = CharStream.fromString(input);
+    const lexer = new TagSetLexer(chars);
+    const tokens = new CommonTokenStream(lexer);
+    const parser = new TagSetParser(tokens);
+    const tree = parser.program();
+    const visitor = new TagSetASTVisitor();
+    tree.accept(visitor);
+    return visitor.buildAST();
+}

package/lib/esm/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/visitor.js

@@ -0,0 +1,81 @@
+import { TagSetVisitor } from './generated/TagSetVisitor.js';
+import { calcBitmask } from './bitmask.js';
+function extractPatternIds(ctx) {
+    return ctx
+        .WORD()
+        .map((w) => w.getText())
+        .filter((t) => t !== '_');
+}
+function extractValues(ctx) {
+    return ctx.valueItem().map((vi) => {
+        const parts = [
+            ...vi.WORD().map((w) => w.getText()),
+            ...vi.QUOTED_STRING().map((q) => {
+                const text = q.getText();
+                return text.startsWith('"') && text.endsWith('"')
+                    ? text.slice(1, -1)
+                    : text;
+            }),
+        ];
+        return parts.join(' ');
+    });
+}
+function autoDetectSets(explicitSets, rawItems) {
+    const explicitIds = new Set(explicitSets.map((s) => s.id));
+    const discovered = [];
+    for (const item of rawItems) {
+        for (const id of item.patternIds) {
+            if (!explicitIds.has(id) && !discovered.includes(id)) {
+                discovered.push(id);
+            }
+        }
+    }
+    let nextIndex = explicitSets.length;
+    const autoSets = discovered.map((id) => ({
+        id,
+        label: id,
+        index: nextIndex++,
+    }));
+    return [...explicitSets, ...autoSets];
+}
+export class TagSetASTVisitor extends TagSetVisitor {
+    explicitSets = [];
+    rawItems = [];
+    setIndex = 0;
+    visitProgram = (ctx) => {
+        for (const line of ctx.line()) {
+            line.accept(this);
+        }
+    };
+    visitSetDecl = (ctx) => {
+        const id = ctx.WORD().getText();
+        const label = ctx
+            .labelPart()
+            .map((lp) => lp.getText())
+            .join(' ');
+        this.explicitSets.push({ id, label, index: this.setIndex++ });
+    };
+    visitItemDecl = (ctx) => {
+        const patternCtx = ctx.pattern();
+        const patternIds = extractPatternIds(patternCtx);
+        const values = extractValues(ctx.valueList());
+        this.rawItems.push({ patternIds, values });
+    };
+    visitSugarDecl = (ctx) => {
+        const patternIds = ctx
+            .WORD()
+            .map((w) => w.getText())
+            .filter((t) => t !== '_');
+        const values = extractValues(ctx.valueList());
+        this.rawItems.push({ patternIds, values });
+    };
+    buildAST() {
+        const sets = autoDetectSets(this.explicitSets, this.rawItems);
+        const items = this.rawItems.map((raw) => {
+            const pattern = raw.patternIds.join('&');
+            const bitmask = calcBitmask(pattern, sets);
+            return { pattern, bitmask, values: raw.values };
+        });
+        return { sets, items };
+    }
+}

package/lib/types/bitmask.d.ts

@@ -0,0 +1,2 @@
+import type { SetDecl } from './types.js';
+export declare function calcBitmask(pattern: string, sets: SetDecl[]): number;

package/lib/types/generated/TagSetLexer.d.ts

@@ -0,0 +1,31 @@
+import * as antlr from "antlr4ng";
+export declare class TagSetLexer extends antlr.Lexer {
+    static readonly SET = 1;
+    static readonly ITEM = 2;
+    static readonly AMP = 3;
+    static readonly COMMA = 4;
+    static readonly COLON = 5;
+    static readonly QUOTED_STRING = 6;
+    static readonly WORD = 7;
+    static readonly NL = 8;
+    static readonly WS = 9;
+    static readonly channelNames: string[];
+    static readonly literalNames: (string | null)[];
+    static readonly symbolicNames: (string | null)[];
+    static readonly modeNames: string[];
+    static readonly ruleNames: string[];
+    constructor(input: antlr.CharStream);
+    get grammarFileName(): string;
+    get literalNames(): (string | null)[];
+    get symbolicNames(): (string | null)[];
+    get ruleNames(): string[];
+    get serializedATN(): number[];
+    get channelNames(): string[];
+    get modeNames(): string[];
+    static readonly _serializedATN: number[];
+    private static __ATN;
+    static get _ATN(): antlr.ATN;
+    private static readonly vocabulary;
+    get vocabulary(): antlr.Vocabulary;
+    private static readonly decisionsToDFA;
+}

package/lib/types/generated/TagSetListener.d.ts

@@ -0,0 +1,110 @@
+import { ErrorNode, ParseTreeListener, ParserRuleContext, TerminalNode } from "antlr4ng";
+import { ProgramContext } from "./TagSetParser.js";
+import { LineContext } from "./TagSetParser.js";
+import { SetDeclContext } from "./TagSetParser.js";
+import { LabelPartContext } from "./TagSetParser.js";
+import { ItemDeclContext } from "./TagSetParser.js";
+import { SugarDeclContext } from "./TagSetParser.js";
+import { PatternContext } from "./TagSetParser.js";
+import { ValueListContext } from "./TagSetParser.js";
+import { ValueItemContext } from "./TagSetParser.js";
+/**
+ * This interface defines a complete listener for a parse tree produced by
+ * `TagSetParser`.
+ */
+export declare class TagSetListener implements ParseTreeListener {
+    /**
+     * Enter a parse tree produced by `TagSetParser.program`.
+     * @param ctx the parse tree
+     */
+    enterProgram?: (ctx: ProgramContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.program`.
+     * @param ctx the parse tree
+     */
+    exitProgram?: (ctx: ProgramContext) => void;
+    /**
+     * Enter a parse tree produced by `TagSetParser.line`.
+     * @param ctx the parse tree
+     */
+    enterLine?: (ctx: LineContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.line`.
+     * @param ctx the parse tree
+     */
+    exitLine?: (ctx: LineContext) => void;
+    /**
+     * Enter a parse tree produced by `TagSetParser.setDecl`.
+     * @param ctx the parse tree
+     */
+    enterSetDecl?: (ctx: SetDeclContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.setDecl`.
+     * @param ctx the parse tree
+     */
+    exitSetDecl?: (ctx: SetDeclContext) => void;
+    /**
+     * Enter a parse tree produced by `TagSetParser.labelPart`.
+     * @param ctx the parse tree
+     */
+    enterLabelPart?: (ctx: LabelPartContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.labelPart`.
+     * @param ctx the parse tree
+     */
+    exitLabelPart?: (ctx: LabelPartContext) => void;
+    /**
+     * Enter a parse tree produced by `TagSetParser.itemDecl`.
+     * @param ctx the parse tree
+     */
+    enterItemDecl?: (ctx: ItemDeclContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.itemDecl`.
+     * @param ctx the parse tree
+     */
+    exitItemDecl?: (ctx: ItemDeclContext) => void;
+    /**
+     * Enter a parse tree produced by `TagSetParser.sugarDecl`.
+     * @param ctx the parse tree
+     */
+    enterSugarDecl?: (ctx: SugarDeclContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.sugarDecl`.
+     * @param ctx the parse tree
+     */
+    exitSugarDecl?: (ctx: SugarDeclContext) => void;
+    /**
+     * Enter a parse tree produced by `TagSetParser.pattern`.
+     * @param ctx the parse tree
+     */
+    enterPattern?: (ctx: PatternContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.pattern`.
+     * @param ctx the parse tree
+     */
+    exitPattern?: (ctx: PatternContext) => void;
+    /**
+     * Enter a parse tree produced by `TagSetParser.valueList`.
+     * @param ctx the parse tree
+     */
+    enterValueList?: (ctx: ValueListContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.valueList`.
+     * @param ctx the parse tree
+     */
+    exitValueList?: (ctx: ValueListContext) => void;
+    /**
+     * Enter a parse tree produced by `TagSetParser.valueItem`.
+     * @param ctx the parse tree
+     */
+    enterValueItem?: (ctx: ValueItemContext) => void;
+    /**
+     * Exit a parse tree produced by `TagSetParser.valueItem`.
+     * @param ctx the parse tree
+     */
+    exitValueItem?: (ctx: ValueItemContext) => void;
+    visitTerminal(node: TerminalNode): void;
+    visitErrorNode(node: ErrorNode): void;
+    enterEveryRule(node: ParserRuleContext): void;
+    exitEveryRule(node: ParserRuleContext): void;
+}

package/lib/types/generated/TagSetParser.d.ts

@@ -0,0 +1,147 @@
+import * as antlr from "antlr4ng";
+import { TagSetListener } from "./TagSetListener.js";
+import { TagSetVisitor } from "./TagSetVisitor.js";
+export declare class TagSetParser extends antlr.Parser {
+    static readonly SET = 1;
+    static readonly ITEM = 2;
+    static readonly AMP = 3;
+    static readonly COMMA = 4;
+    static readonly COLON = 5;
+    static readonly QUOTED_STRING = 6;
+    static readonly WORD = 7;
+    static readonly NL = 8;
+    static readonly WS = 9;
+    static readonly RULE_program = 0;
+    static readonly RULE_line = 1;
+    static readonly RULE_setDecl = 2;
+    static readonly RULE_labelPart = 3;
+    static readonly RULE_itemDecl = 4;
+    static readonly RULE_sugarDecl = 5;
+    static readonly RULE_pattern = 6;
+    static readonly RULE_valueList = 7;
+    static readonly RULE_valueItem = 8;
+    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): antlr.FailedPredicateException;
+    constructor(input: antlr.TokenStream);
+    program(): ProgramContext;
+    line(): LineContext;
+    setDecl(): SetDeclContext;
+    labelPart(): LabelPartContext;
+    itemDecl(): ItemDeclContext;
+    sugarDecl(): SugarDeclContext;
+    pattern(): PatternContext;
+    valueList(): ValueListContext;
+    valueItem(): ValueItemContext;
+    static readonly _serializedATN: number[];
+    private static __ATN;
+    static get _ATN(): antlr.ATN;
+    private static readonly vocabulary;
+    get vocabulary(): antlr.Vocabulary;
+    private static readonly decisionsToDFA;
+}
+export declare class ProgramContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    EOF(): antlr.TerminalNode;
+    NL(): antlr.TerminalNode[];
+    NL(i: number): antlr.TerminalNode | null;
+    line(): LineContext[];
+    line(i: number): LineContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}
+export declare class LineContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    setDecl(): SetDeclContext | null;
+    itemDecl(): ItemDeclContext | null;
+    sugarDecl(): SugarDeclContext | null;
+    NL(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}
+export declare class SetDeclContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    SET(): antlr.TerminalNode;
+    WORD(): antlr.TerminalNode;
+    labelPart(): LabelPartContext[];
+    labelPart(i: number): LabelPartContext | null;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}
+export declare class LabelPartContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    WORD(): antlr.TerminalNode | null;
+    QUOTED_STRING(): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}
+export declare class ItemDeclContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    ITEM(): antlr.TerminalNode;
+    pattern(): PatternContext;
+    valueList(): ValueListContext;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}
+export declare class SugarDeclContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    WORD(): antlr.TerminalNode[];
+    WORD(i: number): antlr.TerminalNode | null;
+    COLON(): antlr.TerminalNode;
+    valueList(): ValueListContext;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}
+export declare class PatternContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    WORD(): antlr.TerminalNode[];
+    WORD(i: number): antlr.TerminalNode | null;
+    AMP(): antlr.TerminalNode[];
+    AMP(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}
+export declare class ValueListContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    valueItem(): ValueItemContext[];
+    valueItem(i: number): ValueItemContext | null;
+    COMMA(): antlr.TerminalNode[];
+    COMMA(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}
+export declare class ValueItemContext extends antlr.ParserRuleContext {
+    constructor(parent: antlr.ParserRuleContext | null, invokingState: number);
+    WORD(): antlr.TerminalNode[];
+    WORD(i: number): antlr.TerminalNode | null;
+    QUOTED_STRING(): antlr.TerminalNode[];
+    QUOTED_STRING(i: number): antlr.TerminalNode | null;
+    get ruleIndex(): number;
+    enterRule(listener: TagSetListener): void;
+    exitRule(listener: TagSetListener): void;
+    accept<Result>(visitor: TagSetVisitor<Result>): Result | null;
+}

package/lib/types/generated/TagSetVisitor.d.ts

@@ -0,0 +1,73 @@
+import { AbstractParseTreeVisitor } from "antlr4ng";
+import { ProgramContext } from "./TagSetParser.js";
+import { LineContext } from "./TagSetParser.js";
+import { SetDeclContext } from "./TagSetParser.js";
+import { LabelPartContext } from "./TagSetParser.js";
+import { ItemDeclContext } from "./TagSetParser.js";
+import { SugarDeclContext } from "./TagSetParser.js";
+import { PatternContext } from "./TagSetParser.js";
+import { ValueListContext } from "./TagSetParser.js";
+import { ValueItemContext } from "./TagSetParser.js";
+/**
+ * This interface defines a complete generic visitor for a parse tree produced
+ * by `TagSetParser`.
+ *
+ * @param <Result> The return type of the visit operation. Use `void` for
+ * operations with no return type.
+ */
+export declare class TagSetVisitor<Result> extends AbstractParseTreeVisitor<Result> {
+    /**
+     * Visit a parse tree produced by `TagSetParser.program`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitProgram?: (ctx: ProgramContext) => Result;
+    /**
+     * Visit a parse tree produced by `TagSetParser.line`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLine?: (ctx: LineContext) => Result;
+    /**
+     * Visit a parse tree produced by `TagSetParser.setDecl`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSetDecl?: (ctx: SetDeclContext) => Result;
+    /**
+     * Visit a parse tree produced by `TagSetParser.labelPart`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitLabelPart?: (ctx: LabelPartContext) => Result;
+    /**
+     * Visit a parse tree produced by `TagSetParser.itemDecl`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitItemDecl?: (ctx: ItemDeclContext) => Result;
+    /**
+     * Visit a parse tree produced by `TagSetParser.sugarDecl`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitSugarDecl?: (ctx: SugarDeclContext) => Result;
+    /**
+     * Visit a parse tree produced by `TagSetParser.pattern`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitPattern?: (ctx: PatternContext) => Result;
+    /**
+     * Visit a parse tree produced by `TagSetParser.valueList`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitValueList?: (ctx: ValueListContext) => Result;
+    /**
+     * Visit a parse tree produced by `TagSetParser.valueItem`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitValueItem?: (ctx: ValueItemContext) => Result;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export { parse } from './parser.js';
+export type { SetDecl, ItemDecl, TagSetAST } from './types.js';

package/lib/types/parser.d.ts

@@ -0,0 +1,2 @@
+import type { TagSetAST } from './types.js';
+export declare function parse(input: string): TagSetAST;

package/lib/types/types.d.ts

@@ -0,0 +1,14 @@
+export interface SetDecl {
+    id: string;
+    label: string;
+    index: number;
+}
+export interface ItemDecl {
+    pattern: string;
+    bitmask: number;
+    values: string[];
+}
+export interface TagSetAST {
+    sets: SetDecl[];
+    items: ItemDecl[];
+}

package/lib/types/visitor.d.ts

@@ -0,0 +1,13 @@
+import { TagSetVisitor } from './generated/TagSetVisitor.js';
+import type { ProgramContext, SetDeclContext, ItemDeclContext, SugarDeclContext } from './generated/TagSetParser.js';
+import type { TagSetAST } from './types.js';
+export declare class TagSetASTVisitor extends TagSetVisitor<void> {
+    private explicitSets;
+    private rawItems;
+    private setIndex;
+    visitProgram: (ctx: ProgramContext) => void;
+    visitSetDecl: (ctx: SetDeclContext) => void;
+    visitItemDecl: (ctx: ItemDeclContext) => void;
+    visitSugarDecl: (ctx: SugarDeclContext) => void;
+    buildAST(): TagSetAST;
+}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) elzup <guild0105@gmail.com> (elzup.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "tagset-parser",
+  "version": "0.0.0",
+  "description": "TagSet DSL parser",
+  "author": "elzup",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    }
+  },
+  "repository": "elzup/tagset-parser",
+  "bugs": {
+    "url": "https://github.com/elzup/tagset-parser/issues"
+  },
+  "homepage": "https://github.com/elzup/tagset-parser#readme",
+  "keywords": [
+    "tagset",
+    "parser",
+    "dsl"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "lib/"
+  ],
+  "sideEffects": false,
+  "devDependencies": {
+    "@elzup/tsconfig": "1.1.0",
+    "@types/node": "24.10.1",
+    "@vitest/coverage-v8": "^4.0.15",
+    "@vitest/ui": "^4.0.15",
+    "antlr-ng": "^1.0.10",
+    "oxlint": "^1.31.0",
+    "prettier": "^3.8.1",
+    "rimraf": "^6.1.2",
+    "typescript": "5.9.3",
+    "vitest": "^4.0.15"
+  },
+  "dependencies": {
+    "antlr4ng": "^3.0.16"
+  },
+  "scripts": {
+    "generate": "antlr-ng -Dlanguage=TypeScript --generate-visitor -o src/generated src/grammar/TagSet.g4",
+    "clean": "rimraf lib",
+    "build": "npm run clean && npm run build:cjs && npm run build:esm && npm run build:types",
+    "build:cjs": "tsc --module commonjs --outDir lib/cjs && echo '{\"type\": \"commonjs\"}' > lib/cjs/package.json",
+    "build:esm": "tsc --module esnext --outDir lib/esm --moduleResolution node --allowSyntheticDefaultImports",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir lib/types",
+    "format": "prettier --write .",
+    "lint": "oxlint --ignore-pattern src/generated/",
+    "lint:fix": "oxlint --fix --ignore-pattern src/generated/",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:cov": "vitest run --coverage"
+  }
+}