yukigo-prolog-parser 0.1.3 → 0.2.2

package/src/parser/{grammar.ts → grammar.cjs}

@@ -1,106 +1,59 @@
 // Generated automatically by nearley, version 2.20.1
 // http://github.com/Hardmath123/nearley
-// Bypasses TS6133. Allow declared but unused functions.
-// @ts-ignore
-function id(d: any[]): any { return d[0]; }
-declare var period: any;
-declare var testKeyword: any;
-declare var lparen: any;
-declare var rparen: any;
-declare var comma: any;
-declare var colonDash: any;
-declare var queryOp: any;
-declare var semicolon: any;
-declare var forallRule: any;
-declare var findallRule: any;
-declare var consOp: any;
-declare var wildcard: any;
-declare var variable: any;
-declare var atom: any;
-declare var primitiveOperator: any;
-declare var op: any;
-declare var comparisonOp: any;
-declare var number: any;
-declare var string: any;
-declare var WS: any;
- import { 
-    NumberPrimitive, 
-    StringPrimitive, 
-    Rule, 
-    Fact, 
-    Query,
-    ListPrimitive,
-    ConsExpression,
-    ArithmeticBinaryOperation,
-    ArithmeticUnaryOperation,
-    ComparisonOperation,
-    Exist, 
-    Not, 
-    Findall, 
-    Sequence,
-    UnguardedBody,
-    Equation,
-    If,
-    Call,
-    Forall, 
-    SymbolPrimitive, 
-    AssignOperation,
-    UnifyOperation,
-    VariablePattern, 
-    FunctorPattern, 
-    ConsPattern, 
-    ListPattern, 
-    LogicConstraint,
-    LiteralPattern,
-    WildcardPattern,
-    TuplePattern,
-    Test,
-    Assert,
-    Truth
- } from "yukigo-ast"
-
-import { PrologLexer } from "./lexer.js"
-
-const asSequence = (d) => {
-    if (d instanceof Sequence) return d;
-    if (Array.isArray(d)) return d.length === 1 ? d[0] : new Sequence(d);
-    return new Sequence([d]);
-};
-
-
-interface NearleyToken {
-  value: any;
-  [key: string]: any;
-};
-
-interface NearleyLexer {
-  reset: (chunk: string, info: any) => void;
-  next: () => NearleyToken | undefined;
-  save: () => any;
-  formatError: (token: never) => string;
-  has: (tokenType: string) => boolean;
-};
-
-interface NearleyRule {
-  name: string;
-  symbols: NearleySymbol[];
-  postprocess?: (d: any[], loc?: number, reject?: {}) => any;
-};
-
-type NearleySymbol = string | { literal: any } | { test: (token: any) => boolean };
-
-interface Grammar {
-  Lexer: NearleyLexer | undefined;
-  ParserRules: NearleyRule[];
-  ParserStart: string;
-};
-
-const grammar: Grammar = {
-  Lexer: PrologLexer,
-  ParserRules: [
+(function () {
+function id(x) { return x[0]; }
+ 
+const { 
+    NumberPrimitive, 
+    BooleanPrimitive,
+    StringPrimitive, 
+    Rule, 
+    Fact, 
+    Query,
+    ListPrimitive,
+    ConsExpression,
+    ArithmeticBinaryOperation,
+    ArithmeticUnaryOperation,
+    ComparisonOperation,
+    Exist, 
+    Not, 
+    Findall, 
+    Sequence,
+    UnguardedBody,
+    Equation,
+    If,
+    Call,
+    Forall, 
+    SymbolPrimitive, 
+    AssignOperation,
+    UnifyOperation,
+    VariablePattern, 
+    FunctorPattern, 
+    ConsPattern, 
+    ListPattern, 
+    LogicConstraint,
+    LiteralPattern,
+    WildcardPattern,
+    TuplePattern,
+    Test,
+    Assert,
+    Truth 
+} = require("yukigo-ast")
+
+const { PrologLexer } = require("./lexer.js")
+
+const asSequence = (d) => {
+    if (d instanceof Sequence) return d;
+    if (Array.isArray(d)) return d.length === 1 ? d[0] : new Sequence(d);
+    return new Sequence([d]);
+};
+
+var grammar = {
+    Lexer: PrologLexer,
+    ParserRules: [
     {"name": "program$ebnf$1", "symbols": []},
     {"name": "program$ebnf$1$subexpression$1", "symbols": ["clause", "_"]},
-    {"name": "program$ebnf$1", "symbols": ["program$ebnf$1", "program$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "program$ebnf$1", "symbols": ["program$ebnf$1", "program$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "program", "symbols": ["_", "program$ebnf$1"], "postprocess": (d) => d[1].map(x => x[0]).filter(x => x !== null).flat(Infinity)},
     {"name": "clause$subexpression$1", "symbols": ["fact"]},
     {"name": "clause$subexpression$1", "symbols": ["rule"]},
@@ -108,22 +61,24 @@ const grammar: Grammar = {
     {"name": "clause$subexpression$1", "symbols": ["test_rule"]},
     {"name": "clause", "symbols": ["clause$subexpression$1"], "postprocess": (d) => d[0][0]},
     {"name": "fact$ebnf$1", "symbols": ["arguments"], "postprocess": id},
-    {"name": "fact$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "fact$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "fact", "symbols": ["any_atom", "fact$ebnf$1", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Fact(d[0], d[1] ?? [])},
     {"name": "rule", "symbols": ["any_atom", "equation", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Rule(d[0], [d[1]])},
     {"name": "test_rule$ebnf$1", "symbols": ["test_args"], "postprocess": id},
-    {"name": "test_rule$ebnf$1", "symbols": [], "postprocess": () => null},
-    {"name": "test_rule", "symbols": [(PrologLexer.has("testKeyword") ? {type: "testKeyword"} : testKeyword), (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "structural_literal", "test_rule$ebnf$1", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen), "equation", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Test(d[3], d[7].body.sequence, d[4] ? [d[4]] : [])},
+    {"name": "test_rule$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "test_rule$subexpression$1", "symbols": [(PrologLexer.has("colonDash") ? {type: "colonDash"} : colonDash)]},
+    {"name": "test_rule$subexpression$1", "symbols": [(PrologLexer.has("colon") ? {type: "colon"} : colon)]},
+    {"name": "test_rule", "symbols": [(PrologLexer.has("testKeyword") ? {type: "testKeyword"} : testKeyword), (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "structural_literal", "test_rule$ebnf$1", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen), "_", "test_rule$subexpression$1", "_", "body", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Test(d[3], new Sequence(d[10]), d[4] ? [d[4]] : [])},
     {"name": "test_args", "symbols": ["_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "pattern"], "postprocess": (d) => d[3]},
     {"name": "equation$ebnf$1", "symbols": ["arguments"], "postprocess": id},
-    {"name": "equation$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "equation$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "equation", "symbols": ["equation$ebnf$1", "_", (PrologLexer.has("colonDash") ? {type: "colonDash"} : colonDash), "_", "body"], "postprocess": (d) => new Equation(d[0] || [], new UnguardedBody(new Sequence(d[4])))},
     {"name": "query", "symbols": [(PrologLexer.has("queryOp") ? {type: "queryOp"} : queryOp), "_", "body", "_", (PrologLexer.has("period") ? {type: "period"} : period)], "postprocess": (d) => new Query(d[2])},
     {"name": "body$ebnf$1", "symbols": []},
     {"name": "body$ebnf$1$subexpression$1$subexpression$1", "symbols": [(PrologLexer.has("comma") ? {type: "comma"} : comma)]},
     {"name": "body$ebnf$1$subexpression$1$subexpression$1", "symbols": [(PrologLexer.has("semicolon") ? {type: "semicolon"} : semicolon)]},
     {"name": "body$ebnf$1$subexpression$1", "symbols": ["_", "body$ebnf$1$subexpression$1$subexpression$1", "_", "expression"]},
-    {"name": "body$ebnf$1", "symbols": ["body$ebnf$1", "body$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "body$ebnf$1", "symbols": ["body$ebnf$1", "body$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "body", "symbols": ["expression", "body$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])]},
     {"name": "expression$subexpression$1", "symbols": ["conditional"]},
     {"name": "expression$subexpression$1", "symbols": ["forall"]},
@@ -136,38 +91,38 @@ const grammar: Grammar = {
     {"name": "expression$subexpression$1", "symbols": ["assertion"]},
     {"name": "expression", "symbols": ["expression$subexpression$1"], "postprocess": (d) => d[0][0]},
     {"name": "expression", "symbols": [{"literal":"("}, "_", "body", "_", {"literal":")"}], "postprocess": (d) => new Sequence(d[2])},
-    {"name": "conditional", "symbols": [{"literal":"("}, "_", "body", "_", {"literal":"->"}, "_", "body", "_", (PrologLexer.has("semicolon") ? {type: "semicolon"} : semicolon), "_", "body", "_", {"literal":")"}], "postprocess":  (d) => 
-        new If(
-            asSequence(d[2]),  
-            asSequence(d[6]),   
-            asSequence(d[10])
-        )
+    {"name": "conditional", "symbols": [{"literal":"("}, "_", "body", "_", {"literal":"->"}, "_", "body", "_", (PrologLexer.has("semicolon") ? {type: "semicolon"} : semicolon), "_", "body", "_", {"literal":")"}], "postprocess":  (d) => 
+        new If(
+            asSequence(d[2]),  
+            asSequence(d[6]),   
+            asSequence(d[10])
+        )
         },
     {"name": "forall", "symbols": [(PrologLexer.has("forallRule") ? {type: "forallRule"} : forallRule), {"literal":"("}, "_", "expression", "_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "expression", "_", {"literal":")"}], "postprocess": (d) => new Forall(d[3], d[7])},
     {"name": "findall", "symbols": [(PrologLexer.has("findallRule") ? {type: "findallRule"} : findallRule), {"literal":"("}, "_", "pattern", "_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "expression", "_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "pattern", "_", {"literal":")"}], "postprocess": (d) => new Findall(d[3], d[7], d[11])},
     {"name": "not", "symbols": [{"literal":"not"}, {"literal":"("}, "_", "expression", "_", {"literal":")"}], "postprocess": (d) => new Not(asSequence(d[3]))},
     {"name": "not", "symbols": [{"literal":"\\+"}, "_", "expression"], "postprocess": (d) => new Not(d[2])},
-    {"name": "exist", "symbols": [{"literal":"call"}, (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "pattern_list", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess":  (d) => {
-            const [callee, ...rest] = d[3]
-            return new Call(callee.name, rest)
+    {"name": "exist", "symbols": [{"literal":"call"}, (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "pattern_list", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess":  (d) => {
+            const [callee, ...rest] = d[3]
+            return new Call(callee.name, rest)
         } },
     {"name": "exist$ebnf$1", "symbols": ["arguments"], "postprocess": id},
-    {"name": "exist$ebnf$1", "symbols": [], "postprocess": () => null},
-    {"name": "exist", "symbols": ["any_atom", "exist$ebnf$1"], "postprocess":  (d, l, reject) => {
-            const val = d[0].value; 
-            if (["not", "\\+", "call", "assertion"].includes(val)) return reject;
-            return new Exist(d[0], d[1] ?? []) 
+    {"name": "exist$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
+    {"name": "exist", "symbols": ["any_atom", "exist$ebnf$1"], "postprocess":  (d, l, reject) => {
+            const val = d[0].value; 
+            if (["not", "\\+", "call", "assertion"].includes(val)) return reject;
+            return new Exist(d[0], d[1] ?? []) 
         } },
     {"name": "exist", "symbols": ["variable"], "postprocess": (d) => new Exist(d[0], [])},
-    {"name": "assertion", "symbols": [{"literal":"assertion"}, (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "expression", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess":  (d) => 
-        new Assert(null, new Truth(asSequence(d[3]))) 
+    {"name": "assertion", "symbols": [{"literal":"assertion"}, (PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "expression", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess":  (d) => 
+        new Assert(new BooleanPrimitive(false), new Truth(asSequence(d[3]))) 
         },
-    {"name": "assignment", "symbols": ["addition", "_", {"literal":"is"}, "_", "addition"], "postprocess":  (d) => 
-        new LogicConstraint(new AssignOperation("Assign", d[0], d[4])) 
+    {"name": "assignment", "symbols": ["addition", "_", {"literal":"is"}, "_", "addition"], "postprocess":  (d) => 
+        new LogicConstraint(new AssignOperation("Assign", d[0], d[4])) 
             },
     {"name": "unification", "symbols": ["addition", "_", {"literal":"="}, "_", "addition"], "postprocess": (d) => new LogicConstraint(new UnifyOperation("Unify", d[0], d[4]))},
-    {"name": "comparison", "symbols": ["addition", "_", "comparison_op", "_", "addition"], "postprocess":  (d) => 
-        new LogicConstraint(new ComparisonOperation(d[2], d[0], d[4])) 
+    {"name": "comparison", "symbols": ["addition", "_", "comparison_op", "_", "addition"], "postprocess":  (d) => 
+        new LogicConstraint(new ComparisonOperation(d[2], d[0], d[4])) 
             },
     {"name": "addition", "symbols": ["multiplication", "_", {"literal":"+"}, "_", "addition"], "postprocess": (d) => new ArithmeticBinaryOperation("Plus", d[0], d[4])},
     {"name": "addition", "symbols": ["multiplication", "_", {"literal":"-"}, "_", "addition"], "postprocess": (d) => new ArithmeticBinaryOperation("Minus", d[0], d[4])},
@@ -178,26 +133,26 @@ const grammar: Grammar = {
     {"name": "primary", "symbols": ["arithmetic_literal"], "postprocess": id},
     {"name": "primary", "symbols": ["variable"], "postprocess": id},
     {"name": "primary", "symbols": [{"literal":"-"}, "_", "primary"], "postprocess": (d) => new ArithmeticUnaryOperation("Negation", d[2])},
-    {"name": "primary", "symbols": ["strict_atom", "arguments"], "postprocess":  (d, l, reject) => {
-            const val = d[0].value;
-            if (["abs", "round", "sqrt", "max", "assertion"].includes(val)) return reject;
-            return new Exist(d[0], d[1] ?? [])
+    {"name": "primary", "symbols": ["strict_atom", "arguments"], "postprocess":  (d, l, reject) => {
+            const val = d[0].value;
+            if (["abs", "round", "sqrt", "max", "assertion"].includes(val)) return reject;
+            return new Exist(d[0], d[1] ?? [])
         } },
     {"name": "primary", "symbols": ["primitiveOperation"], "postprocess": id},
     {"name": "primary", "symbols": ["cons_expr"], "postprocess": id},
     {"name": "primary", "symbols": ["list_expr"], "postprocess": id},
     {"name": "primary", "symbols": [{"literal":"("}, "_", "addition", "_", {"literal":")"}], "postprocess": d => d[2]},
     {"name": "list_expr$ebnf$1", "symbols": ["primary_list"], "postprocess": id},
-    {"name": "list_expr$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "list_expr$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "list_expr", "symbols": [{"literal":"["}, "_", "list_expr$ebnf$1", "_", {"literal":"]"}], "postprocess": (d) => new ListPrimitive(d[2] || [])},
-    {"name": "cons_expr", "symbols": [{"literal":"["}, "_", "primary_list", "_", (PrologLexer.has("consOp") ? {type: "consOp"} : consOp), "_", "addition", "_", {"literal":"]"}], "postprocess":  (d) => {
-            const heads = d[2];
-            const tail = d[6];
-            let current = tail;
-            for (let i = heads.length - 1; i >= 0; i--) {
-                current = new ConsExpression(heads[i], current);
-            }
-            return current;
+    {"name": "cons_expr", "symbols": [{"literal":"["}, "_", "primary_list", "_", (PrologLexer.has("consOp") ? {type: "consOp"} : consOp), "_", "addition", "_", {"literal":"]"}], "postprocess":  (d) => {
+            const heads = d[2];
+            const tail = d[6];
+            let current = tail;
+            for (let i = heads.length - 1; i >= 0; i--) {
+                current = new ConsExpression(heads[i], current);
+            }
+            return current;
         } },
     {"name": "primitiveOperation", "symbols": [{"literal":"round"}, "__", "addition"], "postprocess": d => new ArithmeticUnaryOperation("Round", d[2])},
     {"name": "primitiveOperation", "symbols": [{"literal":"abs"}, "__", "addition"], "postprocess": d => new ArithmeticUnaryOperation("Absolute", d[2])},
@@ -206,12 +161,12 @@ const grammar: Grammar = {
     {"name": "primitiveArguments", "symbols": [(PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "primary_list", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess": (d) => d[2]},
     {"name": "primary_list$ebnf$1", "symbols": []},
     {"name": "primary_list$ebnf$1$subexpression$1", "symbols": ["_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "addition"]},
-    {"name": "primary_list$ebnf$1", "symbols": ["primary_list$ebnf$1", "primary_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "primary_list$ebnf$1", "symbols": ["primary_list$ebnf$1", "primary_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "primary_list", "symbols": ["addition", "primary_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])]},
     {"name": "arguments", "symbols": [(PrologLexer.has("lparen") ? {type: "lparen"} : lparen), "_", "pattern_list", "_", (PrologLexer.has("rparen") ? {type: "rparen"} : rparen)], "postprocess": (d) => d[2]},
     {"name": "pattern_list$ebnf$1", "symbols": []},
     {"name": "pattern_list$ebnf$1$subexpression$1", "symbols": ["_", (PrologLexer.has("comma") ? {type: "comma"} : comma), "_", "pattern"]},
-    {"name": "pattern_list$ebnf$1", "symbols": ["pattern_list$ebnf$1", "pattern_list$ebnf$1$subexpression$1"], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "pattern_list$ebnf$1", "symbols": ["pattern_list$ebnf$1", "pattern_list$ebnf$1$subexpression$1"], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "pattern_list", "symbols": ["pattern", "pattern_list$ebnf$1"], "postprocess": (d) => [d[0], ...d[1].map(x => x[3])]},
     {"name": "pattern", "symbols": ["infix_pattern"], "postprocess": id},
     {"name": "pattern", "symbols": ["primary_pattern"], "postprocess": id},
@@ -220,17 +175,17 @@ const grammar: Grammar = {
     {"name": "primary_pattern", "symbols": [(PrologLexer.has("wildcard") ? {type: "wildcard"} : wildcard)], "postprocess": (d) => new WildcardPattern()},
     {"name": "primary_pattern", "symbols": ["any_atom", "arguments"], "postprocess": (d) => new FunctorPattern(d[0], d[1])},
     {"name": "primary_pattern", "symbols": [{"literal":"("}, "_", "pattern_list", "_", {"literal":")"}], "postprocess": (d) => new TuplePattern(d[2])},
-    {"name": "primary_pattern", "symbols": [{"literal":"["}, "_", "pattern_list", "_", (PrologLexer.has("consOp") ? {type: "consOp"} : consOp), "_", "pattern", "_", {"literal":"]"}], "postprocess":  (d) => {
-            const heads = d[2];
-            const tail = d[6];
-            let current = tail;
-            for (let i = heads.length - 1; i >= 0; i--) {
-                current = new ConsPattern(heads[i], current);
-            }
-            return current;
+    {"name": "primary_pattern", "symbols": [{"literal":"["}, "_", "pattern_list", "_", (PrologLexer.has("consOp") ? {type: "consOp"} : consOp), "_", "pattern", "_", {"literal":"]"}], "postprocess":  (d) => {
+            const heads = d[2];
+            const tail = d[6];
+            let current = tail;
+            for (let i = heads.length - 1; i >= 0; i--) {
+                current = new ConsPattern(heads[i], current);
+            }
+            return current;
         } },
     {"name": "primary_pattern$ebnf$1", "symbols": ["pattern_list"], "postprocess": id},
-    {"name": "primary_pattern$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "primary_pattern$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "primary_pattern", "symbols": [{"literal":"["}, "_", "primary_pattern$ebnf$1", "_", {"literal":"]"}], "postprocess": (d) => new ListPattern(d[2] ? d[2] : [])},
     {"name": "infix_pattern", "symbols": ["primary_pattern", "_", "any_atom", "_", "pattern"], "postprocess": (d) => new FunctorPattern(d[2], [d[0], d[4]])},
     {"name": "variable", "symbols": [(PrologLexer.has("variable") ? {type: "variable"} : variable)], "postprocess": (d) => new SymbolPrimitive(d[0].value)},
@@ -262,13 +217,17 @@ const grammar: Grammar = {
     {"name": "comparison_op", "symbols": [{"literal":"=@="}], "postprocess": d => "Same"},
     {"name": "comparison_op", "symbols": [{"literal":"\\=@="}], "postprocess": d => "NotSame"},
     {"name": "_$ebnf$1", "symbols": []},
-    {"name": "_$ebnf$1", "symbols": ["_$ebnf$1", (PrologLexer.has("WS") ? {type: "WS"} : WS)], "postprocess": (d) => d[0].concat([d[1]])},
+    {"name": "_$ebnf$1", "symbols": ["_$ebnf$1", (PrologLexer.has("WS") ? {type: "WS"} : WS)], "postprocess": function arrpush(d) {return d[0].concat([d[1]]);}},
     {"name": "_", "symbols": ["_$ebnf$1"]},
     {"name": "__$ebnf$1", "symbols": [(PrologLexer.has("WS") ? {type: "WS"} : WS)], "postprocess": id},
-    {"name": "__$ebnf$1", "symbols": [], "postprocess": () => null},
+    {"name": "__$ebnf$1", "symbols": [], "postprocess": function(d) {return null;}},
     {"name": "__", "symbols": ["__$ebnf$1"]}
-  ],
-  ParserStart: "program",
-};
-
-export default grammar;
+]
+  , ParserStart: "program"
+}
+if (typeof module !== 'undefined'&& typeof module.exports !== 'undefined') {
+   module.exports = grammar;
+} else {
+   window.grammar = grammar;
+}
+})();

package/src/parser/grammar.d.ts

@@ -0,0 +1,3 @@
+import { CompiledRules } from "nearley";
+declare const grammar: CompiledRules;
+export = grammar;