@chr33s/pdf-dfa 5.0.0

package/src/grammar.peg

@@ -0,0 +1,72 @@
+{
+  const n = options?.nodes;
+  if (!n) {
+    throw new Error('The parser expects a nodes module via options.nodes.');
+  }
+}
+
+rules
+  = statement+
+
+statement
+  = s:statement_type _ { return s }
+
+statement_type
+  = assignment
+  / comment
+
+comment
+  = '#' v:[^\r\n]* [\r\n] { return new n.Comment(v.join('')) }
+
+assignment
+  = v:variable _ '=' _ e:expr _ ';' { return new n.Assignment(v, e) }
+
+variable
+  = v:name  { return new n.Variable(v) }
+
+expr
+  = alternation
+
+alternation
+  = a:concatenation _ '|' _ b:alternation     { return new n.Alternation(a, b) }
+  / concatenation
+
+concatenation
+  = a:repeat _ b:concatenation           { return new n.Concatenation(a, b) }
+  / repeat
+
+repeat
+  = t:name ':' e:repeat { return new n.Concatenation(e, new n.Tag(t)) }
+  / t:term '*'  { return new n.Repeat(t, '*') }
+  / t:term '?'  { return new n.Repeat(t, '?') }
+  / t:term '+'  { return new n.Repeat(t, '+') }
+  / t:term '{' m:number '}' { return n.buildRepetition(t, m, m) }
+  / t:term '{' min:number ',' '}' { return n.buildRepetition(t, min, Infinity) }
+  / t:term '{' ',' max:number '}' { return n.buildRepetition(t, 0, max) }
+  / t:term '{' min:number ',' max:number '}' { return n.buildRepetition(t, min, max) }
+  / term
+
+term
+  = variable
+  / x:number { return new n.Literal(x) }
+  / '(' e:expr ')' { return e }
+
+repetition
+  = '{' number '}' { return n.buildRepetition() }
+
+name
+  = a:name_start_char b:name_char* { return a + b.join('') }
+
+name_start_char
+  = "_"
+  / [a-zA-Z]
+
+name_char
+  = name_start_char
+  / [0-9]
+
+number
+  = num:[0-9]+  { return parseInt(num.join('')) }
+
+_
+  = [ \t\r\n]*

package/src/index.ts

@@ -0,0 +1,9 @@
+export { build, default as compile, parse, type ExternalSymbols } from "./compile.js";
+export * from "./nodes.js";
+export {
+  FAIL_STATE,
+  INITIAL_STATE,
+  default as StateMachine,
+  type Match,
+  type StateMachineConfig,
+} from "./state-machine.js";

package/src/nodes.ts

