flowquery 1.0.2 → 1.0.5

package/README.md

@@ -18,8 +18,61 @@ FlowQuery is written in TypeScript (https://www.typescriptlang.org/) and built/c
   - This will run all unit tests.
 - Build: ```npm run build``` (builds for both Node and web)
 
+## Installation & Usage
+
+### Node.js
+
+Install FlowQuery from npm:
+
+```bash
+npm install flowquery
+```
+
+Then use it in your code:
+
+```javascript
+const FlowQuery = require('flowquery').default;
+// Or with ES modules:
+// import FlowQuery from 'flowquery';
+
+async function main() {
+    const query = new FlowQuery('WITH 1 AS x RETURN x + 1');
+    await query.run();
+    console.log(query.results); // [ { expr0: 2 } ]
+}
+
+main();
+```
+
+### Browser
+
+Include the minified bundle in your HTML:
+
+```html
+<script src="https://microsoft.github.io/FlowQuery/flowquery.min.js"></script>
+<script>
+async function main() {
+    const query = new FlowQuery('WITH 1 AS x RETURN x + 1');
+    await query.run();
+    console.log(query.results); // [ { expr0: 2 } ]
+}
+
+main();
+</script>
+```
+
+Or import from the browser-specific entry point:
+
+```javascript
+import FlowQuery from 'flowquery/browser';
+
+const query = new FlowQuery('WITH "Hello" AS greeting RETURN greeting');
+await query.run();
+console.log(query.results);
+```
+
 ## Examples
-See also .\queries and .\tests\compute\runner.test.ts for more examples.
+See also ./misc/queries and ./tests/compute/runner.test.ts for more examples.
 ```cypher
 /*
 Collect 10 random pieces of wisdom and create a letter histogram.

package/dist/compute/runner.d.ts

@@ -0,0 +1,81 @@
+import { FunctionCreator, AsyncDataProvider } from "../parsing/functions/function_factory";
+import { FunctionMetadata, RegisterFunctionOptions, RegisterAsyncProviderOptions } from "../parsing/functions/function_metadata";
+import Function from "../parsing/functions/function";
+/**
+ * Executes a FlowQuery statement and retrieves the results.
+ *
+ * The Runner class parses a FlowQuery statement into an AST and executes it,
+ * managing the execution flow from the first operation to the final return statement.
+ *
+ * @example
+ * ```typescript
+ * const runner = new Runner("WITH 1 as x RETURN x");
+ * await runner.run();
+ * console.log(runner.results); // [{ x: 1 }]
+ * ```
+ */
+declare class Runner {
+    private first;
+    private last;
+    /**
+     * Register a synchronous plugin function.
+     * Added dynamically in index.browser.ts / index.node.ts
+     */
+    static registerFunction: (name: string, factoryOrOptions: FunctionCreator | RegisterFunctionOptions) => void;
+    /**
+     * Unregister a synchronous plugin function.
+     * Added dynamically in index.browser.ts / index.node.ts
+     */
+    static unregisterFunction: (name: string) => void;
+    /**
+     * Register an async data provider function for use in LOAD operations.
+     * Added dynamically in index.browser.ts / index.node.ts
+     */
+    static registerAsyncProvider: (name: string, providerOrOptions: AsyncDataProvider | RegisterAsyncProviderOptions) => void;
+    /**
+     * Unregister an async data provider function.
+     * Added dynamically in index.browser.ts / index.node.ts
+     */
+    static unregisterAsyncProvider: (name: string) => void;
+    /**
+     * List all registered functions with their metadata.
+     * Added dynamically in index.browser.ts / index.node.ts
+     */
+    static listFunctions: (options?: {
+        category?: string;
+        asyncOnly?: boolean;
+        syncOnly?: boolean;
+    }) => FunctionMetadata[];
+    /**
+     * Get metadata for a specific function.
+     * Added dynamically in index.browser.ts / index.node.ts
+     */
+    static getFunctionMetadata: (name: string) => FunctionMetadata | undefined;
+    /**
+     * Base Function class for creating custom plugin functions.
+     * Added dynamically in index.browser.ts / index.node.ts
+     */
+    static Function: typeof Function;
+    /**
+     * Creates a new Runner instance and parses the FlowQuery statement.
+     *
+     * @param statement - The FlowQuery statement to execute
+     * @throws {Error} If the statement is null, empty, or contains syntax errors
+     */
+    constructor(statement?: string | null);
+    /**
+     * Executes the parsed FlowQuery statement.
+     *
+     * @returns A promise that resolves when execution completes
+     * @throws {Error} If an error occurs during execution
+     */
+    run(): Promise<void>;
+    /**
+     * Gets the results from the executed statement.
+     *
+     * @returns The results from the last operation (typically a RETURN statement)
+     */
+    get results(): any;
+}
+export default Runner;
+//# sourceMappingURL=runner.d.ts.map

package/dist/compute/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/compute/runner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC3F,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,4BAA4B,EAAE,MAAM,wCAAwC,CAAC;AACjI,OAAO,QAAQ,MAAM,+BAA+B,CAAC;AAErD;;;;;;;;;;;;GAYG;AACH,cAAM,MAAM;IACR,OAAO,CAAC,KAAK,CAAY;IACzB,OAAO,CAAC,IAAI,CAAY;IAExB;;;OAGG;IACH,MAAM,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,eAAe,GAAG,uBAAuB,KAAK,IAAI,CAAC;IAE7G;;;OAGG;IACH,MAAM,CAAC,kBAAkB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAElD;;;OAGG;IACH,MAAM,CAAC,qBAAqB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,iBAAiB,EAAE,iBAAiB,GAAG,4BAA4B,KAAK,IAAI,CAAC;IAE1H;;;OAGG;IACH,MAAM,CAAC,uBAAuB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEvD;;;OAGG;IACH,MAAM,CAAC,aAAa,EAAE,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,KAAK,gBAAgB,EAAE,CAAC;IAEvH;;;OAGG;IACH,MAAM,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,gBAAgB,GAAG,SAAS,CAAC;IAE3E;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAEjC;;;;;OAKG;gBACS,SAAS,GAAE,MAAM,GAAG,IAAW;IAU3C;;;;;OAKG;IACU,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAYjC;;;;OAIG;IACH,IAAW,OAAO,IAAI,GAAG,CAExB;CACJ;AAED,eAAe,MAAM,CAAC"}

package/dist/index.browser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * FlowQuery - A declarative query language for data processing pipelines.
+ *
+ * This is the main entry point for the FlowQuery in-browser usage.
+ *
+ * @packageDocumentation
+ */
+import { default as FlowQuery } from "./compute/runner";
+export default FlowQuery;
+//# sourceMappingURL=index.browser.d.ts.map

package/dist/index.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.browser.d.ts","sourceRoot":"","sources":["../src/index.browser.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAwHtD,eAAe,SAAS,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * FlowQuery - A declarative query language for data processing pipelines.
+ *
+ * This is the main entry point for the FlowQuery command-line interface.
+ *
+ * @packageDocumentation
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/index.node.d.ts

@@ -0,0 +1,14 @@
+/**
+ * FlowQuery - A declarative query language for data processing pipelines.
+ *
+ * This is the main entry point for the FlowQuery Node.js library usage.
+ *
+ * @packageDocumentation
+ */
+import { default as FlowQuery } from "./compute/runner";
+import FunctionFactory, { FunctionCreator, AsyncDataProvider } from "./parsing/functions/function_factory";
+import { FunctionMetadata, ParameterSchema, OutputSchema, RegisterFunctionOptions, RegisterAsyncProviderOptions } from "./parsing/functions/function_metadata";
+import Function from "./parsing/functions/function";
+export default FlowQuery;
+export { FlowQuery, Function, FunctionFactory, FunctionCreator, AsyncDataProvider, FunctionMetadata, ParameterSchema, OutputSchema, RegisterFunctionOptions, RegisterAsyncProviderOptions };
+//# sourceMappingURL=index.node.d.ts.map

package/dist/index.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.node.d.ts","sourceRoot":"","sources":["../src/index.node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,kBAAkB,CAAC;AACtD,OAAO,eAAe,EAAE,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAC3G,OAAO,EACH,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,uBAAuB,EACvB,4BAA4B,EAC/B,MAAM,uCAAuC,CAAC;AAC/C,OAAO,QAAQ,MAAM,8BAA8B,CAAC;AA+GpD,eAAe,SAAS,CAAC;AACzB,OAAO,EACH,SAAS,EACT,QAAQ,EACR,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,YAAY,EACZ,uBAAuB,EACvB,4BAA4B,EAC/B,CAAC"}

package/dist/io/command_line.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Interactive command-line interface for FlowQuery.
+ *
+ * Provides a REPL (Read-Eval-Print Loop) for executing FlowQuery statements
+ * and displaying results.
+ *
+ * @example
+ * ```typescript
+ * const cli = new CommandLine();
+ * cli.loop(); // Starts interactive mode
+ * ```
+ */
+declare class CommandLine {
+    private rl;
+    /**
+     * Creates a new CommandLine interface.
+     */
+    constructor();
+    /**
+     * Starts the interactive command loop.
+     *
+     * Prompts the user for FlowQuery statements, executes them, and displays results.
+     * Type "exit" to quit the loop.
+     */
+    loop(): void;
+}
+export default CommandLine;
+//# sourceMappingURL=command_line.d.ts.map

package/dist/io/command_line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_line.d.ts","sourceRoot":"","sources":["../../src/io/command_line.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,cAAM,WAAW;IACb,OAAO,CAAC,EAAE,CAAqB;IAE/B;;OAEG;;IAQH;;;;;OAKG;IACI,IAAI;CAqCd;AAED,eAAe,WAAW,CAAC"}

package/dist/parsing/alias.d.ts

@@ -0,0 +1,10 @@
+import ASTNode from "./ast_node";
+declare class Alias extends ASTNode {
+    private alias;
+    constructor(alias: string);
+    toString(): string;
+    getAlias(): string;
+    value(): string;
+}
+export default Alias;
+//# sourceMappingURL=alias.d.ts.map

package/dist/parsing/alias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias.d.ts","sourceRoot":"","sources":["../../src/parsing/alias.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,YAAY,CAAC;AAEjC,cAAM,KAAM,SAAQ,OAAO;IACvB,OAAO,CAAC,KAAK,CAAS;gBACV,KAAK,EAAE,MAAM;IAKlB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;IAIlB,KAAK,IAAI,MAAM;CAGzB;AAED,eAAe,KAAK,CAAC"}

package/dist/parsing/alias_option.d.ts

@@ -0,0 +1,6 @@
+export declare enum AliasOption {
+    NOT_ALLOWED = 0,
+    OPTIONAL = 1,
+    REQUIRED = 2
+}
+//# sourceMappingURL=alias_option.d.ts.map

package/dist/parsing/alias_option.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alias_option.d.ts","sourceRoot":"","sources":["../../src/parsing/alias_option.ts"],"names":[],"mappings":"AAAA,oBAAY,WAAW;IACnB,WAAW,IAAI;IACf,QAAQ,IAAI;IACZ,QAAQ,IAAI;CACf"}

package/dist/parsing/ast_node.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Represents a node in the Abstract Syntax Tree (AST).
+ *
+ * The AST is a tree representation of the parsed FlowQuery statement structure.
+ * Each node can have children and maintains a reference to its parent.
+ *
+ * @example
+ * ```typescript
+ * const root = new ASTNode();
+ * const child = new ASTNode();
+ * root.addChild(child);
+ * ```
+ */
+declare class ASTNode {
+    protected _parent: ASTNode | null;
+    protected children: ASTNode[];
+    /**
+     * Adds a child node to this node and sets the child's parent reference.
+     *
+     * @param child - The child node to add
+     */
+    addChild(child: ASTNode): void;
+    /**
+     * Returns the first child node.
+     *
+     * @returns The first child node
+     * @throws {Error} If the node has no children
+     */
+    firstChild(): ASTNode;
+    /**
+     * Returns the last child node.
+     *
+     * @returns The last child node
+     * @throws {Error} If the node has no children
+     */
+    lastChild(): ASTNode;
+    /**
+     * Returns all child nodes.
+     *
+     * @returns Array of child nodes
+     */
+    getChildren(): ASTNode[];
+    /**
+     * Returns the number of child nodes.
+     *
+     * @returns The count of children
+     */
+    childCount(): number;
+    /**
+     * Returns the value of this node. Override in subclasses to provide specific values.
+     *
+     * @returns The node's value, or null if not applicable
+     */
+    value(): any;
+    /**
+     * Checks if this node represents an operator.
+     *
+     * @returns True if this is an operator node, false otherwise
+     */
+    isOperator(): boolean;
+    /**
+     * Checks if this node represents an operand (the opposite of an operator).
+     *
+     * @returns True if this is an operand node, false otherwise
+     */
+    isOperand(): boolean;
+    /**
+     * Gets the operator precedence for this node. Higher values indicate higher precedence.
+     *
+     * @returns The precedence value (0 for non-operators)
+     */
+    get precedence(): number;
+    /**
+     * Indicates whether this operator is left-associative.
+     *
+     * @returns True if left-associative, false otherwise
+     */
+    get leftAssociative(): boolean;
+    /**
+     * Prints a string representation of the AST tree starting from this node.
+     *
+     * @returns A formatted string showing the tree structure
+     */
+    print(): string;
+    /**
+     * Generator function for recursively printing the tree structure.
+     *
+     * @param indent - The current indentation level
+     * @yields Lines representing each node in the tree
+     */
+    private _print;
+    /**
+     * Returns a string representation of this node. Override in subclasses for custom formatting.
+     *
+     * @returns The string representation
+     */
+    protected toString(): string;
+}
+export default ASTNode;
+//# sourceMappingURL=ast_node.d.ts.map

package/dist/parsing/ast_node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast_node.d.ts","sourceRoot":"","sources":["../../src/parsing/ast_node.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAM,OAAO;IACT,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAQ;IACzC,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAM;IAEnC;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAKrC;;;;;OAKG;IACI,UAAU,IAAI,OAAO;IAO5B;;;;;OAKG;IACI,SAAS,IAAI,OAAO;IAO3B;;;;OAIG;IACI,WAAW,IAAI,OAAO,EAAE;IAI/B;;;;OAIG;IACI,UAAU,IAAI,MAAM;IAI3B;;;;OAIG;IACI,KAAK,IAAI,GAAG;IAInB;;;;OAIG;IACI,UAAU,IAAI,OAAO;IAI5B;;;;OAIG;IACI,SAAS,IAAI,OAAO;IAI3B;;;;OAIG;IACH,IAAW,UAAU,IAAI,MAAM,CAE9B;IAED;;;;OAIG;IACH,IAAW,eAAe,IAAI,OAAO,CAEpC;IAED;;;;OAIG;IACI,KAAK,IAAI,MAAM;IAItB;;;;;OAKG;IACH,OAAO,CAAE,MAAM;IAWf;;;;OAIG;IACH,SAAS,CAAC,QAAQ,IAAI,MAAM;CAG/B;AAED,eAAe,OAAO,CAAC"}

package/dist/parsing/base_parser.d.ts

@@ -0,0 +1,49 @@
+import Token from "../tokenization/token";
+/**
+ * Base class for parsers providing common token manipulation functionality.
+ *
+ * This class handles tokenization and provides utility methods for navigating
+ * through tokens, peeking ahead, and checking token sequences.
+ */
+declare class BaseParser {
+    private tokens;
+    private tokenIndex;
+    /**
+     * Tokenizes a statement and initializes the token array.
+     *
+     * @param statement - The input statement to tokenize
+     */
+    protected tokenize(statement: string): void;
+    /**
+     * Advances to the next token in the sequence.
+     */
+    protected setNextToken(): void;
+    /**
+     * Peeks at the next token without advancing the current position.
+     *
+     * @returns The next token, or null if at the end of the token stream
+     */
+    protected peek(): Token | null;
+    /**
+     * Checks if a sequence of tokens appears ahead in the token stream.
+     *
+     * @param tokens - The sequence of tokens to look for
+     * @param skipWhitespaceAndComments - Whether to skip whitespace and comments when matching
+     * @returns True if the token sequence is found ahead, false otherwise
+     */
+    protected ahead(tokens: Token[], skipWhitespaceAndComments?: boolean): boolean;
+    /**
+     * Gets the current token.
+     *
+     * @returns The current token, or EOF if at the end
+     */
+    protected get token(): Token;
+    /**
+     * Gets the previous token.
+     *
+     * @returns The previous token, or EOF if at the beginning
+     */
+    protected get previousToken(): Token;
+}
+export default BaseParser;
+//# sourceMappingURL=base_parser.d.ts.map

package/dist/parsing/base_parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base_parser.d.ts","sourceRoot":"","sources":["../../src/parsing/base_parser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,uBAAuB,CAAC;AAG1C;;;;;GAKG;AACH,cAAM,UAAU;IACZ,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,UAAU,CAAa;IAE/B;;;;OAIG;IACH,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAK3C;;OAEG;IACH,SAAS,CAAC,YAAY,IAAI,IAAI;IAI9B;;;;OAIG;IACH,SAAS,CAAC,IAAI,IAAI,KAAK,GAAG,IAAI;IAO9B;;;;;;OAMG;IACH,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,yBAAyB,GAAE,OAAc,GAAG,OAAO;IAiBpF;;;;OAIG;IACH,SAAS,KAAK,KAAK,IAAI,KAAK,CAK3B;IAED;;;;OAIG;IACH,SAAS,KAAK,aAAa,IAAI,KAAK,CAKnC;CACJ;AAED,eAAe,UAAU,CAAC"}

package/dist/parsing/components/csv.d.ts

@@ -0,0 +1,6 @@
+import ASTNode from "../ast_node";
+declare class CSV extends ASTNode {
+    constructor();
+}
+export default CSV;
+//# sourceMappingURL=csv.d.ts.map

package/dist/parsing/components/csv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csv.d.ts","sourceRoot":"","sources":["../../../src/parsing/components/csv.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC,cAAM,GAAI,SAAQ,OAAO;;CAIxB;AAED,eAAe,GAAG,CAAC"}

package/dist/parsing/components/from.d.ts

@@ -0,0 +1,7 @@
+import ASTNode from "../ast_node";
+declare class From extends ASTNode {
+    constructor();
+    value(): string;
+}
+export default From;
+//# sourceMappingURL=from.d.ts.map

package/dist/parsing/components/from.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"from.d.ts","sourceRoot":"","sources":["../../../src/parsing/components/from.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC,cAAM,IAAK,SAAQ,OAAO;;IAIjB,KAAK,IAAI,MAAM;CAGvB;AAED,eAAe,IAAI,CAAC"}

package/dist/parsing/components/headers.d.ts

@@ -0,0 +1,7 @@
+import ASTNode from "../ast_node";
+declare class Headers extends ASTNode {
+    constructor();
+    value(): object;
+}
+export default Headers;
+//# sourceMappingURL=headers.d.ts.map

package/dist/parsing/components/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../../src/parsing/components/headers.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC,cAAM,OAAQ,SAAQ,OAAO;;IAIpB,KAAK,IAAI,MAAM;CAGvB;AAED,eAAe,OAAO,CAAC"}

package/dist/parsing/components/json.d.ts

@@ -0,0 +1,6 @@
+import ASTNode from "../ast_node";
+declare class JSON extends ASTNode {
+    constructor();
+}
+export default JSON;
+//# sourceMappingURL=json.d.ts.map

package/dist/parsing/components/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/parsing/components/json.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC,cAAM,IAAK,SAAQ,OAAO;;CAIzB;AAED,eAAe,IAAI,CAAC"}

package/dist/parsing/components/null.d.ts

@@ -0,0 +1,6 @@
+import ASTNode from "../ast_node";
+declare class Null extends ASTNode {
+    constructor();
+}
+export default Null;
+//# sourceMappingURL=null.d.ts.map

package/dist/parsing/components/null.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null.d.ts","sourceRoot":"","sources":["../../../src/parsing/components/null.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC,cAAM,IAAK,SAAQ,OAAO;;CAIzB;AAED,eAAe,IAAI,CAAC"}

package/dist/parsing/components/post.d.ts

@@ -0,0 +1,6 @@
+import ASTNode from "../ast_node";
+declare class Post extends ASTNode {
+    constructor();
+}
+export default Post;
+//# sourceMappingURL=post.d.ts.map

package/dist/parsing/components/post.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post.d.ts","sourceRoot":"","sources":["../../../src/parsing/components/post.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC,cAAM,IAAK,SAAQ,OAAO;;CAIzB;AAED,eAAe,IAAI,CAAC"}

package/dist/parsing/components/text.d.ts

@@ -0,0 +1,6 @@
+import ASTNode from "../ast_node";
+declare class Text extends ASTNode {
+    constructor();
+}
+export default Text;
+//# sourceMappingURL=text.d.ts.map

package/dist/parsing/components/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/parsing/components/text.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC,cAAM,IAAK,SAAQ,OAAO;;CAIzB;AAED,eAAe,IAAI,CAAC"}

package/dist/parsing/context.d.ts

@@ -0,0 +1,38 @@
+import ASTNode from "./ast_node";
+/**
+ * Maintains a stack of AST nodes to track parsing context.
+ *
+ * Used during parsing to maintain the current context and check for specific node types
+ * in the parsing hierarchy, which helps with context-sensitive parsing decisions.
+ *
+ * @example
+ * ```typescript
+ * const context = new Context();
+ * context.push(node);
+ * const hasReturn = context.containsType(Return);
+ * ```
+ */
+declare class Context {
+    private stack;
+    /**
+     * Pushes a node onto the context stack.
+     *
+     * @param node - The AST node to push
+     */
+    push(node: ASTNode): void;
+    /**
+     * Pops the top node from the context stack.
+     *
+     * @returns The popped node, or undefined if the stack is empty
+     */
+    pop(): ASTNode | undefined;
+    /**
+     * Checks if the stack contains a node of the specified type.
+     *
+     * @param type - The constructor of the node type to search for
+     * @returns True if a node of the specified type is found in the stack, false otherwise
+     */
+    containsType(type: new (...args: any[]) => ASTNode): boolean;
+}
+export default Context;
+//# sourceMappingURL=context.d.ts.map

package/dist/parsing/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/parsing/context.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,YAAY,CAAC;AAEjC;;;;;;;;;;;;GAYG;AACH,cAAM,OAAO;IACT,OAAO,CAAC,KAAK,CAAiB;IAE9B;;;;OAIG;IACI,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAIhC;;;;OAIG;IACI,GAAG,IAAI,OAAO,GAAG,SAAS;IAIjC;;;;;OAKG;IACI,YAAY,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,GAAG,OAAO;CAGtE;AAED,eAAe,OAAO,CAAC"}

package/dist/parsing/data_structures/associative_array.d.ts

@@ -0,0 +1,28 @@
+import ASTNode from "../ast_node";
+import KeyValuePair from "./key_value_pair";
+/**
+ * Represents an associative array (object/dictionary) in the AST.
+ *
+ * Associative arrays map string keys to values, similar to JSON objects.
+ *
+ * @example
+ * ```typescript
+ * // For { name: "Alice", age: 30 }
+ * const obj = new AssociativeArray();
+ * obj.addKeyValue(new KeyValuePair("name", nameExpr));
+ * obj.addKeyValue(new KeyValuePair("age", ageExpr));
+ * ```
+ */
+declare class AssociativeArray extends ASTNode {
+    /**
+     * Adds a key-value pair to the associative array.
+     *
+     * @param keyValuePair - The key-value pair to add
+     */
+    addKeyValue(keyValuePair: KeyValuePair): void;
+    toString(): string;
+    private _value;
+    value(): Record<string, any>;
+}
+export default AssociativeArray;
+//# sourceMappingURL=associative_array.d.ts.map

package/dist/parsing/data_structures/associative_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"associative_array.d.ts","sourceRoot":"","sources":["../../../src/parsing/data_structures/associative_array.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAClC,OAAO,YAAY,MAAM,kBAAkB,CAAC;AAE5C;;;;;;;;;;;;GAYG;AACH,cAAM,gBAAiB,SAAQ,OAAO;IAClC;;;;OAIG;IACI,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;IAI7C,QAAQ,IAAI,MAAM;IAGzB,OAAO,CAAE,MAAM;IAQR,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAGtC;AAED,eAAe,gBAAgB,CAAC"}

package/dist/parsing/data_structures/json_array.d.ts

@@ -0,0 +1,26 @@
+import ASTNode from "../ast_node";
+/**
+ * Represents a JSON array in the AST.
+ *
+ * JSON arrays are ordered collections of values.
+ *
+ * @example
+ * ```typescript
+ * // For [1, 2, 3]
+ * const arr = new JSONArray();
+ * arr.addValue(new Number("1"));
+ * arr.addValue(new Number("2"));
+ * arr.addValue(new Number("3"));
+ * ```
+ */
+declare class JSONArray extends ASTNode {
+    /**
+     * Adds a value to the array.
+     *
+     * @param value - The AST node representing the value to add
+     */
+    addValue(value: ASTNode): void;
+    value(): any[];
+}
+export default JSONArray;
+//# sourceMappingURL=json_array.d.ts.map

package/dist/parsing/data_structures/json_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json_array.d.ts","sourceRoot":"","sources":["../../../src/parsing/data_structures/json_array.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAElC;;;;;;;;;;;;;GAaG;AACH,cAAM,SAAU,SAAQ,OAAO;IAC3B;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAG9B,KAAK,IAAI,GAAG,EAAE;CAGxB;AAED,eAAe,SAAS,CAAC"}

package/dist/parsing/data_structures/key_value_pair.d.ts

@@ -0,0 +1,25 @@
+import ASTNode from "../ast_node";
+/**
+ * Represents a key-value pair in an associative array.
+ *
+ * Used to build object literals in FlowQuery.
+ *
+ * @example
+ * ```typescript
+ * const kvp = new KeyValuePair("name", new String("Alice"));
+ * ```
+ */
+declare class KeyValuePair extends ASTNode {
+    /**
+     * Creates a new key-value pair.
+     *
+     * @param key - The key string
+     * @param value - The AST node representing the value
+     */
+    constructor(key: string, value: ASTNode);
+    get key(): string;
+    get _value(): any;
+    toString(): string;
+}
+export default KeyValuePair;
+//# sourceMappingURL=key_value_pair.d.ts.map

package/dist/parsing/data_structures/key_value_pair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key_value_pair.d.ts","sourceRoot":"","sources":["../../../src/parsing/data_structures/key_value_pair.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,aAAa,CAAC;AAGlC;;;;;;;;;GASG;AACH,cAAM,YAAa,SAAQ,OAAO;IAC9B;;;;;OAKG;gBACS,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO;IAKvC,IAAW,GAAG,IAAI,MAAM,CAEvB;IACD,IAAW,MAAM,IAAI,GAAG,CAEvB;IACM,QAAQ,IAAI,MAAM;CAG5B;AAED,eAAe,YAAY,CAAC"}