@chr33s/pdf-dfa 5.0.0 → 5.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chr33s/pdf-dfa",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "Deterministic finite automata compiler",
   "type": "module",
   "sideEffects": false,

package/scripts/build-grammar.ts

@@ -1,33 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import peggy from "peggy";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const projectRoot = path.resolve(__dirname, "..");
-const srcDir = path.join(projectRoot, "src");
-const grammarPath = path.join(srcDir, "grammar.peg");
-const outputPath = path.join(srcDir, "grammar.js");
-
-async function buildGrammar(): Promise<void> {
-  const grammar = await readFile(grammarPath, "utf8");
-
-  const parserSource = peggy.generate(grammar, {
-    cache: true,
-    output: "source",
-    format: "es",
-  });
-
-  const banner = [
-    "// @ts-nocheck",
-    "// This file is generated by scripts/build-grammar.ts. Do not edit by hand.\n",
-  ].join("\n");
-  await writeFile(outputPath, `${banner}${parserSource}`);
-  console.log(`Generated ${path.relative(projectRoot, outputPath)}`);
-}
-
-buildGrammar().catch((error) => {
-  console.error("Failed to build grammar:", error);
-  process.exitCode = 1;
-});

package/test/compile.test.ts

@@ -1,131 +0,0 @@
-import { describe, expect, test } from "vitest";
-import compile from "../src/compile.js";
-
-describe("state machine compiler", () => {
-  test("should compile a state machine with a single literal", () => {
-    const stateMachine = compile("a = 0; b = 1; main = a;");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 0]));
-    expect(matches).toEqual([
-      [0, 0, []],
-      [1, 1, []],
-      [3, 3, []],
-    ]);
-  });
-
-  test("should compile a state machine with a concatenation", () => {
-    const stateMachine = compile("a = 0; b = 1; main = a b;");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 1, 0, 1, 0]));
-    expect(matches).toEqual([
-      [1, 2, []],
-      [4, 5, []],
-    ]);
-  });
-
-  test("should compile a state machine with an alternation", () => {
-    const stateMachine = compile("a = 0; b = 1; main = (a b) | (b a);");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 1, 0, 1, 0]));
-    expect(matches).toEqual([
-      [1, 2, []],
-      [3, 4, []],
-      [5, 6, []],
-    ]);
-  });
-
-  test("should compile a state machine with a repeat", () => {
-    const stateMachine = compile("a = 0; b = 1; main = (a b)+;");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 0, 1, 1, 0, 1]));
-    expect(matches).toEqual([
-      [1, 4, []],
-      [6, 7, []],
-    ]);
-  });
-
-  test("should compile a state machine with an optional repeat", () => {
-    const stateMachine = compile("a = 0; b = 1; main = b a (a b)*;");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0]));
-    expect(matches).toEqual([
-      [2, 7, []],
-      [9, 10, []],
-    ]);
-  });
-
-  test("should compile a state machine with an optional group", () => {
-    const stateMachine = compile("a = 0; b = 1; main = b a (a b)?;");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0]));
-    expect(matches).toEqual([
-      [2, 5, []],
-      [9, 10, []],
-    ]);
-  });
-
-  test("should compile a state machine with an exact repetition", () => {
-    const stateMachine = compile("a = 0; b = 1; main = a{3} b;");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1]));
-    expect(matches).toEqual([[3, 6, []]]);
-  });
-
-  test("should compile a state machine with a minimum repetition", () => {
-    const stateMachine = compile("a = 0; b = 1; main = a{3,} b;");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1]));
-    expect(matches).toEqual([
-      [3, 6, []],
-      [7, 11, []],
-    ]);
-  });
-
-  test("should compile a state machine with a maximum repetition", () => {
-    const stateMachine = compile("a = 0; b = 1; main = a{,3} b;");
-    const matches = Array.from(stateMachine.match([0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1]));
-    expect(matches).toEqual([
-      [0, 2, []],
-      [3, 6, []],
-      [10, 11, []],
-      [12, 12, []],
-    ]);
-  });
-
-  test("should compile a state machine with a minimum and maximum repetition", () => {
-    const stateMachine = compile("a = 0; b = 1; main = a{3,5} b;");
-    const matches = Array.from(
-      stateMachine.match([0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]),
-    );
-    expect(matches).toEqual([
-      [3, 6, []],
-      [7, 11, []],
-    ]);
-  });
-
-  test("should compile a state machine with tags", () => {
-    const stateMachine = compile("a = 0; b = 1; main = x:(b a) | y:(a b);");
-    const input = [1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0];
-    const matches = Array.from(stateMachine.match(input));
-    expect(matches).toEqual([
-      [2, 3, ["x"]],
-      [4, 5, ["y"]],
-      [6, 7, ["y"]],
-      [9, 10, ["x"]],
-    ]);
-
-    const applied: Array<[string, number, number, number[]]> = [];
-    stateMachine.apply(input, {
-      x: (start: number, end: number, slice: number[]) => applied.push(["x", start, end, slice]),
-      y: (start: number, end: number, slice: number[]) => applied.push(["y", start, end, slice]),
-    });
-
-    expect(applied).toEqual([
-      ["x", 2, 3, [1, 0]],
-      ["y", 4, 5, [0, 1]],
-      ["y", 6, 7, [0, 1]],
-      ["x", 9, 10, [1, 0]],
-    ]);
-  });
-
-  test("should compile a state machine with external symbols", () => {
-    const stateMachine = compile("main = a b;", { a: 0, b: 1 });
-    const matches = Array.from(stateMachine.match([0, 0, 1, 1, 0, 1, 0]));
-    expect(matches).toEqual([
-      [1, 2, []],
-      [4, 5, []],
-    ]);
-  });
-});