@@ -0,0 +1,308 @@
+import { addAll, union } from "./utils.js";
+
+export type RepeatOperator = "*" | "?" | "+";
+
+export type PositionNode = Literal | Tag | EndMarker;
+
+export type ExpressionNode =
+  | Alternation
+  | Concatenation
+  | Repeat
+  | Literal
+  | Tag
+  | EndMarker
+  | Variable;
+
+/**
+ * Base AST node
+ */
+export class Node {
+  readonly followpos: Set<PositionNode>;
+
+  constructor() {
+    const followpos = new Set<PositionNode>();
+    this.followpos = followpos;
+    Object.defineProperty(this, "followpos", {
+      value: followpos,
+    });
+  }
+
+  calcFollowpos(): void {
+    for (const key of Object.keys(this)) {
+      const value = (this as Record<string, unknown>)[key];
+      if (value instanceof Node) {
+        value.calcFollowpos();
+      }
+    }
+  }
+}
+
+/**
+ * Represents a variable reference
+ */
+export class Variable extends Node {
+  readonly name: string;
+
+  constructor(name: string) {
+    super();
+    this.name = name;
+  }
+
+  get nullable(): boolean {
+    throw new Error("Variable nodes must be resolved before evaluation");
+  }
+
+  get firstpos(): Set<PositionNode> {
+    throw new Error("Variable nodes must be resolved before evaluation");
+  }
+
+  get lastpos(): Set<PositionNode> {
+    throw new Error("Variable nodes must be resolved before evaluation");
+  }
+
+  copy(): Variable {
+    return new Variable(this.name);
+  }
+}
+
+/**
+ * Represents a comment
+ */
+export class Comment extends Node {
+  readonly value: string;
+
+  constructor(value: string) {
+    super();
+    this.value = value;
+  }
+}
+
+/**
+ * Represents an assignment statement.
+ * e.g. `variable = expression;`
+ */
+export class Assignment extends Node {
+  readonly variable: Variable;
+  expression: ExpressionNode;
+
+  constructor(variable: Variable, expression: ExpressionNode) {
+    super();
+    this.variable = variable;
+    this.expression = expression;
+  }
+}
+
+/**
+ * Represents an alternation.
+ * e.g. `a | b`
+ */
+export class Alternation extends Node {
+  readonly a: ExpressionNode;
+  readonly b: ExpressionNode;
+
+  constructor(a: ExpressionNode, b: ExpressionNode) {
+    super();
+    this.a = a;
+    this.b = b;
+  }
+
+  get nullable(): boolean {
+    return this.a.nullable || this.b.nullable;
+  }
+
+  get firstpos(): Set<PositionNode> {
+    return union(this.a.firstpos, this.b.firstpos);
+  }
+
+  get lastpos(): Set<PositionNode> {
+    return union(this.a.lastpos, this.b.lastpos);
+  }
+
+  copy(): Alternation {
+    return new Alternation(this.a.copy(), this.b.copy());
+  }
+}
+
+/**
+ * Represents a concatenation, or chain.
+ * e.g. `a b c`
+ */
+export class Concatenation extends Node {
+  readonly a: ExpressionNode;
+  readonly b: ExpressionNode;
+
+  constructor(a: ExpressionNode, b: ExpressionNode) {
+    super();
+    this.a = a;
+    this.b = b;
+  }
+
+  get nullable(): boolean {
+    return this.a.nullable && this.b.nullable;
+  }
+
+  get firstpos(): Set<PositionNode> {
+    let s = this.a.firstpos;
+    if (this.a.nullable) {
+      s = union(s, this.b.firstpos);
+    }
+
+    return s;
+  }
+
+  get lastpos(): Set<PositionNode> {
+    let s = this.b.lastpos;
+    if (this.b.nullable) {
+      s = union(s, this.a.lastpos);
+    }
+
+    return s;
+  }
+
+  calcFollowpos(): void {
+    super.calcFollowpos();
+    for (const n of this.a.lastpos) {
+      addAll(n.followpos, this.b.firstpos);
+    }
+  }
+
+  copy(): Concatenation {
+    return new Concatenation(this.a.copy(), this.b.copy());
+  }
+}
+
+/**
+ * Represents a repetition.
+ * e.g. `a+`, `b*`, or `c?`
+ */
+export class Repeat extends Node {
+  readonly expression: ExpressionNode;
+  readonly op: RepeatOperator;
+
+  constructor(expression: ExpressionNode, op: RepeatOperator) {
+    super();
+    this.expression = expression;
+    this.op = op;
+  }
+
+  get nullable(): boolean {
+    return this.op === "*" || this.op === "?";
+  }
+
+  get firstpos(): Set<PositionNode> {
+    return this.expression.firstpos;
+  }
+
+  get lastpos(): Set<PositionNode> {
+    return this.expression.lastpos;
+  }
+
+  calcFollowpos(): void {
+    super.calcFollowpos();
+    if (this.op === "*" || this.op === "+") {
+      for (const n of this.lastpos) {
+        addAll(n.followpos, this.firstpos);
+      }
+    }
+  }
+
+  copy(): Repeat {
+    return new Repeat(this.expression.copy(), this.op);
+  }
+}
+
+export function buildRepetition(
+  expression: ExpressionNode,
+  min = 0,
+  max = Infinity,
+): ExpressionNode {
+  if (min < 0 || min > max) {
+    throw new Error(`Invalid repetition range: ${min} ${max}`);
+  }
+
+  let res: ExpressionNode | null = null;
+  for (let i = 0; i < min; i++) {
+    res = concat(res, expression.copy());
+  }
+
+  if (max === Infinity) {
+    res = concat(res, new Repeat(expression.copy(), "*"));
+  } else {
+    for (let i = min; i < max; i++) {
+      res = concat(res, new Repeat(expression.copy(), "?"));
+    }
+  }
+
+  return res ?? expression.copy();
+}
+
+function concat(a: ExpressionNode | null, b: ExpressionNode): ExpressionNode {
+  if (!a) {
+    return b;
+  }
+
+  return new Concatenation(a, b);
+}
+
+/**
+ * Base class for leaf nodes
+ */
+class Leaf extends Node {
+  copy(): this {
+    return this;
+  }
+
+  get nullable(): boolean {
+    return false;
+  }
+
+  get firstpos(): Set<PositionNode> {
+    return new Set([this as PositionNode]);
+  }
+
+  get lastpos(): Set<PositionNode> {
+    return new Set([this as PositionNode]);
+  }
+}
+
+/**
+ * Represents a literal value, e.g. a number
+ */
+export class Literal extends Leaf {
+  readonly value: number;
+
+  constructor(value: number) {
+    super();
+    this.value = value;
+  }
+
+  copy(): this {
+    return new Literal(this.value) as this;
+  }
+}
+
+/**
+ * Marks the end of an expression
+ */
+export class EndMarker extends Leaf {}
+
+/**
+ * Represents a tag
+ * e.g. `a:(a b)`
+ */
+export class Tag extends Leaf {
+  readonly name: string;
+
+  constructor(name: string) {
+    super();
+    this.name = name;
+  }
+
+  get nullable(): boolean {
+    return true;
+  }
+
+  copy(): this {
+    return new Tag(this.name) as this;
+  }
+}

