@aeriajs/compiler 0.0.4 → 0.0.6

package/dist/parser.js

@@ -0,0 +1,907 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.locationMap = void 0;
+const token_js_1 = require("./token.js");
+const types_1 = require("@aeriajs/types");
+const core_1 = require("@phosphor-icons/core");
+const diagnostic_js_1 = require("./diagnostic.js");
+const AST = __importStar(require("./ast.js"));
+const guards = __importStar(require("./guards.js"));
+const lexer = __importStar(require("./lexer.js"));
+const MAX_ERROR_MESSAGE_ITEMS = 20;
+const ICON_NAMES = core_1.icons.map((icon) => icon.name);
+exports.locationMap = new WeakMap();
+const isFileProperty = (property) => {
+    return property.$ref === 'File';
+};
+const parse = (tokens) => {
+    let index = 0;
+    const ast = {
+        kind: 'program',
+        collections: [],
+        contracts: [],
+        functionsets: [],
+    };
+    const errors = [];
+    const advance = () => index++;
+    const next = () => {
+        const token = tokens[index + 1];
+        if (!token) {
+            throw new diagnostic_js_1.Diagnostic('unexpected EOF', current().location);
+        }
+        return token;
+    };
+    const previous = () => {
+        const token = tokens[index - 1];
+        if (!token) {
+            throw new diagnostic_js_1.Diagnostic('invalid position');
+        }
+        return token;
+    };
+    const current = () => {
+        const token = tokens[index];
+        if (!token) {
+            throw new diagnostic_js_1.Diagnostic('unexpected EOF', previous().location);
+        }
+        return token;
+    };
+    const foldBrackets = () => {
+        if (match(token_js_1.TokenType.LeftBracket)) {
+            advance();
+            while (!match(token_js_1.TokenType.RightBracket)) {
+                foldBrackets();
+                advance();
+            }
+        }
+    };
+    const match = (expected, value) => {
+        const token = current();
+        if (token.type === expected) {
+            if (value !== undefined) {
+                return Array.isArray(value)
+                    ? value.includes(token.value)
+                    : token.value === value;
+            }
+            return true;
+        }
+        return false;
+    };
+    const consume = (expected, value) => {
+        const token = current();
+        if (match(expected, value)) {
+            advance();
+            return token;
+        }
+        let expectedValue;
+        if (value) {
+            expectedValue = Array.isArray(value)
+                ? value.slice(0, MAX_ERROR_MESSAGE_ITEMS).map((elem) => `"${elem}"`).join(' | ')
+                : `"${value}"`;
+        }
+        if (Array.isArray(value) && value.length > MAX_ERROR_MESSAGE_ITEMS) {
+            expectedValue += ' | ...';
+        }
+        throw new diagnostic_js_1.Diagnostic(expectedValue
+            ? `expected ${expected} with value ${expectedValue} but found ${token.type} with value "${token.value}" instead`
+            : `expected ${expected} but found ${token.type} instead`, token.location);
+    };
+    const recover = (keywords) => {
+        let token;
+        while (token = tokens[++index]) {
+            if (token.type === token_js_1.TokenType.Keyword && keywords.includes(token.value)) {
+                break;
+            }
+        }
+    };
+    const parseArray = (type) => {
+        consume(token_js_1.TokenType.LeftSquareBracket);
+        const array = [];
+        while (!match(token_js_1.TokenType.RightSquareBracket)) {
+            const { value } = consume(type);
+            array.push(value);
+            if (match(token_js_1.TokenType.Comma)) {
+                consume(token_js_1.TokenType.Comma);
+            }
+        }
+        consume(token_js_1.TokenType.RightSquareBracket);
+        return array;
+    };
+    const parseArrayBlock = (value) => {
+        const array = [];
+        const symbols = [];
+        consume(token_js_1.TokenType.LeftBracket);
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            const { value: identifier, location } = consume(token_js_1.TokenType.Identifier, value);
+            const elemSymbol = Symbol();
+            array.push(identifier);
+            symbols.push(elemSymbol);
+            exports.locationMap.set(elemSymbol, location);
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return {
+            value: array,
+            symbols,
+        };
+    };
+    const parseArrayBlockWithAttributes = () => {
+        const array = {};
+        let hasAttributes = false;
+        consume(token_js_1.TokenType.LeftBracket);
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            const { value: identifier } = consume(token_js_1.TokenType.Identifier);
+            array[identifier] = {};
+            while (match(token_js_1.TokenType.AttributeName)) {
+                hasAttributes = true;
+                const { value: attributeName } = consume(token_js_1.TokenType.AttributeName);
+                if (match(token_js_1.TokenType.LeftParens)) {
+                    consume(token_js_1.TokenType.LeftParens);
+                    consume(token_js_1.TokenType.RightParens);
+                }
+                else {
+                    array[identifier][attributeName] = true;
+                }
+            }
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return hasAttributes
+            ? array
+            : Object.keys(array);
+    };
+    const parsePropertyAttributeValue = (attributeName, property, location) => {
+        const consumeBoolean = () => {
+            if (match(token_js_1.TokenType.Boolean)) {
+                const { value } = consume(token_js_1.TokenType.Boolean);
+                return value;
+            }
+            return true;
+        };
+        if ('enum' in property && attributeName === 'values') {
+            property.enum = parseArray(token_js_1.TokenType.QuotedString);
+            return;
+        }
+        switch (attributeName) {
+            case 'icon': {
+                const { value } = consume(token_js_1.TokenType.QuotedString, ICON_NAMES);
+                property[attributeName] = value;
+                return;
+            }
+            case 'hint':
+            case 'description': {
+                const { value } = consume(token_js_1.TokenType.QuotedString);
+                property[attributeName] = value;
+                return;
+            }
+        }
+        if ('$ref' in property) {
+            switch (attributeName) {
+                case 'purge':
+                case 'inline': {
+                    property[attributeName] = consumeBoolean();
+                    return;
+                }
+                case 'select':
+                case 'form':
+                case 'populate':
+                case 'indexes': {
+                    property[attributeName] = parseArray(token_js_1.TokenType.Identifier);
+                    return;
+                }
+                case 'populateDepth': {
+                    const { value } = consume(token_js_1.TokenType.Number);
+                    property[attributeName] = value;
+                    return;
+                }
+            }
+            if (isFileProperty(property)) {
+                switch (attributeName) {
+                    case 'extensions':
+                    case 'accept': {
+                        property[attributeName] = parseArray(token_js_1.TokenType.QuotedString);
+                        return;
+                    }
+                }
+            }
+        }
+        if ('type' in property) {
+            switch (property.type) {
+                case 'string': {
+                    switch (attributeName) {
+                        case 'format': {
+                            const { value } = consume(token_js_1.TokenType.QuotedString, types_1.PROPERTY_FORMATS);
+                            property[attributeName] = value;
+                            return;
+                        }
+                        case 'mask': {
+                            if (match(token_js_1.TokenType.LeftSquareBracket)) {
+                                property[attributeName] = parseArray(token_js_1.TokenType.QuotedString);
+                                return;
+                            }
+                            else {
+                                const { value } = consume(token_js_1.TokenType.QuotedString);
+                                property[attributeName] = value;
+                                return;
+                            }
+                        }
+                        case 'maskedValue': {
+                            const { value } = consume(token_js_1.TokenType.Boolean);
+                            property[attributeName] = value;
+                            return;
+                        }
+                        case 'minLength':
+                        case 'maxLength': {
+                            const { value } = consume(token_js_1.TokenType.Number);
+                            property[attributeName] = value;
+                            return;
+                        }
+                        case 'inputType': {
+                            const { value } = consume(token_js_1.TokenType.QuotedString, types_1.PROPERTY_INPUT_TYPES);
+                            property[attributeName] = value;
+                            return;
+                        }
+                        case 'element': {
+                            const { value } = consume(token_js_1.TokenType.QuotedString, types_1.PROPERTY_INPUT_ELEMENTS);
+                            property[attributeName] = value;
+                            return;
+                        }
+                        case 'placeholder': {
+                            const { value } = consume(token_js_1.TokenType.QuotedString);
+                            property[attributeName] = value;
+                            return;
+                        }
+                    }
+                    break;
+                }
+                case 'integer':
+                case 'number': {
+                    switch (attributeName) {
+                        case 'exclusiveMinimum':
+                        case 'exclusiveMaximum':
+                        case 'minimum':
+                        case 'maximum': {
+                            const { value } = consume(token_js_1.TokenType.Number);
+                            property[attributeName] = value;
+                            return;
+                        }
+                        case 'placeholder': {
+                            const { value } = consume(token_js_1.TokenType.QuotedString);
+                            property[attributeName] = value;
+                            return;
+                        }
+                    }
+                    break;
+                }
+                case 'array': {
+                    switch (attributeName) {
+                        case 'uniqueItems': {
+                            const { value } = consume(token_js_1.TokenType.Boolean);
+                            property[attributeName] = value;
+                            return;
+                        }
+                        case 'element': {
+                            const { value } = consume(token_js_1.TokenType.QuotedString, types_1.PROPERTY_ARRAY_ELEMENTS);
+                            property[attributeName] = value;
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        throw new diagnostic_js_1.Diagnostic(`invalid attribute name "${attributeName}"`, location);
+    };
+    const parsePropertyType = (options = {
+        allowModifiers: false,
+    }) => {
+        let property;
+        let nestedProperties;
+        let modifierToken;
+        if (match(token_js_1.TokenType.LeftSquareBracket)) {
+            consume(token_js_1.TokenType.LeftSquareBracket);
+            const arrayProperty = {
+                type: 'array',
+            };
+            while (!match(token_js_1.TokenType.RightSquareBracket)) {
+                const attributeSymbol = Symbol();
+                arrayProperty[AST.LOCATION_SYMBOL] ??= {
+                    attributes: {},
+                    arrays: {},
+                };
+                if (match(token_js_1.TokenType.Range)) {
+                    const { value: rangeSeparator } = consume(token_js_1.TokenType.Range);
+                    let attributeName;
+                    const minItems = rangeSeparator[0];
+                    if (!isNaN(minItems)) {
+                        attributeName = 'minItems';
+                        arrayProperty[attributeName] = minItems,
+                            arrayProperty[AST.LOCATION_SYMBOL].attributes[attributeName] = attributeSymbol;
+                    }
+                    const maxItems = rangeSeparator[1];
+                    if (!isNaN(maxItems)) {
+                        attributeName = 'maxItems';
+                        arrayProperty[attributeName] = maxItems;
+                        arrayProperty[AST.LOCATION_SYMBOL].attributes[attributeName] = attributeSymbol;
+                    }
+                    continue;
+                }
+                const { value: attributeName, location } = consume(token_js_1.TokenType.AttributeName);
+                if (match(token_js_1.TokenType.LeftParens)) {
+                    consume(token_js_1.TokenType.LeftParens);
+                    exports.locationMap.set(attributeSymbol, next().location);
+                    arrayProperty[AST.LOCATION_SYMBOL].attributes[attributeName] = attributeSymbol;
+                    parsePropertyAttributeValue(attributeName, arrayProperty, location);
+                    consume(token_js_1.TokenType.RightParens);
+                }
+                else {
+                    parsePropertyAttributeValue(attributeName, arrayProperty, location);
+                }
+            }
+            consume(token_js_1.TokenType.RightSquareBracket);
+            const { property: items, nestedProperties } = parsePropertyType(options);
+            property = {
+                ...arrayProperty,
+                items,
+            };
+            return {
+                kind: 'property',
+                property,
+                nestedProperties,
+            };
+        }
+        if (options.allowModifiers) {
+            const nextToken = next();
+            const currentTokenValue = current().value;
+            if (match(token_js_1.TokenType.Identifier) && typeof currentTokenValue === 'string' && guards.isValidPropertyModifier(currentTokenValue) && (nextToken.type === token_js_1.TokenType.LeftBracket || nextToken.type === token_js_1.TokenType.Identifier)) {
+                modifierToken = consume(token_js_1.TokenType.Identifier);
+            }
+        }
+        if (match(token_js_1.TokenType.LeftBracket)) {
+            consume(token_js_1.TokenType.LeftBracket);
+            property = {
+                type: 'object',
+                properties: {},
+                [AST.LOCATION_SYMBOL]: {
+                    attributes: {},
+                    arrays: {},
+                },
+            };
+            while (!match(token_js_1.TokenType.RightBracket)) {
+                const { value: keyword, location } = current();
+                switch (keyword) {
+                    case 'writable':
+                    case 'required': {
+                        consume(token_js_1.TokenType.Keyword);
+                        const { value, symbols } = parseArrayBlock();
+                        property[keyword] = value;
+                        property[AST.LOCATION_SYMBOL].arrays[keyword] = symbols;
+                        break;
+                    }
+                    case 'properties': {
+                        consume(token_js_1.TokenType.Keyword);
+                        nestedProperties = parsePropertiesBlock(options);
+                        break;
+                    }
+                    default:
+                        throw new diagnostic_js_1.Diagnostic(`invalid keyword "${keyword}"`, location);
+                }
+            }
+            consume(token_js_1.TokenType.RightBracket);
+        }
+        else {
+            const { value: identifier, location } = consume(token_js_1.TokenType.Identifier);
+            if (guards.isNativePropertyType(identifier)) {
+                switch (identifier) {
+                    case 'enum': {
+                        property = {
+                            enum: [],
+                        };
+                        break;
+                    }
+                    case 'date': {
+                        property = {
+                            type: 'string',
+                            format: 'date',
+                        };
+                        break;
+                    }
+                    case 'datetime': {
+                        property = {
+                            type: 'string',
+                            format: 'date-time',
+                        };
+                        break;
+                    }
+                    default:
+                        property = {
+                            type: AST.PropertyType[identifier],
+                        };
+                }
+            }
+            else {
+                const collection = ast.collections.find((node) => node.name === identifier);
+                if (!collection) {
+                    throw new diagnostic_js_1.Diagnostic(`invalid reference "${identifier}"`, location);
+                }
+                property = {
+                    $ref: identifier,
+                };
+            }
+        }
+        while (match(token_js_1.TokenType.AttributeName)) {
+            const { value: attributeName, location } = consume(token_js_1.TokenType.AttributeName);
+            if (match(token_js_1.TokenType.LeftParens)) {
+                consume(token_js_1.TokenType.LeftParens);
+                const attributeSymbol = Symbol();
+                exports.locationMap.set(attributeSymbol, next().location);
+                property[AST.LOCATION_SYMBOL] ??= {
+                    attributes: {},
+                    arrays: {},
+                };
+                property[AST.LOCATION_SYMBOL].attributes[attributeName] = attributeSymbol;
+                parsePropertyAttributeValue(attributeName, property, location);
+                consume(token_js_1.TokenType.RightParens);
+            }
+            else {
+                parsePropertyAttributeValue(attributeName, property, location);
+            }
+        }
+        const node = {
+            kind: 'property',
+            property,
+            nestedProperties,
+        };
+        if (modifierToken) {
+            node.modifier = modifierToken.value;
+        }
+        return node;
+    };
+    const parsePropertiesBlock = (options = {
+        allowModifiers: false,
+    }) => {
+        consume(token_js_1.TokenType.LeftBracket);
+        const properties = {};
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            try {
+                const { value: propName } = consume(token_js_1.TokenType.Identifier);
+                properties[propName] = parsePropertyType(options);
+                if (match(token_js_1.TokenType.Comma)) {
+                    consume(token_js_1.TokenType.Comma);
+                }
+            }
+            catch (err) {
+                if (err instanceof diagnostic_js_1.Diagnostic) {
+                    errors.push(err);
+                    recoverLoop: for (;;) {
+                        switch (current().type) {
+                            case token_js_1.TokenType.RightBracket:
+                            case token_js_1.TokenType.Identifier: {
+                                break recoverLoop;
+                            }
+                        }
+                        while (match(token_js_1.TokenType.AttributeName)) {
+                            advance();
+                            if (match(token_js_1.TokenType.LeftParens)) {
+                                advance();
+                                while (!match(token_js_1.TokenType.RightParens)) {
+                                    advance();
+                                }
+                            }
+                        }
+                        advance();
+                        foldBrackets();
+                    }
+                    continue;
+                }
+            }
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return properties;
+    };
+    const parseMultiplePropertyTypes = (options = {
+        allowModifiers: false,
+    }) => {
+        if (match(token_js_1.TokenType.Pipe)) {
+            consume(token_js_1.TokenType.Pipe);
+            const properties = [];
+            while (index < tokens.length) {
+                properties.push(parsePropertyType(options));
+                if (match(token_js_1.TokenType.Pipe)) {
+                    consume(token_js_1.TokenType.Pipe);
+                }
+                else {
+                    break;
+                }
+            }
+            return properties;
+        }
+        return parsePropertyType(options);
+    };
+    const parseCollection = (ast) => {
+        consume(token_js_1.TokenType.Keyword, 'collection');
+        const { value: name } = consume(token_js_1.TokenType.Identifier);
+        const node = {
+            kind: 'collection',
+            name,
+            properties: {},
+            [AST.LOCATION_SYMBOL]: {
+                arrays: {},
+            },
+        };
+        if (match(token_js_1.TokenType.Keyword, 'extends')) {
+            consume(token_js_1.TokenType.Keyword);
+            const { value: packageName } = consume(token_js_1.TokenType.Identifier);
+            consume(token_js_1.TokenType.Dot);
+            const { value: symbolName } = consume(token_js_1.TokenType.Identifier);
+            node.extends = {
+                packageName,
+                symbolName: symbolName[0].toLowerCase() + symbolName.slice(1),
+            };
+        }
+        consume(token_js_1.TokenType.LeftBracket);
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            const { value: keyword } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_KEYWORDS);
+            try {
+                switch (keyword) {
+                    case 'owned': {
+                        if (match(token_js_1.TokenType.QuotedString, [
+                            'always',
+                            'on-write',
+                        ])) {
+                            node.owned = consume(token_js_1.TokenType.QuotedString).value;
+                        }
+                        break;
+                    }
+                    case 'icon': {
+                        const { value } = consume(token_js_1.TokenType.QuotedString, ICON_NAMES);
+                        node.icon = value;
+                        break;
+                    }
+                    case 'properties': {
+                        node.properties = parsePropertiesBlock();
+                        break;
+                    }
+                    case 'functions': {
+                        node.functions = parseFunctionsBlock(ast);
+                        break;
+                    }
+                    case 'individualActions':
+                    case 'actions': {
+                        node[keyword] = parseActionsBlock();
+                        break;
+                    }
+                    case 'required': {
+                        node.required = parseArrayBlockWithAttributes();
+                        break;
+                    }
+                    case 'presets': {
+                        const { value, symbols } = parseArrayBlock(types_1.DESCRIPTION_PRESETS);
+                        node[keyword] = value;
+                        node[AST.LOCATION_SYMBOL].arrays[keyword] = symbols;
+                        break;
+                    }
+                    case 'indexes':
+                    case 'form':
+                    case 'table':
+                    case 'filters': {
+                        const { value, symbols } = parseArrayBlock();
+                        node[keyword] = value;
+                        node[AST.LOCATION_SYMBOL].arrays[keyword] = symbols;
+                        break;
+                    }
+                    case 'search': {
+                        node[keyword] = parseSearchBlock();
+                        break;
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof diagnostic_js_1.Diagnostic) {
+                    errors.push(err);
+                    recover(lexer.COLLECTION_KEYWORDS);
+                    continue;
+                }
+            }
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return node;
+    };
+    const parseContract = () => {
+        consume(token_js_1.TokenType.Keyword, 'contract');
+        const { value: name } = consume(token_js_1.TokenType.Identifier);
+        consume(token_js_1.TokenType.LeftBracket);
+        const node = {
+            kind: 'contract',
+            name,
+        };
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            const { value: keyword } = consume(token_js_1.TokenType.Keyword, lexer.CONTRACT_KEYWORDS);
+            switch (keyword) {
+                case 'payload': {
+                    node.payload = parsePropertyType({
+                        allowModifiers: true,
+                    });
+                    break;
+                }
+                case 'query': {
+                    node.query = parsePropertyType({
+                        allowModifiers: true,
+                    });
+                    break;
+                }
+                case 'response': {
+                    node.response = parseMultiplePropertyTypes({
+                        allowModifiers: true,
+                    });
+                    break;
+                }
+            }
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return node;
+    };
+    const parseFunctionsBlock = (ast) => {
+        consume(token_js_1.TokenType.LeftBracket);
+        const functions = {};
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            if (match(token_js_1.TokenType.MacroName)) {
+                const { value: macroName } = consume(token_js_1.TokenType.MacroName, ['include']);
+                switch (macroName) {
+                    case 'include': {
+                        const { value: functionSetName, location } = consume(token_js_1.TokenType.Identifier);
+                        const functionset = ast.functionsets.find((node) => node.name === functionSetName);
+                        if (!functionset) {
+                            throw new diagnostic_js_1.Diagnostic(`functionset "${functionSetName}" not found`, location);
+                        }
+                        Object.assign(functions, functionset.functions);
+                        consume(token_js_1.TokenType.RightParens);
+                    }
+                }
+                continue;
+            }
+            const { value: functionName } = consume(token_js_1.TokenType.Identifier);
+            functions[functionName] = {
+                accessCondition: false,
+            };
+            while (match(token_js_1.TokenType.AttributeName, 'expose')) {
+                consume(token_js_1.TokenType.AttributeName, 'expose');
+                if (match(token_js_1.TokenType.LeftParens)) {
+                    consume(token_js_1.TokenType.LeftParens);
+                    if (match(token_js_1.TokenType.Boolean)) {
+                        const { value } = consume(token_js_1.TokenType.Boolean);
+                        functions[functionName] = {
+                            accessCondition: value,
+                        };
+                    }
+                    else if (match(token_js_1.TokenType.QuotedString, [
+                        'unauthenticated',
+                        'unauthenticated-only',
+                    ])) {
+                        const { value } = consume(token_js_1.TokenType.QuotedString, [
+                            'unauthenticated',
+                            'unauthenticated-only',
+                        ]);
+                        functions[functionName] = {
+                            accessCondition: value,
+                        };
+                    }
+                    else {
+                        const value = parseArray(token_js_1.TokenType.QuotedString);
+                        functions[functionName] = {
+                            accessCondition: value,
+                        };
+                    }
+                    consume(token_js_1.TokenType.RightParens);
+                }
+                else {
+                    functions[functionName] = {
+                        accessCondition: true,
+                    };
+                }
+            }
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return functions;
+    };
+    const parseFunctionSet = (ast) => {
+        consume(token_js_1.TokenType.Keyword, 'functionset');
+        const { value: name } = consume(token_js_1.TokenType.Identifier);
+        const node = {
+            kind: 'functionset',
+            name,
+            functions: parseFunctionsBlock(ast),
+        };
+        return node;
+    };
+    const parseActionsBlock = () => {
+        const actions = {};
+        consume(token_js_1.TokenType.LeftBracket);
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            const { value: actionName } = consume(token_js_1.TokenType.Identifier);
+            consume(token_js_1.TokenType.LeftBracket);
+            const baseSlots = {};
+            const slots = {
+                route: {
+                    route: {
+                        name: '',
+                    },
+                },
+                function: {},
+                event: {},
+            };
+            let actionType;
+            while (!match(token_js_1.TokenType.RightBracket)) {
+                const { value: keyword } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_ACTIONS_KEYWORDS);
+                switch (keyword) {
+                    case 'icon': {
+                        const { value } = consume(token_js_1.TokenType.QuotedString, ICON_NAMES);
+                        baseSlots[keyword] = value;
+                        break;
+                    }
+                    case 'label': {
+                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        baseSlots[keyword] = value;
+                        break;
+                    }
+                    case 'ask':
+                    case 'button':
+                    case 'translate': {
+                        const { value } = consume(token_js_1.TokenType.Boolean);
+                        baseSlots[keyword] = value;
+                        break;
+                    }
+                    case 'roles':
+                    case 'requires': {
+                        const value = parseArray(token_js_1.TokenType.Identifier);
+                        baseSlots[keyword] = value;
+                        break;
+                    }
+                    case 'route': {
+                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        actionType = 'route';
+                        slots.route.route.name = value;
+                        break;
+                    }
+                    case 'setItem':
+                    case 'fetchItem':
+                    case 'clearItem': {
+                        const { value } = consume(token_js_1.TokenType.Boolean);
+                        slots.route.route[keyword] = value;
+                        break;
+                    }
+                    case 'function': {
+                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        actionType = 'function';
+                        slots.function.function = value;
+                        break;
+                    }
+                    case 'effect': {
+                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        slots.function.effect = value;
+                        break;
+                    }
+                    case 'selection': {
+                        const { value } = consume(token_js_1.TokenType.Boolean);
+                        slots.function.selection = value;
+                        break;
+                    }
+                    case 'event': {
+                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        actionType = 'event';
+                        slots.event.event = value;
+                        break;
+                    }
+                }
+            }
+            if (actionType) {
+                actions[actionName] = {
+                    ...baseSlots,
+                    ...slots[actionType],
+                };
+            }
+            else {
+                actions[actionName] = baseSlots;
+            }
+            consume(token_js_1.TokenType.RightBracket);
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return actions;
+    };
+    const parseSearchBlock = () => {
+        const searchSlots = {};
+        const { location } = consume(token_js_1.TokenType.LeftBracket);
+        while (!match(token_js_1.TokenType.RightBracket)) {
+            const { value: keyword } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_SEARCH_KEYWORDS);
+            switch (keyword) {
+                case 'placeholder': {
+                    const { value } = consume(token_js_1.TokenType.QuotedString);
+                    searchSlots[keyword] = value;
+                    break;
+                }
+                case 'exactMatches': {
+                    const { value } = consume(token_js_1.TokenType.Boolean);
+                    searchSlots[keyword] = value;
+                    break;
+                }
+                case 'indexes': {
+                    const { value } = parseArrayBlock();
+                    searchSlots[keyword] = value;
+                    break;
+                }
+            }
+        }
+        const { indexes } = searchSlots;
+        if (!indexes) {
+            throw new diagnostic_js_1.Diagnostic('"indexes" option is required', location);
+        }
+        consume(token_js_1.TokenType.RightBracket);
+        return {
+            ...searchSlots,
+            indexes,
+        };
+    };
+    while (index < tokens.length) {
+        const { value: declType, location } = current();
+        try {
+            switch (declType) {
+                case 'collection': {
+                    ast.collections.push(parseCollection(ast));
+                    break;
+                }
+                case 'contract': {
+                    ast.contracts.push(parseContract());
+                    break;
+                }
+                case 'functionset': {
+                    ast.functionsets.push(parseFunctionSet(ast));
+                    break;
+                }
+                default:
+                    throw new diagnostic_js_1.Diagnostic(`invalid declaration type: "${declType}"`, location);
+            }
+        }
+        catch (err) {
+            if (err instanceof diagnostic_js_1.Diagnostic) {
+                errors.push(err);
+                recover(lexer.TOPLEVEL_KEYWORDS);
+                continue;
+            }
+            throw err;
+        }
+    }
+    return {
+        ast,
+        errors,
+    };
+};
+exports.parse = parse;