package/test/dfa.test.ts

@@ -1,87 +0,0 @@
-import { describe, expect, test } from "vitest";
-import buildDFA from "../src/dfa.js";
-import { Alternation, Concatenation, Literal, Repeat, Tag } from "../src/nodes.js";
-
-describe("buildDFA", () => {
-  test("should build DFA for single literal", () => {
-    const root = new Literal(0);
-    const states = buildDFA(root, 1);
-
-    // Should have fail state (0), initial state (1), and at least one accepting state
-    expect(states.length).toBeGreaterThanOrEqual(2);
-    expect(states[0].accepting).toBe(false); // Fail state
-  });
-
-  test("should build DFA for concatenation", () => {
-    const root = new Concatenation(new Literal(0), new Literal(1));
-    const states = buildDFA(root, 2);
-
-    expect(states.length).toBeGreaterThanOrEqual(2);
-    // Verify there's at least one accepting state
-    const hasAccepting = states.some((s) => s.accepting);
-    expect(hasAccepting).toBe(true);
-  });
-
-  test("should build DFA for alternation", () => {
-    const root = new Alternation(new Literal(0), new Literal(1));
-    const states = buildDFA(root, 2);
-
-    expect(states.length).toBeGreaterThanOrEqual(2);
-    const hasAccepting = states.some((s) => s.accepting);
-    expect(hasAccepting).toBe(true);
-  });
-
-  test("should build DFA for repeat *", () => {
-    const root = new Repeat(new Literal(0), "*");
-    const states = buildDFA(root, 1);
-
-    expect(states.length).toBeGreaterThanOrEqual(2);
-  });
-
-  test("should build DFA for repeat +", () => {
-    const root = new Repeat(new Literal(0), "+");
-    const states = buildDFA(root, 1);
-
-    expect(states.length).toBeGreaterThanOrEqual(2);
-  });
-
-  test("should build DFA for repeat ?", () => {
-    const root = new Repeat(new Literal(0), "?");
-    const states = buildDFA(root, 1);
-
-    expect(states.length).toBeGreaterThanOrEqual(2);
-  });
-
-  test("should build DFA with tags", () => {
-    const lit = new Literal(0);
-    const tag = new Tag("myTag");
-    const root = new Concatenation(tag, lit);
-    const states = buildDFA(root, 1);
-
-    // Find state with the tag
-    const statesWithTags = states.filter((s) => s.tags.size > 0);
-    expect(statesWithTags.length).toBeGreaterThan(0);
-    expect(statesWithTags.some((s) => s.tags.has("myTag"))).toBe(true);
-  });
-
-  test("should have fail state with no transitions", () => {
-    const root = new Literal(0);
-    const states = buildDFA(root, 1);
-
-    const failState = states[0];
-    expect(failState.accepting).toBe(false);
-    expect(failState.transitions.every((t) => t === 0)).toBe(true);
-  });
-
-  test("should handle complex nested expression", () => {
-    // ((a | b) c)+
-    const inner = new Alternation(new Literal(0), new Literal(1));
-    const concat = new Concatenation(inner, new Literal(2));
-    const root = new Repeat(concat, "+");
-    const states = buildDFA(root, 3);
-
-    expect(states.length).toBeGreaterThanOrEqual(2);
-    const hasAccepting = states.some((s) => s.accepting);
-    expect(hasAccepting).toBe(true);
-  });
-});