package/src/state-machine.ts

@@ -0,0 +1,94 @@
+export const INITIAL_STATE = 1;
+export const FAIL_STATE = 0;
+
+export type Match = [start: number, end: number, tags: string[]];
+
+export interface StateMachineConfig {
+  stateTable: number[][];
+  accepting: boolean[];
+  tags: string[][];
+}
+
+/**
+ * A StateMachine represents a deterministic finite automaton.
+ * It can perform matches over a sequence of values, similar to a regular expression.
+ */
+export default class StateMachine {
+  readonly stateTable: number[][];
+  readonly accepting: boolean[];
+  readonly tags: string[][];
+
+  constructor(dfa: StateMachineConfig) {
+    this.stateTable = dfa.stateTable;
+    this.accepting = dfa.accepting;
+    this.tags = dfa.tags;
+  }
+
+  /**
+   * Returns an iterable object that yields pattern matches over the input sequence.
+   * Matches are of the form [startIndex, endIndex, tags].
+   */
+  match(input: readonly number[]): Iterable<Match> {
+    const { stateTable, accepting, tags } = this;
+
+    return {
+      *[Symbol.iterator](): Iterator<Match> {
+        let state = INITIAL_STATE;
+        let startRun: number | null = null;
+        let lastAccepting: number | null = null;
+        let lastState = INITIAL_STATE;
+
+        for (let index = 0; index < input.length; index++) {
+          const symbol = input[index];
+
+          lastState = state;
+          state = stateTable[state]?.[symbol] ?? FAIL_STATE;
+
+          if (state === FAIL_STATE) {
+            if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
+              yield [startRun, lastAccepting, tags[lastState] ?? []];
+            }
+
+            state = stateTable[INITIAL_STATE]?.[symbol] ?? FAIL_STATE;
+            startRun = null;
+          }
+
+          if (state !== FAIL_STATE && startRun == null) {
+            startRun = index;
+          }
+
+          if (accepting[state]) {
+            lastAccepting = index;
+          }
+
+          if (state === FAIL_STATE) {
+            state = INITIAL_STATE;
+          }
+        }
+
+        if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
+          yield [startRun, lastAccepting, tags[state] ?? []];
+        }
+      },
+    };
+  }
+
+  /**
+   * For each match over the input sequence, action functions matching
+   * the tag definitions in the input pattern are called with the startIndex,
+   * endIndex, and sub-match sequence.
+   */
+  apply(
+    input: readonly number[],
+    actions: Record<string, (start: number, end: number, slice: number[]) => void>,
+  ): void {
+    for (const [start, end, tagList] of this.match(input)) {
+      for (const tag of tagList) {
+        const handler = actions[tag];
+        if (typeof handler === "function") {
+          handler(start, end, input.slice(start, end + 1));
+        }
+      }
+    }
+  }
+}

