@chr33s/pdf-dfa 5.0.0

package/README.md

@@ -0,0 +1,91 @@
+# @chr33s/pdf-dfa
+
+> Deterministic finite automata compiler packaged as modern ES modules.
+
+Distributed as native ES modules with NodeNext resolution (use Node.js 18+ or a modern bundler).
+
+`@chr33s/pdf-dfa` lives in the [`chr33s/pdf`](https://github.com/chr33s/pdf) monorepo and provides native ES modules with TypeScript declarations.
+
+## Overview
+
+Compiles a regular expression like syntax to fast deterministic finite automata.
+Useful for pattern matching against non-string sequences.
+
+## Example
+
+This example matches [Hangul](https://en.wikipedia.org/wiki/Hangul) syllables. The symbols defined in the machine are Unicode character categories which could be mapped from code points.
+
+Machine definition:
+
+```coffeescript
+# define symbols
+X   = 0; # Other character
+L   = 1; # Leading consonant
+V   = 2; # Medial vowel
+T   = 3; # Trailing consonant
+LV  = 4; # Composed <LV> syllable
+LVT = 5; # Composed <LVT> syllable
+M   = 6; # Tone mark
+
+# define variables
+decomposed = L V T?;
+partial = LV T?;
+composed = LVT;
+
+# define main state machine pattern
+main = (decomposed | partial | composed) M?;
+```
+
+Visualized, the machine looks like this (double circles are accepting states):
+
+![dfa](https://cloud.githubusercontent.com/assets/19409/19143719/8fbc6a12-8b5a-11e6-868d-99621644d094.png)
+
+Compiling and using the machine:
+
+```javascript
+import { compile } from "@chr33s/pdf-dfa";
+import fs from "node:fs";
+
+let stateMachine = compile(fs.readFileSync('hangul.machine', 'utf8'));
+
+// find matches
+for (let [startIndex, endIndex] of stateMachine.match([0, 1, 2, 3, 0, 4, 6]) {
+  console.log('match:', startIndex, endIndex);
+}
+```
+
+Output:
+```
+match: 1 3
+match: 5 6
+```
+
+## Syntax
+
+A state machine file contains a list of assignment statements. Comments are also allowed
+and are started with the `#` character. Each statement is an assignment of a variable name
+to a value or expression. Assigning a variable to a number produces a symbol, which is
+added to the state machine's alphabet. Assigning a variable to an expression allows
+for substitutions into later expressions. The special `main` variable should always be
+assigned to at the end of the file, and is the final expression that will be compiled.
+
+A subset of common regular expression syntax is supported. A list of operators and their
+precedence is below. Operators with the same precedence are evaluated left to right.
+
+| Precedence | Syntax     | Type          | Meaning                                    |
+| ---------- | ---------- | --------------| ------------------------------------------ |
+| 1          | `a \| b`   | Alternation   | Matches either `a` or `b`                  |
+| 2          | `a b`      | Concatenation | Matches `a` followed by `b`                |
+| 3          | `a*`       | Repetition    | Matches zero or more occurrences of `a`    |
+| 3          | `a+`       | Repetition    | Matches one ore more occurrences of `a`    |
+| 3          | `a?`       | Optional      | Matches zero or one occurrence of `a`      |
+| 3          | `a{n}`     | Repetition    | Matches exactly n occurrences of `a`       |
+| 3          | `a{n,}`    | Repetition    | Matches n or more occurrences of `a`       |
+| 3          | `a{,n}`    | Repetition    | Matches up to n occurrences of `a`         |
+| 3          | `a{n,m}`   | Repetition    | Matches n to m occurrences of `a`          |
+| 4          | `t:<expr>` | Tag           | Tags the following expression with tag `t` |
+| 5          | `(<expr>)` | Grouping      | Groups an expression                       |
+
+## License
+
+MIT

package/dfa.d.ts

@@ -0,0 +1,44 @@
+declare module "peggy" {
+  export type OutputFormat = "parser" | "source";
+  export type ModuleFormat = "es" | "commonjs" | "umd";
+
+  export interface GenerateOptions {
+    allowedStartRules?: string[];
+    cache?: boolean;
+    format?: ModuleFormat;
+    output?: OutputFormat;
+  }
+
+  export interface PeggyParser {
+    parse<T = unknown>(input: string, options?: unknown): T;
+  }
+
+  export interface PeggyApi {
+    generate(grammar: string, options?: GenerateOptions): string | PeggyParser;
+  }
+
+  const peggy: PeggyApi;
+  export default peggy;
+}
+
+declare module "graphviz" {
+  export interface GraphAttributeMap {
+    [key: string]: string | number | undefined;
+  }
+
+  export interface Edge {
+    set(attribute: string, value: string): Edge;
+  }
+
+  export interface Node {
+    set(attribute: string, value: string): void;
+  }
+
+  export interface Graph {
+    set(attribute: string, value: string): void;
+    addNode(id: string, attributes?: GraphAttributeMap): Node;
+    addEdge(from: Node, to: Node, attributes?: GraphAttributeMap): Edge;
+  }
+
+  export function digraph(id: string): Graph;
+}

package/dist/compile.d.ts

@@ -0,0 +1,6 @@
+import StateMachine from "./state-machine.js";
+import SymbolTable from "./symbol-table.js";
+export type ExternalSymbols = Record<string, number>;
+export declare function parse(source: string, externalSymbols?: ExternalSymbols): SymbolTable;
+export declare function build(symbolTable: SymbolTable): StateMachine;
+export default function compile(source: string, externalSymbols?: ExternalSymbols): StateMachine;

package/dist/compile.js

@@ -0,0 +1,22 @@
+import buildDFA from "./dfa.js";
+import { parse as parseGrammar } from "./grammar.js";
+import * as nodes from "./nodes.js";
+import StateMachine from "./state-machine.js";
+import SymbolTable from "./symbol-table.js";
+export function parse(source, externalSymbols = {}) {
+    const ast = parseGrammar(source, { nodes });
+    return new SymbolTable(ast, externalSymbols);
+}
+export function build(symbolTable) {
+    const states = buildDFA(symbolTable.main, symbolTable.size);
+    const config = {
+        stateTable: states.map((state) => Array.from(state.transitions)),
+        accepting: states.map((state) => state.accepting),
+        tags: states.map((state) => Array.from(state.tags)),
+    };
+    return new StateMachine(config);
+}
+export default function compile(source, externalSymbols = {}) {
+    return build(parse(source, externalSymbols));
+}
+//# sourceMappingURL=compile.js.map

package/dist/compile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.js","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA,OAAO,QAAsB,MAAM,UAAU,CAAC;AAC9C,OAAO,EAAE,KAAK,IAAI,YAAY,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AACpC,OAAO,YAAoC,MAAM,oBAAoB,CAAC;AACtE,OAAO,WAAW,MAAM,mBAAmB,CAAC;AAI5C,MAAM,UAAU,KAAK,CAAC,MAAc,EAAE,kBAAmC,EAAE;IACzE,MAAM,GAAG,GAAG,YAAY,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5C,OAAO,IAAI,WAAW,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,WAAwB;IAC5C,MAAM,MAAM,GAAe,QAAQ,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;IAExE,MAAM,MAAM,GAAuB;QACjC,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QAChE,SAAS,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC;QACjD,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;KACpD,CAAC;IAEF,OAAO,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,CAAC,OAAO,UAAU,OAAO,CAC7B,MAAc,EACd,kBAAmC,EAAE;IAErC,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC;AAC/C,CAAC"}

package/dist/dfa.d.ts

@@ -0,0 +1,16 @@
+import { ExpressionNode, PositionNode } from "./nodes.js";
+export interface DFAState {
+    positions: Set<PositionNode>;
+    transitions: Uint16Array;
+    accepting: boolean;
+    marked: boolean;
+    tags: Set<string>;
+}
+/**
+ * This is an implementation of the direct regular expression to DFA algorithm described
+ * in section 3.9.5 of "Compilers: Principles, Techniques, and Tools" by Aho,
+ * Lam, Sethi, and Ullman. http://dragonbook.stanford.edu
+ * There is a PDF of the book here:
+ * http://www.informatik.uni-bremen.de/agbkb/lehre/ccfl/Material/ALSUdragonbook.pdf
+ */
+export default function buildDFA(root: ExpressionNode, numSymbols: number): DFAState[];

package/dist/dfa.js

@@ -0,0 +1,81 @@
+import { Concatenation, EndMarker, Literal, Tag } from "./nodes.js";
+import { addAll, equal } from "./utils.js";
+const END_MARKER = new EndMarker();
+/**
+ * This is an implementation of the direct regular expression to DFA algorithm described
+ * in section 3.9.5 of "Compilers: Principles, Techniques, and Tools" by Aho,
+ * Lam, Sethi, and Ullman. http://dragonbook.stanford.edu
+ * There is a PDF of the book here:
+ * http://www.informatik.uni-bremen.de/agbkb/lehre/ccfl/Material/ALSUdragonbook.pdf
+ */
+export default function buildDFA(root, numSymbols) {
+    const augmentedRoot = new Concatenation(root, END_MARKER);
+    augmentedRoot.calcFollowpos();
+    const failState = new State(new Set(), numSymbols);
+    const initialState = new State(augmentedRoot.firstpos, numSymbols);
+    const dstates = [failState, initialState];
+    // while there is an unmarked state S in dstates
+    while (true) {
+        let s = null;
+        for (let j = 1; j < dstates.length; j++) {
+            if (!dstates[j].marked) {
+                s = dstates[j];
+                break;
+            }
+        }
+        if (s == null) {
+            break;
+        }
+        // mark S
+        s.marked = true;
+        // for each input symbol a
+        for (let a = 0; a < numSymbols; a++) {
+            // let U be the union of followpos(p) for all
+            //  p in S that correspond to a
+            const u = new Set();
+            for (const p of s.positions) {
+                if (p instanceof Literal && p.value === a) {
+                    addAll(u, p.followpos);
+                }
+            }
+            if (u.size === 0) {
+                continue;
+            }
+            // if U is not in dstates
+            let ux = -1;
+            for (let i = 0; i < dstates.length; i++) {
+                if (equal(u, dstates[i].positions)) {
+                    ux = i;
+                    break;
+                }
+            }
+            if (ux === -1) {
+                // Add U as an unmarked state to dstates
+                dstates.push(new State(u, numSymbols));
+                ux = dstates.length - 1;
+            }
+            s.transitions[a] = ux;
+        }
+    }
+    return dstates;
+}
+class State {
+    positions;
+    transitions;
+    accepting;
+    marked;
+    tags;
+    constructor(positions, len) {
+        this.positions = positions;
+        this.transitions = new Uint16Array(len);
+        this.accepting = positions.has(END_MARKER);
+        this.marked = false;
+        this.tags = new Set();
+        for (const pos of positions) {
+            if (pos instanceof Tag) {
+                this.tags.add(pos.name);
+            }
+        }
+    }
+}
+//# sourceMappingURL=dfa.js.map

package/dist/dfa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dfa.js","sourceRoot":"","sources":["../src/dfa.ts"],"names":[],"mappings":"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"}

package/dist/grammar.d.ts

@@ -0,0 +1,11 @@
+declare const peg$allowedStartRules: string[];
+declare class peg$SyntaxError extends SyntaxError {
+    static buildMessage(expected: any, found: any): string;
+    constructor(message: any, expected: any, found: any, location: any);
+    expected: any;
+    found: any;
+    location: any;
+    format(sources: any): string;
+}
+declare function peg$parse(input: any, options: any): any;
+export { peg$allowedStartRules as StartRules, peg$SyntaxError as SyntaxError, peg$parse as parse };