package/test/nodes.test.ts

@@ -1,324 +0,0 @@
-import { describe, expect, test } from "vitest";
-import {
-  Alternation,
-  Assignment,
-  buildRepetition,
-  Comment,
-  Concatenation,
-  EndMarker,
-  Literal,
-  Repeat,
-  Tag,
-  Variable,
-} from "../src/nodes.js";
-
-describe("nodes", () => {
-  describe("Variable", () => {
-    test("should store name", () => {
-      const v = new Variable("test");
-      expect(v.name).toBe("test");
-    });
-
-    test("should throw on nullable access", () => {
-      const v = new Variable("test");
-      expect(() => v.nullable).toThrow("Variable nodes must be resolved before evaluation");
-    });
-
-    test("should throw on firstpos access", () => {
-      const v = new Variable("test");
-      expect(() => v.firstpos).toThrow("Variable nodes must be resolved before evaluation");
-    });
-
-    test("should throw on lastpos access", () => {
-      const v = new Variable("test");
-      expect(() => v.lastpos).toThrow("Variable nodes must be resolved before evaluation");
-    });
-
-    test("should copy correctly", () => {
-      const v = new Variable("test");
-      const copy = v.copy();
-      expect(copy.name).toBe("test");
-      expect(copy).not.toBe(v);
-    });
-  });
-
-  describe("Comment", () => {
-    test("should store value", () => {
-      const c = new Comment("this is a comment");
-      expect(c.value).toBe("this is a comment");
-    });
-  });
-
-  describe("Assignment", () => {
-    test("should store variable and expression", () => {
-      const variable = new Variable("x");
-      const expr = new Literal(42);
-      const assign = new Assignment(variable, expr);
-      expect(assign.variable).toBe(variable);
-      expect(assign.expression).toBe(expr);
-    });
-  });
-
-  describe("Alternation", () => {
-    test("should be nullable if either child is nullable", () => {
-      const a = new Literal(1);
-      const b = new Repeat(new Literal(2), "?");
-      const alt = new Alternation(a, b);
-      expect(alt.nullable).toBe(true);
-    });
-
-    test("should not be nullable if both children are not nullable", () => {
-      const a = new Literal(1);
-      const b = new Literal(2);
-      const alt = new Alternation(a, b);
-      expect(alt.nullable).toBe(false);
-    });
-
-    test("should compute firstpos as union of children", () => {
-      const a = new Literal(1);
-      const b = new Literal(2);
-      const alt = new Alternation(a, b);
-      expect(alt.firstpos.size).toBe(2);
-      expect(alt.firstpos.has(a)).toBe(true);
-      expect(alt.firstpos.has(b)).toBe(true);
-    });
-
-    test("should compute lastpos as union of children", () => {
-      const a = new Literal(1);
-      const b = new Literal(2);
-      const alt = new Alternation(a, b);
-      expect(alt.lastpos.size).toBe(2);
-      expect(alt.lastpos.has(a)).toBe(true);
-      expect(alt.lastpos.has(b)).toBe(true);
-    });
-
-    test("should copy correctly", () => {
-      const a = new Literal(1);
-      const b = new Literal(2);
-      const alt = new Alternation(a, b);
-      const copy = alt.copy();
-      expect(copy).not.toBe(alt);
-      expect((copy.a as Literal).value).toBe(1);
-      expect((copy.b as Literal).value).toBe(2);
-    });
-  });
-
-  describe("Concatenation", () => {
-    test("should be nullable only if both children are nullable", () => {
-      const a = new Repeat(new Literal(1), "?");
-      const b = new Repeat(new Literal(2), "?");
-      const concat = new Concatenation(a, b);
-      expect(concat.nullable).toBe(true);
-    });
-
-    test("should not be nullable if one child is not nullable", () => {
-      const a = new Literal(1);
-      const b = new Repeat(new Literal(2), "?");
-      const concat = new Concatenation(a, b);
-      expect(concat.nullable).toBe(false);
-    });
-
-    test("should compute firstpos including second child if first is nullable", () => {
-      const a = new Repeat(new Literal(1), "?");
-      const b = new Literal(2);
-      const concat = new Concatenation(a, b);
-      expect(concat.firstpos.size).toBe(2);
-    });
-
-    test("should compute firstpos only from first child if not nullable", () => {
-      const a = new Literal(1);
-      const b = new Literal(2);
-      const concat = new Concatenation(a, b);
-      expect(concat.firstpos.size).toBe(1);
-      expect(concat.firstpos.has(a)).toBe(true);
-    });
-
-    test("should compute lastpos including first child if second is nullable", () => {
-      const a = new Literal(1);
-      const b = new Repeat(new Literal(2), "?");
-      const concat = new Concatenation(a, b);
-      expect(concat.lastpos.size).toBe(2);
-    });
-
-    test("should copy correctly", () => {
-      const a = new Literal(1);
-      const b = new Literal(2);
-      const concat = new Concatenation(a, b);
-      const copy = concat.copy();
-      expect(copy).not.toBe(concat);
-    });
-
-    test("should calculate followpos correctly", () => {
-      const a = new Literal(1);
-      const b = new Literal(2);
-      const concat = new Concatenation(a, b);
-      concat.calcFollowpos();
-      expect(a.followpos.has(b)).toBe(true);
-    });
-  });
-
-  describe("Repeat", () => {
-    test("should be nullable for * operator", () => {
-      const r = new Repeat(new Literal(1), "*");
-      expect(r.nullable).toBe(true);
-    });
-
-    test("should be nullable for ? operator", () => {
-      const r = new Repeat(new Literal(1), "?");
-      expect(r.nullable).toBe(true);
-    });
-
-    test("should not be nullable for + operator", () => {
-      const r = new Repeat(new Literal(1), "+");
-      expect(r.nullable).toBe(false);
-    });
-
-    test("should compute firstpos from expression", () => {
-      const lit = new Literal(1);
-      const r = new Repeat(lit, "*");
-      expect(r.firstpos.has(lit)).toBe(true);
-    });
-
-    test("should compute lastpos from expression", () => {
-      const lit = new Literal(1);
-      const r = new Repeat(lit, "*");
-      expect(r.lastpos.has(lit)).toBe(true);
-    });
-
-    test("should calculate followpos for * operator", () => {
-      const lit = new Literal(1);
-      const r = new Repeat(lit, "*");
-      r.calcFollowpos();
-      expect(lit.followpos.has(lit)).toBe(true);
-    });
-
-    test("should calculate followpos for + operator", () => {
-      const lit = new Literal(1);
-      const r = new Repeat(lit, "+");
-      r.calcFollowpos();
-      expect(lit.followpos.has(lit)).toBe(true);
-    });
-
-    test("should not calculate followpos for ? operator", () => {
-      const lit = new Literal(1);
-      const r = new Repeat(lit, "?");
-      r.calcFollowpos();
-      expect(lit.followpos.size).toBe(0);
-    });
-
-    test("should copy correctly", () => {
-      const r = new Repeat(new Literal(1), "*");
-      const copy = r.copy();
-      expect(copy).not.toBe(r);
-      expect(copy.op).toBe("*");
-    });
-  });
-
-  describe("Literal", () => {
-    test("should store value", () => {
-      const lit = new Literal(42);
-      expect(lit.value).toBe(42);
-    });
-
-    test("should not be nullable", () => {
-      const lit = new Literal(42);
-      expect(lit.nullable).toBe(false);
-    });
-
-    test("should have itself in firstpos", () => {
-      const lit = new Literal(42);
-      expect(lit.firstpos.has(lit)).toBe(true);
-    });
-
-    test("should have itself in lastpos", () => {
-      const lit = new Literal(42);
-      expect(lit.lastpos.has(lit)).toBe(true);
-    });
-
-    test("should copy to new instance with same value", () => {
-      const lit = new Literal(42);
-      const copy = lit.copy();
-      expect(copy).not.toBe(lit);
-      expect(copy.value).toBe(42);
-    });
-  });
-
-  describe("EndMarker", () => {
-    test("should not be nullable", () => {
-      const em = new EndMarker();
-      expect(em.nullable).toBe(false);
-    });
-
-    test("should have itself in firstpos", () => {
-      const em = new EndMarker();
-      expect(em.firstpos.has(em)).toBe(true);
-    });
-
-    test("should have itself in lastpos", () => {
-      const em = new EndMarker();
-      expect(em.lastpos.has(em)).toBe(true);
-    });
-  });
-
-  describe("Tag", () => {
-    test("should store name", () => {
-      const t = new Tag("myTag");
-      expect(t.name).toBe("myTag");
-    });
-
-    test("should be nullable", () => {
-      const t = new Tag("myTag");
-      expect(t.nullable).toBe(true);
-    });
-
-    test("should have itself in firstpos", () => {
-      const t = new Tag("myTag");
-      expect(t.firstpos.has(t)).toBe(true);
-    });
-
-    test("should have itself in lastpos", () => {
-      const t = new Tag("myTag");
-      expect(t.lastpos.has(t)).toBe(true);
-    });
-
-    test("should copy to new instance with same name", () => {
-      const t = new Tag("myTag");
-      const copy = t.copy();
-      expect(copy).not.toBe(t);
-      expect(copy.name).toBe("myTag");
-    });
-  });
-
-  describe("buildRepetition", () => {
-    test("should throw for negative min", () => {
-      expect(() => buildRepetition(new Literal(1), -1, 5)).toThrow("Invalid repetition range");
-    });
-
-    test("should throw when min > max", () => {
-      expect(() => buildRepetition(new Literal(1), 5, 3)).toThrow("Invalid repetition range");
-    });
-
-    test("should build exact repetition (min = max)", () => {
-      const result = buildRepetition(new Literal(1), 3, 3);
-      // Should be Concatenation(Concatenation(Literal, Literal), Literal)
-      expect(result).toBeInstanceOf(Concatenation);
-    });
-
-    test("should build unbounded repetition (max = Infinity)", () => {
-      const result = buildRepetition(new Literal(1), 2, Infinity);
-      // Should include a Repeat with *
-      expect(result).toBeInstanceOf(Concatenation);
-    });
-
-    test("should build range repetition", () => {
-      const result = buildRepetition(new Literal(1), 1, 3);
-      expect(result).toBeInstanceOf(Concatenation);
-    });
-
-    test("should build optional repetition (min = 0, max = 1)", () => {
-      const result = buildRepetition(new Literal(1), 0, 1);
-      expect(result).toBeInstanceOf(Repeat);
-      expect((result as Repeat).op).toBe("?");
-    });
-  });
-});