package/src/symbol-table.ts

@@ -0,0 +1,78 @@
+import { Assignment, ExpressionNode, Literal, Node, Variable } from "./nodes.js";
+
+type SymbolTableStatement = Node;
+type ExternalSymbolMap = Record<string, number>;
+
+/**
+ * Processes a list of statements into a symbol table
+ */
+export default class SymbolTable {
+  readonly variables: Record<string, ExpressionNode>;
+  readonly symbols: Record<string, number>;
+  main: ExpressionNode;
+  size: number;
+
+  constructor(statements: SymbolTableStatement[], externalSymbols: ExternalSymbolMap = {}) {
+    this.variables = {};
+    this.symbols = {};
+    this.main = undefined as unknown as ExpressionNode;
+    this.size = 0;
+
+    this.addExternalSymbols(externalSymbols);
+    this.process(statements);
+  }
+
+  private addExternalSymbols(externalSymbols: ExternalSymbolMap): void {
+    for (const [key, value] of Object.entries(externalSymbols)) {
+      const literal = new Literal(value);
+      this.variables[key] = literal;
+      this.symbols[key] = value;
+      this.size++;
+    }
+  }
+
+  private process(statements: SymbolTableStatement[]): void {
+    for (const statement of statements) {
+      if (statement instanceof Assignment) {
+        const resolved = this.processExpression(statement.expression);
+        this.variables[statement.variable.name] = resolved;
+        statement.expression = resolved;
+
+        if (resolved instanceof Literal) {
+          this.symbols[statement.variable.name] = resolved.value;
+          this.size++;
+        }
+      }
+    }
+
+    const main = this.variables.main;
+    if (!main) {
+      throw new Error("No main variable declaration found");
+    }
+
+    this.main = main;
+  }
+
+  private processExpression(expr: ExpressionNode): ExpressionNode {
+    // Process children
+    for (const key of Object.keys(expr)) {
+      const recordExpr = expr as unknown as Record<string, unknown>;
+      const value = recordExpr[key];
+      if (value instanceof Node) {
+        recordExpr[key] = this.processExpression(value as ExpressionNode);
+      }
+    }
+
+    // Replace variable references with their values
+    if (expr instanceof Variable) {
+      const value = this.variables[expr.name];
+      if (value == null) {
+        throw new Error(`Undeclared identifier ${expr.name}`);
+      }
+
+      return this.processExpression(value.copy());
+    }
+
+    return expr;
+  }
+}

package/src/utils.ts

@@ -0,0 +1,38 @@
+/**
+ * Returns a new set representing the union of a and b.
+ */
+export function union<T>(a: Set<T>, b: Iterable<T>): Set<T> {
+  const result = new Set(a);
+  addAll(result, b);
+  return result;
+}
+
+/**
+ * Adds all items from the set b to a.
+ */
+export function addAll<T>(target: Set<T>, source: Iterable<T>): void {
+  for (const item of source) {
+    target.add(item);
+  }
+}
+
+/**
+ * Returns whether two sets are equal
+ */
+export function equal<T>(a: Set<T>, b: Set<T>): boolean {
+  if (a === b) {
+    return true;
+  }
+
+  if (a.size !== b.size) {
+    return false;
+  }
+
+  for (const item of a) {
+    if (!b.has(item)) {
+      return false;
+    }
+  }
+
+  return true;
+}