agency-lang 0.0.21 → 0.0.23

package/dist/lib/parser.test.js

@@ -35,7 +35,7 @@ describe("agencyNode", () => {
             },
         },
         {
-            input: "// this is a comment\n",
+            input: "// this is a comment",
             expected: {
                 success: true,
                 nodeCount: 1,
@@ -46,7 +46,7 @@ describe("agencyNode", () => {
             input: "bar :: number\nx = 5",
             expected: {
                 success: true,
-                nodeCount: 2,
+                nodeCount: 3,
                 firstNodeType: "typeHint",
             },
         },
@@ -54,7 +54,7 @@ describe("agencyNode", () => {
             input: "foo :: string\nfoo = `hello`",
             expected: {
                 success: true,
-                nodeCount: 2,
+                nodeCount: 3,
                 firstNodeType: "typeHint",
             },
         },
@@ -62,7 +62,7 @@ describe("agencyNode", () => {
             input: "def test() { foo = 1 }\ntest()",
             expected: {
                 success: true,
-                nodeCount: 2,
+                nodeCount: 3,
                 firstNodeType: "function",
             },
         },
@@ -108,14 +108,14 @@ describe("agencyParser", () => {
             input: "bar :: number\nbar = 5",
             expected: {
                 success: true,
-                nodeCount: 2,
+                nodeCount: 3,
             },
         },
         {
             input: "x = 5\ny = 10\nz = 15",
             expected: {
                 success: true,
-                nodeCount: 3,
+                nodeCount: 5,
             },
         },
         {
@@ -129,14 +129,14 @@ describe("agencyParser", () => {
             input: "def add() { x = 5\ny = 10 }\nadd()",
             expected: {
                 success: true,
-                nodeCount: 2,
+                nodeCount: 3,
             },
         },
         {
             input: "result :: number\nresult = `the number 42`",
             expected: {
                 success: true,
-                nodeCount: 2,
+                nodeCount: 3,
             },
         },
         {
@@ -181,7 +181,7 @@ describe("parseAgency", () => {
             expected: {
                 success: true,
                 programType: "agencyProgram",
-                nodeCount: 2,
+                nodeCount: 3,
             },
         },
         {
@@ -205,7 +205,7 @@ describe("parseAgency", () => {
             expected: {
                 success: true,
                 programType: "agencyProgram",
-                nodeCount: 3,
+                nodeCount: 5,
             },
         },
         {
@@ -243,46 +243,23 @@ describe("parseAgency", () => {
             });
         }
     });
-    it("should handle complex multi-statement programs", () => {
-        const input = `count :: number
-count = \`the number 5\`
-items :: string[]
-items = \`list of fruits\`
-def process() {
-  result = count
-  result
-}
-process()`;
-        const result = parseAgency(input);
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.result.type).toBe("agencyProgram");
-            expect(result.result.nodes.length).toBe(6);
-            expect(result.result.nodes[0].type).toBe("typeHint");
-            expect(result.result.nodes[1].type).toBe("assignment");
-            expect(result.result.nodes[2].type).toBe("typeHint");
-            expect(result.result.nodes[3].type).toBe("assignment");
-            expect(result.result.nodes[4].type).toBe("function");
-            expect(result.result.nodes[5].type).toBe("functionCall");
-        }
-    });
     it("should parse real-world example from tests/assignment.agency pattern", () => {
         const input = `bar :: number
-test :: string
 bar = \`the number 1\``;
         const result = parseAgency(input);
         expect(result.success).toBe(true);
         if (result.success) {
-            expect(result.result.nodes.length).toBe(3);
             expect(result.result.nodes[0]).toMatchObject({
                 type: "typeHint",
                 variableName: "bar",
                 variableType: { type: "primitiveType", value: "number" },
             });
             expect(result.result.nodes[1]).toMatchObject({
-                type: "typeHint",
-                variableName: "test",
-                variableType: { type: "primitiveType", value: "string" },
+                type: "newLine",
+            });
+            expect(result.result.nodes[2]).toMatchObject({
+                type: "assignment",
+                variableName: "bar",
             });
         }
     });

package/dist/lib/parsers/access.test.js

@@ -68,7 +68,10 @@ describe("access expression parsers", () => {
                     result: {
                         type: "indexAccess",
                         array: { type: "variableName", value: "obj" },
-                        index: { type: "string", value: "key" },
+                        index: {
+                            type: "string",
+                            segments: [{ type: "text", value: "key" }],
+                        },
                     },
                 },
             },
@@ -79,7 +82,10 @@ describe("access expression parsers", () => {
                     result: {
                         type: "indexAccess",
                         array: { type: "variableName", value: "data" },
-                        index: { type: "string", value: "field" },
+                        index: {
+                            type: "string",
+                            segments: [{ type: "text", value: "field" }],
+                        },
                     },
                 },
             },
@@ -155,7 +161,12 @@ describe("access expression parsers", () => {
                         array: {
                             type: "functionCall",
                             functionName: "getUsers",
-                            arguments: [{ type: "string", value: "active" }],
+                            arguments: [
+                                {
+                                    type: "string",
+                                    segments: [{ type: "text", value: "active" }],
+                                },
+                            ],
                         },
                         index: { type: "number", value: "0" },
                     },

package/dist/lib/parsers/assignment.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { assignmentParser } from "./assignment.js";
+import { assignmentParser } from "./function.js";
 describe("assignmentParser", () => {
     const testCases = [
         // Happy path - simple literal assignments
@@ -21,7 +21,10 @@ describe("assignmentParser", () => {
                 result: {
                     type: "assignment",
                     variableName: "name",
-                    value: { type: "string", value: "Alice" },
+                    value: {
+                        type: "string",
+                        segments: [{ type: "text", value: "Alice" }],
+                    },
                 },
             },
         },
@@ -136,7 +139,10 @@ describe("assignmentParser", () => {
                         functionName: "calculate",
                         arguments: [
                             { type: "number", value: "1" },
-                            { type: "string", value: "test" },
+                            {
+                                type: "string",
+                                segments: [{ type: "text", value: "test" }],
+                            },
                         ],
                     },
                 },
@@ -188,7 +194,10 @@ describe("assignmentParser", () => {
                         entries: [
                             {
                                 key: "key",
-                                value: { type: "string", value: "value" },
+                                value: {
+                                    type: "string",
+                                    segments: [{ type: "text", value: "value" }],
+                                },
                             },
                         ],
                     },
@@ -252,6 +261,152 @@ describe("assignmentParser", () => {
                 },
             },
         },
+        // Typed assignments - primitive types
+        {
+            input: "foo: number = 1",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "foo",
+                    typeHint: { type: "primitiveType", value: "number" },
+                    value: { type: "number", value: "1" },
+                },
+            },
+        },
+        {
+            input: "bar: number = `the number 1`",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "bar",
+                    typeHint: { type: "primitiveType", value: "number" },
+                    value: {
+                        type: "prompt",
+                        segments: [{ type: "text", value: "the number 1" }],
+                    },
+                },
+            },
+        },
+        {
+            input: 'name: string = "Alice"',
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "name",
+                    typeHint: { type: "primitiveType", value: "string" },
+                    value: {
+                        type: "string",
+                        segments: [{ type: "text", value: "Alice" }],
+                    },
+                },
+            },
+        },
+        {
+            input: "isActive: boolean = true",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "isActive",
+                    typeHint: { type: "primitiveType", value: "boolean" },
+                    value: { type: "variableName", value: "true" },
+                },
+            },
+        },
+        // Typed assignments - array types
+        {
+            input: "items: number[] = [1, 2, 3]",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "items",
+                    typeHint: {
+                        type: "arrayType",
+                        elementType: { type: "primitiveType", value: "number" },
+                    },
+                    value: {
+                        type: "agencyArray",
+                        items: [
+                            { type: "number", value: "1" },
+                            { type: "number", value: "2" },
+                            { type: "number", value: "3" },
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            input: 'names: string[] = ["Alice", "Bob"]',
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "names",
+                    typeHint: {
+                        type: "arrayType",
+                        elementType: { type: "primitiveType", value: "string" },
+                    },
+                    value: {
+                        type: "agencyArray",
+                        items: [
+                            {
+                                type: "string",
+                                segments: [{ type: "text", value: "Alice" }],
+                            },
+                            {
+                                type: "string",
+                                segments: [{ type: "text", value: "Bob" }],
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+        // Typed assignments - with whitespace variations
+        {
+            input: "x:number=5",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "x",
+                    typeHint: { type: "primitiveType", value: "number" },
+                    value: { type: "number", value: "5" },
+                },
+            },
+        },
+        {
+            input: "  y  :  string  =  `hello`  ",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "y",
+                    typeHint: { type: "primitiveType", value: "string" },
+                    value: {
+                        type: "prompt",
+                        segments: [{ type: "text", value: "hello" }],
+                    },
+                },
+            },
+        },
+        // Typed assignments - with semicolons
+        {
+            input: "count: number = 42;",
+            expected: {
+                success: true,
+                result: {
+                    type: "assignment",
+                    variableName: "count",
+                    typeHint: { type: "primitiveType", value: "number" },
+                    value: { type: "number", value: "42" },
+                },
+            },
+        },
         // Failure cases
         { input: "=5", expected: { success: false } },
         { input: "x =", expected: { success: false } },

package/dist/lib/parsers/await.d.ts

@@ -0,0 +1,3 @@
+import { AwaitStatement } from "../types/await.js";
+import { ParserResult } from "tarsec";
+export declare const awaitParser: (input: string) => ParserResult<AwaitStatement>;

package/dist/lib/parsers/await.js

@@ -0,0 +1,18 @@
+/* import { UsesTool } from "../types/tools.js";
+import { capture, char, many1WithJoin, Parser, seqC, set } from "tarsec";
+import { varNameChar } from "./utils.js";
+
+export const usesToolParser: Parser<UsesTool> = seqC(
+  set("type", "usesTool"),
+  char("+"),
+  capture(many1WithJoin(varNameChar), "toolName")
+);
+ */
+import { capture, or, seqC, set, spaces, str } from "tarsec";
+import { accessExpressionParser } from "./access.js";
+import { functionCallParser } from "./functionCall.js";
+import { literalParser } from "./literals.js";
+export const awaitParser = (input) => {
+    const parser = seqC(set("type", "awaitStatement"), str("await"), spaces, capture(or(accessExpressionParser, functionCallParser, literalParser), "expression"));
+    return parser(input);
+};

package/dist/lib/parsers/body.test.js

@@ -23,7 +23,10 @@ describe("functionBodyParser", () => {
                     {
                         type: "assignment",
                         variableName: "bar",
-                        value: { type: "string", value: "hello" },
+                        value: {
+                            type: "string",
+                            segments: [{ type: "text", value: "hello" }],
+                        },
                     },
                 ],
             },
@@ -41,6 +44,9 @@ describe("functionBodyParser", () => {
                             segments: [{ type: "text", value: "hello" }],
                         },
                     },
+                    {
+                        type: "newLine",
+                    },
                     {
                         type: "variableName",
                         value: "foo",
@@ -58,6 +64,9 @@ describe("functionBodyParser", () => {
                         variableName: "x",
                         value: { type: "number", value: "5" },
                     },
+                    {
+                        type: "newLine",
+                    },
                     {
                         type: "assignment",
                         variableName: "y",

package/dist/lib/parsers/dataStructures.js

@@ -2,7 +2,7 @@ import { capture, char, manyWithJoin, noneOf, optional, or, sepBy, seqC, set, su
 import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { functionCallParser } from "./functionCall.js";
 import { literalParser } from "./literals.js";
-import { comma, optionalSpaces } from "./utils.js";
+import { comma, optionalSpaces, optionalSpacesOrNewline } from "./utils.js";
 export const agencyArrayParser = (input) => {
     const parser = trace("agencyArrayParser", seqC(set("type", "agencyArray"), char("["), capture(sepBy(comma, or(indexAccessParser, accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser)), "items"), char("]")));
     return parser(input);
@@ -11,4 +11,4 @@ export const agencyObjectKVParser = (input) => {
     const parser = trace("agencyObjectKVParser", seqC(optionalSpaces, optional(char('"')), capture(manyWithJoin(noneOf('":\n\t ')), "key"), optional(char('"')), optionalSpaces, char(":"), optionalSpaces, capture(or(indexAccessParser, accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value")));
     return parser(input);
 };
-export const agencyObjectParser = seqC(set("type", "agencyObject"), char("{"), optionalSpaces, capture(or(sepBy(comma, agencyObjectKVParser), succeed([])), "entries"), optional(char(",")), optionalSpaces, char("}"));
+export const agencyObjectParser = seqC(set("type", "agencyObject"), char("{"), optionalSpacesOrNewline, capture(or(sepBy(comma, agencyObjectKVParser), succeed([])), "entries"), optional(char(",")), optionalSpacesOrNewline, char("}"));

package/dist/lib/parsers/dataStructures.test.js

@@ -46,8 +46,8 @@ describe("dataStructures parsers", () => {
                     result: {
                         type: "agencyArray",
                         items: [
-                            { type: "string", value: "hello" },
-                            { type: "string", value: "world" },
+                            { type: "string", segments: [{ type: "text", value: "hello" }] },
+                            { type: "string", segments: [{ type: "text", value: "world" }] },
                         ],
                     },
                 },
@@ -76,7 +76,7 @@ describe("dataStructures parsers", () => {
                         type: "agencyArray",
                         items: [
                             { type: "number", value: "1" },
-                            { type: "string", value: "hello" },
+                            { type: "string", segments: [{ type: "text", value: "hello" }] },
                             { type: "variableName", value: "foo" },
                         ],
                     },
@@ -212,7 +212,7 @@ describe("dataStructures parsers", () => {
                     success: true,
                     result: {
                         key: "name",
-                        value: { type: "string", value: "Alice" },
+                        value: { type: "string", segments: [{ type: "text", value: "Alice" }] },
                     },
                 },
             },
@@ -233,7 +233,7 @@ describe("dataStructures parsers", () => {
                     success: true,
                     result: {
                         key: "name",
-                        value: { type: "string", value: "Alice" },
+                        value: { type: "string", segments: [{ type: "text", value: "Alice" }] },
                     },
                 },
             },
@@ -377,7 +377,7 @@ describe("dataStructures parsers", () => {
                         entries: [
                             {
                                 key: "name",
-                                value: { type: "string", value: "Alice" },
+                                value: { type: "string", segments: [{ type: "text", value: "Alice" }] },
                             },
                         ],
                     },
@@ -412,7 +412,7 @@ describe("dataStructures parsers", () => {
                         entries: [
                             {
                                 key: "name",
-                                value: { type: "string", value: "Alice" },
+                                value: { type: "string", segments: [{ type: "text", value: "Alice" }] },
                             },
                             {
                                 key: "age",
@@ -420,7 +420,7 @@ describe("dataStructures parsers", () => {
                             },
                             {
                                 key: "city",
-                                value: { type: "string", value: "NYC" },
+                                value: { type: "string", segments: [{ type: "text", value: "NYC" }] },
                             },
                         ],
                     },
@@ -608,7 +608,7 @@ describe("dataStructures parsers", () => {
                         entries: [
                             {
                                 key: "name",
-                                value: { type: "string", value: "Alice" },
+                                value: { type: "string", segments: [{ type: "text", value: "Alice" }] },
                             },
                             {
                                 key: "age",
@@ -623,8 +623,8 @@ describe("dataStructures parsers", () => {
                                 value: {
                                     type: "agencyArray",
                                     items: [
-                                        { type: "string", value: "a" },
-                                        { type: "string", value: "b" },
+                                        { type: "string", segments: [{ type: "text", value: "a" }] },
+                                        { type: "string", segments: [{ type: "text", value: "b" }] },
                                     ],
                                 },
                             },

package/dist/lib/parsers/function.d.ts

@@ -1,9 +1,14 @@
-import { AgencyNode, DocString, FunctionDefinition, FunctionParameter, VariableType } from "../types.js";
-import { Parser } from "tarsec";
+import { TimeBlock } from "../types/timeBlock.js";
+import { Parser, ParserResult } from "tarsec";
+import { AgencyNode, Assignment, DocString, FunctionDefinition, FunctionParameter, VariableType } from "../types.js";
 import { GraphNodeDefinition } from "../types/graphNode.js";
 import { WhileLoop } from "../types/whileLoop.js";
+import { IfElse } from "../types/ifElse.js";
+export declare const assignmentParser: Parser<Assignment>;
 export declare const docStringParser: Parser<DocString>;
-export declare const bodyParser: Parser<AgencyNode[]>;
+export declare const bodyParser: (input: string) => ParserResult<AgencyNode[]>;
+export declare const timeBlockParser: Parser<TimeBlock>;
+export declare const ifParser: Parser<IfElse>;
 export declare const whileLoopParser: Parser<WhileLoop>;
 export declare const functionParameterParserWithTypeHint: Parser<FunctionParameter>;
 export declare const functionParameterParser: Parser<FunctionParameter>;

package/dist/lib/parsers/function.js

@@ -1,26 +1,78 @@
-import { capture, captureCaptures, char, debug, many1, many1Till, many1WithJoin, map, optional, or, sepBy, seqC, set, space, spaces, str, succeed, trace, } from "tarsec";
+import { capture, captureCaptures, char, debug, many, many1, many1Till, many1WithJoin, map, optional, or, sepBy, seqC, set, space, spaces, str, succeed, trace, } from "tarsec";
 import { accessExpressionParser, indexAccessParser } from "./access.js";
-import { assignmentParser } from "./assignment.js";
 import { commentParser } from "./comment.js";
 import { functionCallParser } from "./functionCall.js";
 import { literalParser } from "./literals.js";
 import { matchBlockParser } from "./matchBlock.js";
 import { optionalSemicolon } from "./parserUtils.js";
-import { typeAliasParser, typeHintParser, variableTypeParser, } from "./typeHints.js";
-import { comma, optionalSpaces, varNameChar } from "./utils.js";
 import { returnStatementParser } from "./returnStatement.js";
-import { usesToolParser } from "./tools.js";
 import { specialVarParser } from "./specialVar.js";
+import { usesToolParser } from "./tools.js";
+import { typeAliasParser, typeHintParser, variableTypeParser, } from "./typeHints.js";
+import { comma, optionalSpaces, optionalSpacesOrNewline, varNameChar, } from "./utils.js";
+import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
+import { awaitParser } from "./await.js";
+import { newLineParser } from "./newline.js";
+export const assignmentParser = (input) => {
+    const parser = trace("assignmentParser", seqC(set("type", "assignment"), optionalSpaces, capture(many1WithJoin(varNameChar), "variableName"), optionalSpaces, optional(captureCaptures(seqC(char(":"), optionalSpaces, capture(variableTypeParser, "typeHint")))), optionalSpaces, char("="), optionalSpaces, capture(or(timeBlockParser, awaitParser, functionCallParser, indexAccessParser, accessExpressionParser, agencyArrayParser, agencyObjectParser, literalParser), "value"), optionalSemicolon));
+    return parser(input);
+};
 const trim = (s) => s.trim();
 export const docStringParser = trace("docStringParser", seqC(set("type", "docString"), str('"""'), capture(map(many1Till(str('"""')), trim), "value"), str('"""')));
-export const bodyParser = trace("functionBodyParser", (input) => {
-    const parser = sepBy(spaces, or(usesToolParser, debug(typeAliasParser, "error in typeAliasParser"), debug(typeHintParser, "error in typeHintParser"), specialVarParser, returnStatementParser, whileLoopParser, matchBlockParser, functionParser, accessExpressionParser, assignmentParser, functionCallParser, literalParser, commentParser));
-    const result = parser(input);
-    return result;
-});
+export const bodyParser = (input) => {
+    const parser = trace("functionBodyParser", many(or(usesToolParser, debug(typeAliasParser, "error in typeAliasParser"), debug(typeHintParser, "error in typeHintParser"), specialVarParser, returnStatementParser, whileLoopParser, matchBlockParser, awaitParser, ifParser, functionParser, accessExpressionParser, assignmentParser, functionCallParser, literalParser, commentParser, newLineParser)));
+    return parser(input);
+};
+export const timeBlockParser = trace("timeBlockParser", seqC(set("type", "timeBlock"), str("time"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpaces, char("}")));
+/* const elseClauseParser: Parser<AgencyNode[]> = seqC(
+  str("else"),
+  optionalSpaces,
+  char("{"),
+  spaces,
+  captureCaptures(bodyParser),
+  optionalSpaces,
+  char("}"),
+);
+
+export const ifElseParser: Parser<IfElse> = (input: string) => {
+  const parser = trace(
+    "ifElseParser",
+    seqC(
+      set("type", "ifElse"),
+      str("if"),
+      optionalSpaces,
+      char("("),
+      optionalSpaces,
+      capture(
+        or(
+          indexAccessParser,
+          functionCallParser,
+          accessExpressionParser,
+          literalParser,
+        ),
+        "condition",
+      ),
+      optionalSpaces,
+      char(")"),
+      optionalSpaces,
+      char("{"),
+      spaces,
+      capture(bodyParser, "thenBody"),
+      optionalSpaces,
+      char("}"),
+      optionalSpaces,
+      capture(optional(elseClauseParser), "elseBody"),
+    ),
+  );
+  return parser(input);
+}; */
+export const ifParser = (input) => {
+    const parser = trace("ifParser", seqC(set("type", "ifElse"), str("if"), optionalSpaces, char("("), optionalSpaces, capture(or(accessExpressionParser, functionCallParser, literalParser), "condition"), optionalSpaces, char(")"), optionalSpaces, char("{"), spaces, capture(bodyParser, "thenBody"), optionalSpaces, char("}")));
+    return parser(input);
+};
 export const whileLoopParser = trace("whileLoopParser", seqC(set("type", "whileLoop"), str("while"), optionalSpaces, char("("), optionalSpaces, capture(or(indexAccessParser, functionCallParser, accessExpressionParser, literalParser), "condition"), optionalSpaces, char(")"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpaces, char("}")));
 export const functionParameterParserWithTypeHint = trace("functionParameterParserWithTypeHint", seqC(set("type", "functionParameter"), capture(many1WithJoin(varNameChar), "name"), optionalSpaces, char(":"), optionalSpaces, capture(variableTypeParser, "typeHint")));
 export const functionParameterParser = trace("functionParameterParser", seqC(set("type", "functionParameter"), capture(many1WithJoin(varNameChar), "name")));
 export const functionReturnTypeParser = trace("functionReturnTypeParser", seqC(char(":"), optionalSpaces, captureCaptures(variableTypeParser)));
-export const functionParser = trace("functionParser", seqC(set("type", "function"), str("def"), many1(space), capture(many1Till(char("(")), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpaces, capture(or(docStringParser, succeed(undefined)), "docString"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
-export const graphNodeParser = trace("graphNodeParser", seqC(set("type", "graphNode"), str("node"), many1(space), capture(many1Till(char("(")), "nodeName"), char("("), optionalSpaces, capture(or(sepBy(comma, many1WithJoin(varNameChar)), succeed([])), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
+export const functionParser = trace("functionParser", seqC(set("type", "function"), str("def"), many1(space), capture(many1Till(char("(")), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpacesOrNewline, capture(or(docStringParser, succeed(undefined)), "docString"), optionalSpacesOrNewline, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
+export const graphNodeParser = trace("graphNodeParser", seqC(set("type", "graphNode"), str("node"), many1(space), capture(many1Till(char("(")), "nodeName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpacesOrNewline, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));