package/test/parse-build.test.ts

@@ -1,50 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { build, parse } from "../src/compile.js";
-import StateMachine from "../src/state-machine.js";
-
-describe("parse", () => {
-  test("should parse simple grammar", () => {
-    const table = parse("a = 0; main = a;");
-    expect(table.symbols.a).toBe(0);
-    expect(table.main).toBeDefined();
-  });
-
-  test("should parse grammar with external symbols", () => {
-    const table = parse("main = a;", { a: 42 });
-    expect(table.symbols.a).toBe(42);
-  });
-
-  test("should parse complex grammar", () => {
-    const table = parse("a = 0; b = 1; main = (a b)+ | a*;");
-    expect(table.symbols.a).toBe(0);
-    expect(table.symbols.b).toBe(1);
-    expect(table.main).toBeDefined();
-  });
-
-  test("should parse grammar with tags", () => {
-    const table = parse("a = 0; main = x:(a);");
-    expect(table.main).toBeDefined();
-  });
-});
-
-describe("build", () => {
-  test("should build state machine from symbol table", () => {
-    const table = parse("a = 0; main = a;");
-    const sm = build(table);
-    expect(sm).toBeInstanceOf(StateMachine);
-  });
-
-  test("should build working state machine", () => {
-    const table = parse("a = 0; b = 1; main = a b;");
-    const sm = build(table);
-    const matches = Array.from(sm.match([0, 1]));
-    expect(matches).toEqual([[0, 1, []]]);
-  });
-
-  test("should build state machine with tags", () => {
-    const table = parse("a = 0; main = x:(a);");
-    const sm = build(table);
-    const matches = Array.from(sm.match([0]));
-    expect(matches).toEqual([[0, 0, ["x"]]]);
-  });
-});

