flowquery 1.0.0 → 1.0.1

package/dist/parsing/parser.js

@@ -0,0 +1,812 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const return_1 = __importDefault(require("./operations/return"));
+const expression_1 = __importDefault(require("./expressions/expression"));
+const ast_node_1 = __importDefault(require("./ast_node"));
+const base_parser_1 = __importDefault(require("./base_parser"));
+const function_factory_1 = __importDefault(require("./functions/function_factory"));
+const function_1 = __importDefault(require("./functions/function"));
+const async_function_1 = __importDefault(require("./functions/async_function"));
+const associative_array_1 = __importDefault(require("./data_structures/associative_array"));
+const json_array_1 = __importDefault(require("./data_structures/json_array"));
+const key_value_pair_1 = __importDefault(require("./data_structures/key_value_pair"));
+const with_1 = __importDefault(require("./operations/with"));
+const unwind_1 = __importDefault(require("./operations/unwind"));
+const where_1 = __importDefault(require("./operations/where"));
+const alias_option_1 = require("./alias_option");
+const load_1 = __importDefault(require("./operations/load"));
+const from_1 = __importDefault(require("./components/from"));
+const alias_1 = __importDefault(require("./alias"));
+const headers_1 = __importDefault(require("./components/headers"));
+const case_1 = __importDefault(require("./logic/case"));
+const when_1 = __importDefault(require("./logic/when"));
+const else_1 = __importDefault(require("./logic/else"));
+const then_1 = __importDefault(require("./logic/then"));
+const lookup_1 = __importDefault(require("./data_structures/lookup"));
+const operator_1 = require("./expressions/operator");
+const reference_1 = __importDefault(require("./expressions/reference"));
+const post_1 = __importDefault(require("./components/post"));
+const aggregated_return_1 = __importDefault(require("./operations/aggregated_return"));
+const context_1 = __importDefault(require("./context"));
+const aggregate_function_1 = __importDefault(require("./functions/aggregate_function"));
+const object_utils_1 = __importDefault(require("../utils/object_utils"));
+const token_1 = __importDefault(require("../tokenization/token"));
+const predicate_function_factory_1 = __importDefault(require("./functions/predicate_function_factory"));
+const f_string_1 = __importDefault(require("./expressions/f_string"));
+const string_1 = __importDefault(require("./expressions/string"));
+const aggregated_with_1 = __importDefault(require("./operations/aggregated_with"));
+const identifier_1 = __importDefault(require("./expressions/identifier"));
+const limit_1 = __importDefault(require("./operations/limit"));
+const range_lookup_1 = __importDefault(require("./data_structures/range_lookup"));
+const null_1 = __importDefault(require("./components/null"));
+/**
+ * Main parser for FlowQuery statements.
+ *
+ * Parses FlowQuery declarative query language statements into an Abstract Syntax Tree (AST).
+ * Supports operations like WITH, UNWIND, RETURN, LOAD, WHERE, and LIMIT, along with
+ * expressions, functions, data structures, and logical constructs.
+ *
+ * @example
+ * ```typescript
+ * const parser = new Parser();
+ * const ast = parser.parse("unwind [1, 2, 3, 4, 5, 6] as num return num");
+ * ```
+ */
+class Parser extends base_parser_1.default {
+    constructor() {
+        super(...arguments);
+        this.variables = new Map();
+        this.context = new context_1.default();
+        this._returns = 0;
+    }
+    /**
+     * Parses a FlowQuery statement into an Abstract Syntax Tree.
+     *
+     * @param statement - The FlowQuery statement to parse
+     * @returns The root AST node containing the parsed structure
+     * @throws {Error} If the statement is malformed or contains syntax errors
+     *
+     * @example
+     * ```typescript
+     * const ast = parser.parse("LOAD JSON FROM 'https://api.adviceslip.com/advice' AS data RETURN data");
+     * ```
+     */
+    parse(statement) {
+        this.tokenize(statement);
+        const root = new ast_node_1.default();
+        let previous = null;
+        let operation = null;
+        while (!this.token.isEOF()) {
+            if (root.childCount() > 0) {
+                this.expectAndSkipWhitespaceAndComments();
+            }
+            else {
+                this.skipWhitespaceAndComments();
+            }
+            operation = this.parseOperation();
+            if (operation === null) {
+                throw new Error('Expected one of WITH, UNWIND, RETURN, or LOAD');
+            }
+            if (this._returns > 1) {
+                throw new Error('Only one RETURN statement is allowed');
+            }
+            if (previous !== null) {
+                previous.addSibling(operation);
+            }
+            else {
+                root.addChild(operation);
+            }
+            const where = this.parseWhere();
+            if (where !== null) {
+                if (operation instanceof return_1.default) {
+                    operation.where = where;
+                }
+                else {
+                    operation.addSibling(where);
+                    operation = where;
+                }
+            }
+            const limit = this.parseLimit();
+            if (limit !== null) {
+                operation.addSibling(limit);
+                operation = limit;
+            }
+            previous = operation;
+        }
+        if (!(operation instanceof return_1.default)) {
+            throw new Error('Last statement must be a RETURN or a WHERE statement');
+        }
+        return root;
+    }
+    parseOperation() {
+        return (this.parseWith() ||
+            this.parseUnwind() ||
+            this.parseReturn() ||
+            this.parseLoad());
+    }
+    parseWith() {
+        if (!this.token.isWith()) {
+            return null;
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const expressions = Array.from(this.parseExpressions(alias_option_1.AliasOption.REQUIRED));
+        if (expressions.length === 0) {
+            throw new Error('Expected expression');
+        }
+        if (expressions.some((expression) => expression.has_reducers())) {
+            return new aggregated_with_1.default(expressions);
+        }
+        return new with_1.default(expressions);
+    }
+    parseUnwind() {
+        if (!this.token.isUnwind()) {
+            return null;
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const expression = this.parseExpression();
+        if (expression === null) {
+            throw new Error('Expected expression');
+        }
+        if (!object_utils_1.default.isInstanceOfAny(expression.firstChild(), [json_array_1.default, function_1.default, reference_1.default, lookup_1.default, range_lookup_1.default])) {
+            throw new Error('Expected array, function, reference, or lookup.');
+        }
+        this.expectAndSkipWhitespaceAndComments();
+        const alias = this.parseAlias();
+        if (alias !== null) {
+            expression.setAlias(alias.getAlias());
+        }
+        else {
+            throw new Error('Expected alias');
+        }
+        const unwind = new unwind_1.default(expression);
+        this.variables.set(alias.getAlias(), unwind);
+        return unwind;
+    }
+    parseReturn() {
+        if (!this.token.isReturn()) {
+            return null;
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const expressions = Array.from(this.parseExpressions(alias_option_1.AliasOption.OPTIONAL));
+        if (expressions.length === 0) {
+            throw new Error('Expected expression');
+        }
+        if (expressions.some((expression) => expression.has_reducers())) {
+            return new aggregated_return_1.default(expressions);
+        }
+        this._returns++;
+        return new return_1.default(expressions);
+    }
+    parseWhere() {
+        if (!this.token.isWhere()) {
+            return null;
+        }
+        this.expectPreviousTokenToBeWhitespaceOrComment();
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const expression = this.parseExpression();
+        if (expression === null) {
+            throw new Error('Expected expression');
+        }
+        if (object_utils_1.default.isInstanceOfAny(expression.firstChild(), [json_array_1.default, associative_array_1.default])) {
+            throw new Error('Expected an expression which can be evaluated to a boolean');
+        }
+        return new where_1.default(expression);
+    }
+    parseLoad() {
+        if (!this.token.isLoad()) {
+            return null;
+        }
+        const load = new load_1.default();
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        if (!(this.token.isJSON() || this.token.isCSV() || this.token.isText())) {
+            throw new Error('Expected JSON, CSV, or TEXT');
+        }
+        load.addChild(this.token.node);
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        if (!this.token.isFrom()) {
+            throw new Error('Expected FROM');
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const from = new from_1.default();
+        load.addChild(from);
+        // Check if the source is an async function
+        const asyncFunc = this.parseAsyncFunction();
+        if (asyncFunc !== null) {
+            from.addChild(asyncFunc);
+        }
+        else {
+            const expression = this.parseExpression();
+            if (expression === null) {
+                throw new Error('Expected expression or async function');
+            }
+            from.addChild(expression);
+        }
+        this.expectAndSkipWhitespaceAndComments();
+        if (this.token.isHeaders()) {
+            const headers = new headers_1.default();
+            this.setNextToken();
+            this.expectAndSkipWhitespaceAndComments();
+            const header = this.parseExpression();
+            if (header === null) {
+                throw new Error('Expected expression');
+            }
+            headers.addChild(header);
+            load.addChild(headers);
+            this.expectAndSkipWhitespaceAndComments();
+        }
+        if (this.token.isPost()) {
+            const post = new post_1.default();
+            this.setNextToken();
+            this.expectAndSkipWhitespaceAndComments();
+            const payload = this.parseExpression();
+            if (payload === null) {
+                throw new Error('Expected expression');
+            }
+            post.addChild(payload);
+            load.addChild(post);
+            this.expectAndSkipWhitespaceAndComments();
+        }
+        const alias = this.parseAlias();
+        if (alias !== null) {
+            load.addChild(alias);
+            this.variables.set(alias.getAlias(), load);
+        }
+        else {
+            throw new Error('Expected alias');
+        }
+        return load;
+    }
+    parseLimit() {
+        this.skipWhitespaceAndComments();
+        if (!this.token.isLimit()) {
+            return null;
+        }
+        this.expectPreviousTokenToBeWhitespaceOrComment();
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        if (!this.token.isNumber()) {
+            throw new Error('Expected number');
+        }
+        const limit = new limit_1.default(parseInt(this.token.value || '0'));
+        this.setNextToken();
+        return limit;
+    }
+    *parseExpressions(alias_option = alias_option_1.AliasOption.NOT_ALLOWED) {
+        while (true) {
+            const expression = this.parseExpression();
+            if (expression !== null) {
+                const alias = this.parseAlias();
+                if (expression.firstChild() instanceof reference_1.default && alias === null) {
+                    const reference = expression.firstChild();
+                    expression.setAlias(reference.identifier);
+                    this.variables.set(reference.identifier, expression);
+                }
+                else if (alias_option === alias_option_1.AliasOption.REQUIRED && alias === null && !(expression.firstChild() instanceof reference_1.default)) {
+                    throw new Error('Alias required');
+                }
+                else if (alias_option === alias_option_1.AliasOption.NOT_ALLOWED && alias !== null) {
+                    throw new Error('Alias not allowed');
+                }
+                else if ([alias_option_1.AliasOption.OPTIONAL, alias_option_1.AliasOption.REQUIRED].includes(alias_option) && alias !== null) {
+                    expression.setAlias(alias.getAlias());
+                    this.variables.set(alias.getAlias(), expression);
+                }
+                yield expression;
+            }
+            else {
+                break;
+            }
+            this.skipWhitespaceAndComments();
+            if (!this.token.isComma()) {
+                break;
+            }
+            this.setNextToken();
+        }
+    }
+    parseExpression() {
+        var _a, _b;
+        const expression = new expression_1.default();
+        while (true) {
+            this.skipWhitespaceAndComments();
+            if (this.token.isIdentifier() && !((_a = this.peek()) === null || _a === void 0 ? void 0 : _a.isLeftParenthesis())) {
+                const identifier = this.token.value || '';
+                const reference = new reference_1.default(identifier, this.variables.get(identifier));
+                this.setNextToken();
+                const lookup = this.parseLookup(reference);
+                expression.addNode(lookup);
+            }
+            else if (this.token.isIdentifier() && ((_b = this.peek()) === null || _b === void 0 ? void 0 : _b.isLeftParenthesis())) {
+                const func = this.parsePredicateFunction() || this.parseFunction();
+                if (func !== null) {
+                    const lookup = this.parseLookup(func);
+                    expression.addNode(lookup);
+                }
+            }
+            else if (this.token.isOperand()) {
+                expression.addNode(this.token.node);
+                this.setNextToken();
+            }
+            else if (this.token.isFString()) {
+                const f_string = this.parseFString();
+                if (f_string === null) {
+                    throw new Error('Expected f-string');
+                }
+                expression.addNode(f_string);
+            }
+            else if (this.token.isLeftParenthesis()) {
+                this.setNextToken();
+                const sub = this.parseExpression();
+                if (sub === null) {
+                    throw new Error('Expected expression');
+                }
+                if (!this.token.isRightParenthesis()) {
+                    throw new Error('Expected right parenthesis');
+                }
+                this.setNextToken();
+                const lookup = this.parseLookup(sub);
+                expression.addNode(lookup);
+            }
+            else if (this.token.isOpeningBrace() || this.token.isOpeningBracket()) {
+                const json = this.parseJSON();
+                if (json === null) {
+                    throw new Error('Expected JSON object');
+                }
+                const lookup = this.parseLookup(json);
+                expression.addNode(lookup);
+            }
+            else if (this.token.isCase()) {
+                const _case = this.parseCase();
+                if (_case === null) {
+                    throw new Error('Expected CASE statement');
+                }
+                expression.addNode(_case);
+            }
+            else if (this.token.isNot()) {
+                const not = new operator_1.Not();
+                this.setNextToken();
+                const sub = this.parseExpression();
+                if (sub === null) {
+                    throw new Error('Expected expression');
+                }
+                not.addChild(sub);
+                expression.addNode(not);
+            }
+            else {
+                if (expression.nodesAdded()) {
+                    throw new Error('Expected operand or left parenthesis');
+                }
+                else {
+                    break;
+                }
+            }
+            this.skipWhitespaceAndComments();
+            if (this.token.isOperator()) {
+                expression.addNode(this.token.node);
+            }
+            else {
+                break;
+            }
+            this.setNextToken();
+        }
+        if (expression.nodesAdded()) {
+            expression.finish();
+            return expression;
+        }
+        return null;
+    }
+    parseLookup(node) {
+        let variable = node;
+        let lookup = null;
+        while (true) {
+            if (this.token.isDot()) {
+                this.setNextToken();
+                if (!this.token.isIdentifier() && !this.token.isKeyword()) {
+                    throw new Error('Expected identifier');
+                }
+                lookup = new lookup_1.default();
+                lookup.index = new identifier_1.default(this.token.value || '');
+                lookup.variable = variable;
+                this.setNextToken();
+            }
+            else if (this.token.isOpeningBracket()) {
+                this.setNextToken();
+                this.skipWhitespaceAndComments();
+                const index = this.parseExpression();
+                let to = null;
+                this.skipWhitespaceAndComments();
+                if (this.token.isColon()) {
+                    this.setNextToken();
+                    this.skipWhitespaceAndComments();
+                    lookup = new range_lookup_1.default();
+                    to = this.parseExpression();
+                }
+                else {
+                    if (index === null) {
+                        throw new Error('Expected expression');
+                    }
+                    lookup = new lookup_1.default();
+                }
+                this.skipWhitespaceAndComments();
+                if (!this.token.isClosingBracket()) {
+                    throw new Error('Expected closing bracket');
+                }
+                this.setNextToken();
+                if (lookup instanceof range_lookup_1.default) {
+                    lookup.from = index || new null_1.default();
+                    lookup.to = to || new null_1.default();
+                }
+                else if (lookup instanceof lookup_1.default && index !== null) {
+                    lookup.index = index;
+                }
+                lookup.variable = variable;
+            }
+            else {
+                break;
+            }
+            variable = lookup || variable;
+        }
+        return variable;
+    }
+    parseCase() {
+        if (!this.token.isCase()) {
+            return null;
+        }
+        this.setNextToken();
+        const _case = new case_1.default();
+        let parts = 0;
+        this.expectAndSkipWhitespaceAndComments();
+        while (true) {
+            const when = this.parseWhen();
+            if (when === null && parts === 0) {
+                throw new Error('Expected WHEN');
+            }
+            else if (when === null && parts > 0) {
+                break;
+            }
+            else if (when !== null) {
+                _case.addChild(when);
+            }
+            this.expectAndSkipWhitespaceAndComments();
+            const then = this.parseThen();
+            if (then === null) {
+                throw new Error('Expected THEN');
+            }
+            else {
+                _case.addChild(then);
+            }
+            this.expectAndSkipWhitespaceAndComments();
+            parts++;
+        }
+        const _else = this.parseElse();
+        if (_else === null) {
+            throw new Error('Expected ELSE');
+        }
+        else {
+            _case.addChild(_else);
+        }
+        this.expectAndSkipWhitespaceAndComments();
+        if (!this.token.isEnd()) {
+            throw new Error('Expected END');
+        }
+        this.setNextToken();
+        return _case;
+    }
+    parseWhen() {
+        if (!this.token.isWhen()) {
+            return null;
+        }
+        this.setNextToken();
+        const when = new when_1.default();
+        this.expectAndSkipWhitespaceAndComments();
+        const expression = this.parseExpression();
+        if (expression === null) {
+            throw new Error('Expected expression');
+        }
+        when.addChild(expression);
+        return when;
+    }
+    parseThen() {
+        if (!this.token.isThen()) {
+            return null;
+        }
+        this.setNextToken();
+        const then = new then_1.default();
+        this.expectAndSkipWhitespaceAndComments();
+        const expression = this.parseExpression();
+        if (expression === null) {
+            throw new Error('Expected expression');
+        }
+        then.addChild(expression);
+        return then;
+    }
+    parseElse() {
+        if (!this.token.isElse()) {
+            return null;
+        }
+        this.setNextToken();
+        const _else = new else_1.default();
+        this.expectAndSkipWhitespaceAndComments();
+        const expression = this.parseExpression();
+        if (expression === null) {
+            throw new Error('Expected expression');
+        }
+        _else.addChild(expression);
+        return _else;
+    }
+    parseAlias() {
+        this.skipWhitespaceAndComments();
+        if (!this.token.isAs()) {
+            return null;
+        }
+        this.expectPreviousTokenToBeWhitespaceOrComment();
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        if ((!this.token.isIdentifier() && !this.token.isKeyword()) || this.token.value === null) {
+            throw new Error('Expected identifier');
+        }
+        const alias = new alias_1.default(this.token.value || '');
+        this.setNextToken();
+        return alias;
+    }
+    parseFunction() {
+        var _a;
+        if (!this.token.isIdentifier()) {
+            return null;
+        }
+        if (this.token.value === null) {
+            throw new Error('Expected identifier');
+        }
+        if (!((_a = this.peek()) === null || _a === void 0 ? void 0 : _a.isLeftParenthesis())) {
+            return null;
+        }
+        const func = function_factory_1.default.create(this.token.value);
+        if (func instanceof aggregate_function_1.default && this.context.containsType(aggregate_function_1.default)) {
+            throw new Error('Aggregate functions cannot be nested');
+        }
+        this.context.push(func);
+        this.setNextToken();
+        this.setNextToken();
+        this.skipWhitespaceAndComments();
+        if (this.token.isDistinct()) {
+            func.distinct = true;
+            this.setNextToken();
+            this.expectAndSkipWhitespaceAndComments();
+        }
+        func.parameters = Array.from(this.parseExpressions(alias_option_1.AliasOption.NOT_ALLOWED));
+        this.skipWhitespaceAndComments();
+        if (!this.token.isRightParenthesis()) {
+            throw new Error('Expected right parenthesis');
+        }
+        this.setNextToken();
+        this.context.pop();
+        return func;
+    }
+    /**
+     * Parses an async function call for use in LOAD operations.
+     * Only matches if the identifier is registered as an async data provider.
+     *
+     * @returns An AsyncFunction node if a registered async function is found, otherwise null
+     */
+    parseAsyncFunction() {
+        var _a;
+        if (!this.token.isIdentifier()) {
+            return null;
+        }
+        if (this.token.value === null) {
+            return null;
+        }
+        // Only parse as async function if it's registered as an async provider
+        if (!function_factory_1.default.isAsyncProvider(this.token.value)) {
+            return null;
+        }
+        if (!((_a = this.peek()) === null || _a === void 0 ? void 0 : _a.isLeftParenthesis())) {
+            return null;
+        }
+        const asyncFunc = new async_function_1.default(this.token.value);
+        this.setNextToken(); // skip function name
+        this.setNextToken(); // skip left parenthesis
+        this.skipWhitespaceAndComments();
+        asyncFunc.parameters = Array.from(this.parseExpressions(alias_option_1.AliasOption.NOT_ALLOWED));
+        this.skipWhitespaceAndComments();
+        if (!this.token.isRightParenthesis()) {
+            throw new Error('Expected right parenthesis');
+        }
+        this.setNextToken();
+        return asyncFunc;
+    }
+    parsePredicateFunction() {
+        if (!this.ahead([token_1.default.IDENTIFIER(""), token_1.default.LEFT_PARENTHESIS, token_1.default.IDENTIFIER(""), token_1.default.IN])) {
+            return null;
+        }
+        if (this.token.value === null) {
+            throw new Error('Expected identifier');
+        }
+        const func = predicate_function_factory_1.default.create(this.token.value);
+        this.setNextToken();
+        if (!this.token.isLeftParenthesis()) {
+            throw new Error('Expected left parenthesis');
+        }
+        this.setNextToken();
+        this.skipWhitespaceAndComments();
+        if (!this.token.isIdentifier()) {
+            throw new Error('Expected identifier');
+        }
+        const reference = new reference_1.default(this.token.value);
+        this.variables.set(reference.identifier, reference);
+        func.addChild(reference);
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        if (!this.token.isIn()) {
+            throw new Error('Expected IN');
+        }
+        this.setNextToken();
+        this.expectAndSkipWhitespaceAndComments();
+        const expression = this.parseExpression();
+        if (expression === null) {
+            throw new Error('Expected expression');
+        }
+        if (!object_utils_1.default.isInstanceOfAny(expression.firstChild(), [json_array_1.default, reference_1.default, lookup_1.default, function_1.default])) {
+            throw new Error('Expected array or reference');
+        }
+        func.addChild(expression);
+        this.skipWhitespaceAndComments();
+        if (!this.token.isPipe()) {
+            throw new Error('Expected pipe');
+        }
+        this.setNextToken();
+        const _return = this.parseExpression();
+        if (_return === null) {
+            throw new Error('Expected expression');
+        }
+        func.addChild(_return);
+        const where = this.parseWhere();
+        if (where !== null) {
+            func.addChild(where);
+        }
+        this.skipWhitespaceAndComments();
+        if (!this.token.isRightParenthesis()) {
+            throw new Error('Expected right parenthesis');
+        }
+        this.setNextToken();
+        this.variables.delete(reference.identifier);
+        return func;
+    }
+    parseFString() {
+        if (!this.token.isFString()) {
+            return null;
+        }
+        const f_string = new f_string_1.default();
+        while (this.token.isFString()) {
+            if (this.token.value !== null) {
+                f_string.addChild(new string_1.default(this.token.value));
+            }
+            this.setNextToken();
+            if (this.token.isOpeningBrace()) {
+                this.setNextToken();
+                const expression = this.parseExpression();
+                if (expression === null) {
+                    throw new Error('Expected expression');
+                }
+                f_string.addChild(expression);
+                if (!this.token.isClosingBrace()) {
+                    throw new Error('Expected closing brace');
+                }
+                this.setNextToken();
+            }
+            else {
+                break;
+            }
+        }
+        return f_string;
+    }
+    parseJSON() {
+        if (this.token.isOpeningBrace()) {
+            const array = this.parseAssociativeArray();
+            if (array === null) {
+                throw new Error('Expected associative array');
+            }
+            return array;
+        }
+        else if (this.token.isOpeningBracket()) {
+            const array = this.parseJSONArray();
+            if (array === null) {
+                throw new Error('Expected JSON array');
+            }
+            return array;
+        }
+        throw new Error('Expected opening brace or bracket');
+    }
+    parseAssociativeArray() {
+        if (!this.token.isOpeningBrace()) {
+            return null;
+        }
+        const array = new associative_array_1.default();
+        this.setNextToken();
+        while (true) {
+            this.skipWhitespaceAndComments();
+            if (this.token.isClosingBrace()) {
+                break;
+            }
+            if (!this.token.isIdentifier() && !this.token.isKeyword()) {
+                throw new Error('Expected identifier');
+            }
+            const key = this.token.value;
+            if (key === null) {
+                throw new Error('Expected string');
+            }
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            if (!this.token.isColon()) {
+                throw new Error('Expected colon');
+            }
+            this.setNextToken();
+            this.skipWhitespaceAndComments();
+            const value = this.parseExpression();
+            if (value === null) {
+                throw new Error('Expected expression');
+            }
+            array.addKeyValue(new key_value_pair_1.default(key, value));
+            this.skipWhitespaceAndComments();
+            if (this.token.isComma()) {
+                this.setNextToken();
+            }
+        }
+        this.setNextToken();
+        return array;
+    }
+    parseJSONArray() {
+        if (!this.token.isOpeningBracket()) {
+            return null;
+        }
+        const array = new json_array_1.default();
+        this.setNextToken();
+        while (true) {
+            this.skipWhitespaceAndComments();
+            if (this.token.isClosingBracket()) {
+                break;
+            }
+            const value = this.parseExpression();
+            if (value === null) {
+                throw new Error('Expected expression');
+            }
+            array.addValue(value);
+            this.skipWhitespaceAndComments();
+            if (this.token.isComma()) {
+                this.setNextToken();
+            }
+        }
+        this.setNextToken();
+        return array;
+    }
+    expectAndSkipWhitespaceAndComments() {
+        const skipped = this.skipWhitespaceAndComments();
+        if (!skipped) {
+            throw new Error('Expected whitespace or comment');
+        }
+    }
+    skipWhitespaceAndComments() {
+        let skipped = this.previousToken.isWhitespaceOrComment();
+        while (this.token.isWhitespace() || this.token.isComment()) {
+            this.setNextToken();
+            skipped = true;
+        }
+        return skipped;
+    }
+    expectPreviousTokenToBeWhitespaceOrComment() {
+        if (!this.previousToken.isWhitespaceOrComment()) {
+            throw new Error('Expected whitespace or comment');
+        }
+    }
+}
+exports.default = Parser;
+//# sourceMappingURL=parser.js.map