package/test/state-machine.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, test } from "vitest";
-import StateMachine, { FAIL_STATE, INITIAL_STATE } from "../src/state-machine.js";
-
-describe("StateMachine", () => {
-  describe("constants", () => {
-    test("INITIAL_STATE is 1", () => {
-      expect(INITIAL_STATE).toBe(1);
-    });
-
-    test("FAIL_STATE is 0", () => {
-      expect(FAIL_STATE).toBe(0);
-    });
-  });
-
-  describe("match", () => {
-    test("should return empty matches for empty input", () => {
-      const sm = new StateMachine({
-        stateTable: [[], [0]],
-        accepting: [false, true],
-        tags: [[], []],
-      });
-      const matches = Array.from(sm.match([]));
-      expect(matches).toEqual([]);
-    });
-
-    test("should handle no accepting states", () => {
-      const sm = new StateMachine({
-        stateTable: [[1], [1]],
-        accepting: [false, false],
-        tags: [[], []],
-      });
-      const matches = Array.from(sm.match([0, 0, 0]));
-      expect(matches).toEqual([]);
-    });
-
-    test("should handle single accepting state at start", () => {
-      const sm = new StateMachine({
-        stateTable: [[], [2], [0]],
-        accepting: [false, false, true],
-        tags: [[], [], []],
-      });
-      const matches = Array.from(sm.match([0]));
-      expect(matches).toEqual([[0, 0, []]]);
-    });
-
-    test("should handle multiple consecutive matches", () => {
-      const sm = new StateMachine({
-        stateTable: [[], [2], [0]],
-        accepting: [false, false, true],
-        tags: [[], [], []],
-      });
-      const matches = Array.from(sm.match([0, 0, 0]));
-      expect(matches).toEqual([
-        [0, 0, []],
-        [1, 1, []],
-        [2, 2, []],
-      ]);
-    });
-
-    test("should return tags for accepting states", () => {
-      const sm = new StateMachine({
-        stateTable: [[], [2], [0]],
-        accepting: [false, false, true],
-        tags: [[], [], ["myTag"]],
-      });
-      const matches = Array.from(sm.match([0]));
-      expect(matches).toEqual([[0, 0, ["myTag"]]]);
-    });
-
-    test("should handle undefined state transitions gracefully", () => {
-      const sm = new StateMachine({
-        stateTable: [[], [2], []],
-        accepting: [false, false, true],
-        tags: [[], [], []],
-      });
-      // Symbol 1 has no transition from state 1
-      const matches = Array.from(sm.match([0, 1]));
-      expect(matches).toEqual([[0, 0, []]]);
-    });
-  });
-
-  describe("apply", () => {
-    test("should call action handlers for each tag", () => {
-      const sm = new StateMachine({
-        stateTable: [[], [2], [0]],
-        accepting: [false, false, true],
-        tags: [[], [], ["action1"]],
-      });
-
-      const calls: Array<[string, number, number, number[]]> = [];
-      sm.apply([0, 0], {
-        action1: (start, end, slice) => calls.push(["action1", start, end, slice]),
-      });
-
-      expect(calls).toEqual([
-        ["action1", 0, 0, [0]],
-        ["action1", 1, 1, [0]],
-      ]);
-    });
-
-    test("should not call missing action handlers", () => {
-      const sm = new StateMachine({
-        stateTable: [[], [2], [0]],
-        accepting: [false, false, true],
-        tags: [[], [], ["missingAction"]],
-      });
-
-      const calls: string[] = [];
-      sm.apply([0], {
-        otherAction: () => calls.push("called"),
-      });
-
-      expect(calls).toEqual([]);
-    });
-
-    test("should handle multiple tags on same match", () => {
-      const sm = new StateMachine({
-        stateTable: [[], [2], [0]],
-        accepting: [false, false, true],
-        tags: [[], [], ["tag1", "tag2"]],
-      });
-
-      const calls: string[] = [];
-      sm.apply([0], {
-        tag1: () => calls.push("tag1"),
-        tag2: () => calls.push("tag2"),
-      });
-
-      expect(calls).toEqual(["tag1", "tag2"]);
-    });
-  });
-});

package/test/symbol-table.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { Assignment, Literal, Variable } from "../src/nodes.js";
-import SymbolTable from "../src/symbol-table.js";
-
-describe("SymbolTable", () => {
-  test("should process assignments and store variables", () => {
-    const statements = [
-      new Assignment(new Variable("a"), new Literal(0)),
-      new Assignment(new Variable("main"), new Variable("a")),
-    ];
-
-    const table = new SymbolTable(statements);
-    expect(table.variables.a).toBeInstanceOf(Literal);
-    expect((table.variables.a as Literal).value).toBe(0);
-  });
-
-  test("should throw when main is not declared", () => {
-    const statements = [new Assignment(new Variable("a"), new Literal(0))];
-
-    expect(() => new SymbolTable(statements)).toThrow("No main variable declaration found");
-  });
-
-  test("should throw for undeclared identifiers", () => {
-    const statements = [new Assignment(new Variable("main"), new Variable("undeclared"))];
-
-    expect(() => new SymbolTable(statements)).toThrow("Undeclared identifier undeclared");
-  });
-
-  test("should resolve variable references", () => {
-    const statements = [
-      new Assignment(new Variable("a"), new Literal(0)),
-      new Assignment(new Variable("b"), new Variable("a")),
-      new Assignment(new Variable("main"), new Variable("b")),
-    ];
-
-    const table = new SymbolTable(statements);
-    expect(table.main).toBeInstanceOf(Literal);
-    expect((table.main as Literal).value).toBe(0);
-  });
-
-  test("should add external symbols", () => {
-    const statements = [new Assignment(new Variable("main"), new Variable("external"))];
-
-    const table = new SymbolTable(statements, { external: 42 });
-    expect(table.symbols.external).toBe(42);
-    expect(table.main).toBeInstanceOf(Literal);
-    expect((table.main as Literal).value).toBe(42);
-  });
-
-  test("should track symbol count", () => {
-    const statements = [
-      new Assignment(new Variable("a"), new Literal(0)),
-      new Assignment(new Variable("b"), new Literal(1)),
-      new Assignment(new Variable("main"), new Variable("a")),
-    ];
-
-    const table = new SymbolTable(statements);
-    // Size counts all literal assignments: a=0, b=1, and the resolved main=a (which is 0)
-    expect(table.size).toBe(3);
-  });
-
-  test("should include external symbols in size count", () => {
-    const statements = [new Assignment(new Variable("main"), new Variable("ext"))];
-
-    const table = new SymbolTable(statements, { ext: 0 });
-    // Size counts: external symbol ext=0, and the resolved main (which is also a literal)
-    expect(table.size).toBe(2);
-  });
-});

package/test/utils.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { addAll, equal, union } from "../src/utils.js";
-
-describe("utils", () => {
-  describe("union", () => {
-    test("should return union of two sets", () => {
-      const a = new Set([1, 2, 3]);
-      const b = new Set([3, 4, 5]);
-      const result = union(a, b);
-      expect(result).toEqual(new Set([1, 2, 3, 4, 5]));
-    });
-
-    test("should not modify original sets", () => {
-      const a = new Set([1, 2]);
-      const b = new Set([3, 4]);
-      union(a, b);
-      expect(a).toEqual(new Set([1, 2]));
-      expect(b).toEqual(new Set([3, 4]));
-    });
-
-    test("should handle empty sets", () => {
-      const a = new Set<number>();
-      const b = new Set([1, 2]);
-      expect(union(a, b)).toEqual(new Set([1, 2]));
-      expect(union(b, a)).toEqual(new Set([1, 2]));
-    });
-
-    test("should handle both empty sets", () => {
-      const a = new Set<number>();
-      const b = new Set<number>();
-      expect(union(a, b)).toEqual(new Set());
-    });
-
-    test("should work with iterable as second argument", () => {
-      const a = new Set([1, 2]);
-      const b = [3, 4];
-      const result = union(a, b);
-      expect(result).toEqual(new Set([1, 2, 3, 4]));
-    });
-  });
-
-  describe("addAll", () => {
-    test("should add all items from source to target", () => {
-      const target = new Set([1, 2]);
-      const source = new Set([3, 4]);
-      addAll(target, source);
-      expect(target).toEqual(new Set([1, 2, 3, 4]));
-    });
-
-    test("should handle duplicates", () => {
-      const target = new Set([1, 2, 3]);
-      const source = new Set([2, 3, 4]);
-      addAll(target, source);
-      expect(target).toEqual(new Set([1, 2, 3, 4]));
-    });
-
-    test("should handle empty source", () => {
-      const target = new Set([1, 2]);
-      const source = new Set<number>();
-      addAll(target, source);
-      expect(target).toEqual(new Set([1, 2]));
-    });
-
-    test("should work with array as source", () => {
-      const target = new Set([1, 2]);
-      const source = [3, 4, 5];
-      addAll(target, source);
-      expect(target).toEqual(new Set([1, 2, 3, 4, 5]));
-    });
-  });
-
-  describe("equal", () => {
-    test("should return true for identical sets", () => {
-      const a = new Set([1, 2, 3]);
-      expect(equal(a, a)).toBe(true);
-    });
-
-    test("should return true for equal sets with same elements", () => {
-      const a = new Set([1, 2, 3]);
-      const b = new Set([1, 2, 3]);
-      expect(equal(a, b)).toBe(true);
-    });
-
-    test("should return true for equal sets with different insertion order", () => {
-      const a = new Set([1, 2, 3]);
-      const b = new Set([3, 2, 1]);
-      expect(equal(a, b)).toBe(true);
-    });
-
-    test("should return false for sets with different sizes", () => {
-      const a = new Set([1, 2, 3]);
-      const b = new Set([1, 2]);
-      expect(equal(a, b)).toBe(false);
-    });
-
-    test("should return false for sets with different elements", () => {
-      const a = new Set([1, 2, 3]);
-      const b = new Set([1, 2, 4]);
-      expect(equal(a, b)).toBe(false);
-    });
-
-    test("should return true for empty sets", () => {
-      const a = new Set<number>();
-      const b = new Set<number>();
-      expect(equal(a, b)).toBe(true);
-    });
-  });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "allowJs": true,
-    "rootDir": "src",
-    "outDir": "dist",
-    "types": ["node"]
-  },
-  "include": [
-    "dfa.d.ts",
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "dist"
-  ]
-}

package/tsconfig.test.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "types": ["node"],
-    "noEmit": true
-  },
-  "include": ["**/*.ts"]
-}

package/tsconfig.typecheck.json

@@ -1,16 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "rootDir": "."
-  },
-  "include": [
-    "**/*.ts",
-  ],
-  "exclude": [
-    "dist",
-    "node_modules",
-    "src/grammar.js",
-    "vendor"
-  ]
-}

package/vitest.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from "vitest/config";
-
-export default defineConfig({
-  test: {
-    environment: "node",
-    include: ["test/**/*.test.ts"],
-  },
-});