@aeriajs/compiler 0.0.61 → 0.0.63

package/dist/parser.mjs

@@ -1,1297 +0,0 @@
-"use strict";
-import { DESCRIPTION_PRESETS, LAYOUT_NAMES, PROPERTY_ARRAY_ELEMENTS, PROPERTY_FORMATS, PROPERTY_INPUT_ELEMENTS, PROPERTY_INPUT_TYPES } from "@aeriajs/types";
-import { icons } from "@phosphor-icons/core";
-import * as AST from "./ast.mjs";
-import * as guards from "./guards.mjs";
-import * as lexer from "./lexer.mjs";
-import { TokenType } from "./token.mjs";
-import { Diagnostic } from "./diagnostic.mjs";
-import { DEFAULT_EXPORT_SYMBOLS } from "./utils.mjs";
-const MAX_ERROR_MESSAGE_ITEMS = 20;
-const ICON_NAMES = icons.map((icon) => icon.name);
-export const locationMap = /* @__PURE__ */ new WeakMap();
-export const memoTable = {
-  defaultExportSymbols: DEFAULT_EXPORT_SYMBOLS
-};
-const isFileProperty = (property) => {
-  return property.$ref === "File";
-};
-const checkForValidRoles = (roles, symbols) => {
-  if (memoTable.roles) {
-    for (const [i, role] of roles.entries()) {
-      const symbol = symbols[i];
-      if (!memoTable.roles.includes(role)) {
-        const location = locationMap.get(symbol);
-        throw new Diagnostic(`invalid role "${role}"`, location);
-      }
-    }
-  }
-  return roles;
-};
-export const parse = (tokens) => {
-  let index = 0;
-  const ast = {
-    kind: "program",
-    collections: [],
-    contracts: [],
-    functionsets: []
-  };
-  const errors = [];
-  const advance = () => index++;
-  const rollback = () => index--;
-  const next = () => {
-    const token = tokens[index + 1];
-    if (!token) {
-      throw new Diagnostic("unexpected EOF", current().location);
-    }
-    return token;
-  };
-  const previous = () => {
-    const token = tokens[index - 1];
-    if (!token) {
-      throw new Diagnostic("invalid position");
-    }
-    return token;
-  };
-  const current = () => {
-    const token = tokens[index];
-    if (!token) {
-      throw new Diagnostic("unexpected EOF", previous().location);
-    }
-    return token;
-  };
-  const foldBrackets = () => {
-    if (match(TokenType.LeftBracket)) {
-      advance();
-      while (!match(TokenType.RightBracket)) {
-        foldBrackets();
-        advance();
-      }
-    }
-  };
-  const match = (expected, value) => {
-    const token = current();
-    if (token.type === expected) {
-      if (value !== void 0) {
-        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(
-      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 === TokenType.Keyword && keywords.includes(token.value)) {
-        break;
-      }
-    }
-  };
-  const parseArray = (types) => {
-    const array = [];
-    const symbols = [];
-    const { location: openingLocation } = consume(TokenType.LeftSquareBracket);
-    if (match(TokenType.RightSquareBracket)) {
-      consume(TokenType.RightSquareBracket);
-      return {
-        value: [],
-        symbols: []
-      };
-    }
-    let type;
-    for (const typeCandidate of types) {
-      if (match(typeCandidate)) {
-        type = typeCandidate;
-        break;
-      }
-    }
-    if (!type) {
-      throw new Diagnostic(`array got an invalid type, accepted ones are: ${types.join(" | ")}`, openingLocation);
-    }
-    while (!match(TokenType.RightSquareBracket)) {
-      const { value, location } = consume(type);
-      const elemSymbol = Symbol();
-      array.push(value);
-      symbols.push(elemSymbol);
-      locationMap.set(elemSymbol, location);
-      if (match(TokenType.Comma)) {
-        consume(TokenType.Comma);
-      }
-    }
-    consume(TokenType.RightSquareBracket);
-    return {
-      value: array,
-      symbols
-    };
-  };
-  const parseArrayBlock = (value) => {
-    const array = [];
-    const symbols = [];
-    consume(TokenType.LeftBracket);
-    while (!match(TokenType.RightBracket)) {
-      const { value: identifier, location } = consume(TokenType.Identifier, value);
-      const elemSymbol = Symbol();
-      array.push(identifier);
-      symbols.push(elemSymbol);
-      locationMap.set(elemSymbol, location);
-      if (match(TokenType.Comma)) {
-        consume(TokenType.Comma);
-      }
-    }
-    consume(TokenType.RightBracket);
-    return {
-      value: array,
-      symbols
-    };
-  };
-  const parseArrayBlockWithAttributes = (allowedAttributes, cb) => {
-    const array = {};
-    const symbols = [];
-    let hasAttributes = false;
-    consume(TokenType.LeftBracket);
-    while (!match(TokenType.RightBracket)) {
-      const { value: identifier, location } = consume(TokenType.Identifier);
-      array[identifier] = true;
-      const elemSymbol = Symbol();
-      symbols.push(elemSymbol);
-      locationMap.set(elemSymbol, location);
-      if (match(TokenType.AttributeName)) {
-        hasAttributes = true;
-      }
-      while (match(TokenType.AttributeName)) {
-        array[identifier] = {};
-        const { value: attributeName } = consume(TokenType.AttributeName, allowedAttributes);
-        cb(attributeName, array, identifier);
-      }
-    }
-    consume(TokenType.RightBracket);
-    const value = hasAttributes ? array : Object.keys(array);
-    return {
-      value,
-      symbols
-    };
-  };
-  const parsePropertyAttributeValue = (attributeName, property, location) => {
-    const consumeBoolean = () => {
-      if (match(TokenType.Boolean)) {
-        const { value } = consume(TokenType.Boolean);
-        return value;
-      }
-      return true;
-    };
-    if ("enum" in property && attributeName === "values") {
-      property.enum = parseArray([
-        TokenType.QuotedString,
-        TokenType.Number
-      ]).value;
-      return;
-    }
-    if ("const" in property && attributeName === "value") {
-      const token = current();
-      advance();
-      switch (token.type) {
-        case TokenType.Number:
-        case TokenType.Boolean:
-        case TokenType.Null:
-        case TokenType.QuotedString: {
-          property.const = token.value;
-          return;
-        }
-        default: {
-          throw new Diagnostic(`const received invalid value: "${token.value}"`, location);
-        }
-      }
-    }
-    switch (attributeName) {
-      case "icon": {
-        const { value } = consume(TokenType.QuotedString, ICON_NAMES);
-        property[attributeName] = value;
-        return;
-      }
-      case "hint":
-      case "description": {
-        const { value } = consume(TokenType.QuotedString);
-        property[attributeName] = value;
-        return;
-      }
-      case "hidden":
-      case "translate": {
-        property[attributeName] = consumeBoolean();
-        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([TokenType.Identifier]).value;
-          return;
-        }
-        case "populateDepth": {
-          const { value } = consume(TokenType.Number);
-          property[attributeName] = value;
-          return;
-        }
-        case "constraints": {
-          const constraintTerms = [];
-          rollback();
-          property[attributeName] = parseCondition(constraintTerms);
-          property[AST.LOCATION_SYMBOL].contraintTerms = constraintTerms;
-          rollback();
-          return;
-        }
-      }
-      if (isFileProperty(property)) {
-        switch (attributeName) {
-          case "extensions":
-          case "accept": {
-            property[attributeName] = parseArray([TokenType.QuotedString]).value;
-            return;
-          }
-        }
-      }
-    }
-    if ("type" in property) {
-      switch (property.type) {
-        case "string": {
-          switch (attributeName) {
-            case "format": {
-              const { value } = consume(TokenType.QuotedString, PROPERTY_FORMATS);
-              property[attributeName] = value;
-              return;
-            }
-            case "mask": {
-              if (match(TokenType.LeftSquareBracket)) {
-                property[attributeName] = parseArray([TokenType.QuotedString]).value;
-                return;
-              } else {
-                const { value } = consume(TokenType.QuotedString);
-                property[attributeName] = value;
-                return;
-              }
-            }
-            case "maskedValue": {
-              const { value } = consume(TokenType.Boolean);
-              property[attributeName] = value;
-              return;
-            }
-            case "minLength":
-            case "maxLength": {
-              const { value } = consume(TokenType.Number);
-              property[attributeName] = value;
-              return;
-            }
-            case "inputType": {
-              const { value } = consume(TokenType.QuotedString, PROPERTY_INPUT_TYPES);
-              property[attributeName] = value;
-              return;
-            }
-            case "element": {
-              const { value } = consume(TokenType.QuotedString, PROPERTY_INPUT_ELEMENTS);
-              property[attributeName] = value;
-              return;
-            }
-            case "placeholder": {
-              const { value } = consume(TokenType.QuotedString);
-              property[attributeName] = value;
-              return;
-            }
-          }
-          break;
-        }
-        case "integer":
-        case "number": {
-          switch (attributeName) {
-            case "exclusiveMinimum":
-            case "exclusiveMaximum":
-            case "minimum":
-            case "maximum": {
-              const { value } = consume(TokenType.Number);
-              property[attributeName] = value;
-              return;
-            }
-            case "placeholder": {
-              const { value } = consume(TokenType.QuotedString);
-              property[attributeName] = value;
-              return;
-            }
-          }
-          break;
-        }
-        case "array": {
-          switch (attributeName) {
-            case "uniqueItems": {
-              const { value } = consume(TokenType.Boolean);
-              property[attributeName] = value;
-              return;
-            }
-            case "element": {
-              const { value } = consume(TokenType.QuotedString, PROPERTY_ARRAY_ELEMENTS);
-              property[attributeName] = value;
-              return;
-            }
-          }
-        }
-      }
-    }
-    throw new Diagnostic(`invalid attribute name "${attributeName}"`, location);
-  };
-  const parsePropertyType = (options = {
-    allowModifiers: false
-  }) => {
-    let property;
-    let nestedProperties;
-    let nestedAdditionalProperties;
-    let modifierToken;
-    const typeSymbol = Symbol();
-    if (options.allowModifiers) {
-      const nextToken = next();
-      const currentTokenValue = current().value;
-      if (match(TokenType.Identifier) && typeof currentTokenValue === "string" && guards.isValidPropertyModifier(currentTokenValue) && (nextToken.type === TokenType.LeftBracket || nextToken.type === TokenType.LeftSquareBracket || nextToken.type === TokenType.Identifier)) {
-        modifierToken = consume(TokenType.Identifier);
-      }
-    }
-    if (match(TokenType.LeftSquareBracket)) {
-      consume(TokenType.LeftSquareBracket);
-      const arrayProperty = {
-        type: "array"
-      };
-      while (!match(TokenType.RightSquareBracket)) {
-        const attributeSymbol = Symbol();
-        arrayProperty[AST.LOCATION_SYMBOL] ??= {
-          type: typeSymbol,
-          attributes: {},
-          arrays: {}
-        };
-        if (match(TokenType.Range)) {
-          const { value: rangeSeparator } = consume(TokenType.Range);
-          let attributeName2;
-          const minItems = rangeSeparator[0];
-          if (!isNaN(minItems)) {
-            attributeName2 = "minItems";
-            arrayProperty[attributeName2] = minItems, arrayProperty[AST.LOCATION_SYMBOL].attributes[attributeName2] = attributeSymbol;
-          }
-          const maxItems = rangeSeparator[1];
-          if (!isNaN(maxItems)) {
-            attributeName2 = "maxItems";
-            arrayProperty[attributeName2] = maxItems;
-            arrayProperty[AST.LOCATION_SYMBOL].attributes[attributeName2] = attributeSymbol;
-          }
-          continue;
-        }
-        const { value: attributeName, location } = consume(TokenType.AttributeName);
-        if (match(TokenType.LeftParens)) {
-          consume(TokenType.LeftParens);
-          locationMap.set(attributeSymbol, next().location);
-          arrayProperty[AST.LOCATION_SYMBOL].attributes[attributeName] = attributeSymbol;
-          parsePropertyAttributeValue(attributeName, arrayProperty, location);
-          consume(TokenType.RightParens);
-        } else {
-          parsePropertyAttributeValue(attributeName, arrayProperty, location);
-        }
-      }
-      consume(TokenType.RightSquareBracket);
-      const { property: items, nestedProperties: nestedProperties2 } = parsePropertyType(options);
-      property = {
-        ...arrayProperty,
-        items
-      };
-      locationMap.set(typeSymbol, current().location);
-      return {
-        kind: "property",
-        property,
-        nestedProperties: nestedProperties2
-      };
-    }
-    locationMap.set(typeSymbol, current().location);
-    if (match(TokenType.LeftBracket)) {
-      consume(TokenType.LeftBracket);
-      property = {
-        type: "object",
-        properties: {},
-        [AST.LOCATION_SYMBOL]: {
-          type: typeSymbol,
-          attributes: {},
-          arrays: {}
-        }
-      };
-      while (!match(TokenType.RightBracket)) {
-        const { value: keyword, location } = consume(TokenType.Keyword, lexer.COLLECTION_KEYWORDS);
-        switch (keyword) {
-          case "writable":
-          case "required": {
-            const { value, symbols } = parseArrayBlock();
-            property[keyword] = value;
-            property[AST.LOCATION_SYMBOL].arrays[keyword] = symbols;
-            break;
-          }
-          case "properties": {
-            nestedProperties = parsePropertiesBlock(options);
-            break;
-          }
-          case "additionalProperties": {
-            if (match(TokenType.Boolean)) {
-              nestedAdditionalProperties = consume(TokenType.Boolean).value;
-            } else {
-              nestedAdditionalProperties = parsePropertyType();
-            }
-            break;
-          }
-          default:
-            throw new Diagnostic(`invalid keyword "${keyword}"`, location);
-        }
-      }
-      consume(TokenType.RightBracket);
-    } else {
-      const { value: identifier } = consume(TokenType.Identifier);
-      if (guards.isNativePropertyType(identifier)) {
-        switch (identifier) {
-          case "enum": {
-            property = {
-              enum: []
-            };
-            break;
-          }
-          case "const": {
-            property = {
-              const: null
-            };
-            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 {
-        property = {
-          $ref: identifier,
-          [AST.LOCATION_SYMBOL]: {
-            type: typeSymbol,
-            attributes: {},
-            arrays: {}
-          }
-        };
-      }
-    }
-    while (match(TokenType.AttributeName)) {
-      const { value: attributeName, location } = consume(TokenType.AttributeName);
-      if (match(TokenType.LeftParens)) {
-        consume(TokenType.LeftParens);
-        const attributeSymbol = Symbol();
-        locationMap.set(attributeSymbol, next().location);
-        property[AST.LOCATION_SYMBOL] ??= {
-          type: typeSymbol,
-          attributes: {},
-          arrays: {}
-        };
-        property[AST.LOCATION_SYMBOL].attributes[attributeName] = attributeSymbol;
-        parsePropertyAttributeValue(attributeName, property, location);
-        consume(TokenType.RightParens);
-      } else {
-        parsePropertyAttributeValue(attributeName, property, location);
-      }
-    }
-    const node = {
-      kind: "property",
-      property,
-      nestedProperties,
-      nestedAdditionalProperties
-    };
-    if (modifierToken) {
-      node.modifier = modifierToken.value;
-    }
-    return node;
-  };
-  const parsePropertiesBlock = (options = {
-    allowModifiers: false
-  }) => {
-    consume(TokenType.LeftBracket);
-    const properties = {};
-    while (!match(TokenType.RightBracket)) {
-      try {
-        const { value: propName } = consume(TokenType.Identifier);
-        properties[propName] = parsePropertyType(options);
-        if (match(TokenType.Comma)) {
-          consume(TokenType.Comma);
-        }
-      } catch (err) {
-        if (err instanceof Diagnostic) {
-          errors.push(err);
-          recoverLoop: for (; ; ) {
-            switch (current().type) {
-              case TokenType.RightBracket:
-              case TokenType.Identifier: {
-                break recoverLoop;
-              }
-            }
-            while (match(TokenType.AttributeName)) {
-              advance();
-              if (match(TokenType.LeftParens)) {
-                advance();
-                while (!match(TokenType.RightParens)) {
-                  advance();
-                }
-              }
-            }
-            advance();
-            foldBrackets();
-          }
-          continue;
-        }
-        throw err;
-      }
-    }
-    consume(TokenType.RightBracket);
-    return properties;
-  };
-  const parseMultiplePropertyTypes = (options = {
-    allowModifiers: false
-  }) => {
-    if (match(TokenType.Pipe)) {
-      consume(TokenType.Pipe);
-      const properties = [];
-      while (index < tokens.length) {
-        properties.push(parsePropertyType(options));
-        if (match(TokenType.Pipe)) {
-          consume(TokenType.Pipe);
-        } else {
-          break;
-        }
-      }
-      return properties;
-    }
-    return parsePropertyType(options);
-  };
-  const parseAccessCondition = (options = {
-    arrayBlock: false
-  }) => {
-    if (match(TokenType.Boolean)) {
-      const { value } = consume(TokenType.Boolean);
-      return value;
-    } else if (match(TokenType.QuotedString, [
-      "unauthenticated",
-      "unauthenticated-only"
-    ])) {
-      const { value } = consume(TokenType.QuotedString, [
-        "unauthenticated",
-        "unauthenticated-only"
-      ]);
-      return value;
-    } else {
-      const { value, symbols } = options.arrayBlock ? parseArrayBlock() : parseArray([TokenType.QuotedString]);
-      return checkForValidRoles(value, symbols);
-    }
-  };
-  const parseCollection = () => {
-    consume(TokenType.Keyword, "collection");
-    const { value: name } = consume(TokenType.Identifier);
-    const node = {
-      kind: "collection",
-      name,
-      properties: {},
-      [AST.LOCATION_SYMBOL]: {
-        arrays: {}
-      }
-    };
-    if (match(TokenType.Keyword, "extends")) {
-      consume(TokenType.Keyword);
-      const { value: packageName } = match(TokenType.QuotedString) ? consume(TokenType.QuotedString) : consume(TokenType.Identifier);
-      consume(TokenType.Dot);
-      const { value: symbolName } = consume(TokenType.Identifier);
-      node.extends = {
-        packageName,
-        importPath: packageName,
-        symbolName: symbolName[0].toLowerCase() + symbolName.slice(1)
-      };
-    }
-    consume(TokenType.LeftBracket);
-    while (!match(TokenType.RightBracket)) {
-      const { value: keyword } = consume(TokenType.Keyword, lexer.COLLECTION_KEYWORDS);
-      try {
-        switch (keyword) {
-          case "middlewares": {
-            node.middlewares = parseArrayBlock().value;
-            break;
-          }
-          case "owned": {
-            if (match(TokenType.Boolean)) {
-              node.owned = consume(TokenType.Boolean).value;
-            } else {
-              node.owned = consume(TokenType.QuotedString, [
-                "always",
-                "on-write"
-              ]).value;
-            }
-            break;
-          }
-          case "icon": {
-            const { value } = consume(TokenType.QuotedString, ICON_NAMES);
-            node[keyword] = value;
-            break;
-          }
-          case "properties": {
-            node[keyword] = parsePropertiesBlock();
-            break;
-          }
-          case "functions": {
-            const { functions, functionSets } = parseFunctionsBlock();
-            node.functions = functions;
-            node.functionSets = functionSets;
-            break;
-          }
-          case "individualActions":
-          case "actions": {
-            node[keyword] = parseActionsBlock();
-            break;
-          }
-          case "required": {
-            const { value, symbols } = parseArrayBlockWithAttributes(["if"], (attributeName, array, identifier) => {
-              switch (attributeName) {
-                case "if": {
-                  const ifTerms = [];
-                  array[identifier] = parseCondition(ifTerms);
-                  node[AST.LOCATION_SYMBOL].requiredTerms = ifTerms;
-                  break;
-                }
-              }
-            });
-            node.required = value;
-            node[AST.LOCATION_SYMBOL].required = symbols;
-            break;
-          }
-          case "presets": {
-            const { value, symbols } = parseArrayBlock(DESCRIPTION_PRESETS);
-            node[keyword] = value;
-            node[AST.LOCATION_SYMBOL].arrays[keyword] = symbols;
-            break;
-          }
-          case "indexes":
-          case "form":
-          case "table":
-          case "tableMeta":
-          case "unique":
-          case "filters": {
-            const { value, symbols } = parseArrayBlock();
-            node[keyword] = value;
-            node[AST.LOCATION_SYMBOL].arrays[keyword] = symbols;
-            break;
-          }
-          case "search": {
-            const { options, indexesSymbols } = parseSearchBlock();
-            node[keyword] = options;
-            node[AST.LOCATION_SYMBOL].searchIndexes = indexesSymbols;
-            break;
-          }
-          case "layout": {
-            node[keyword] = parseLayoutBlock();
-            break;
-          }
-          case "formLayout": {
-            node[keyword] = parseFormLayoutBlock();
-            break;
-          }
-        }
-      } catch (err) {
-        if (err instanceof Diagnostic) {
-          errors.push(err);
-          recover(lexer.COLLECTION_KEYWORDS);
-          continue;
-        }
-        throw err;
-      }
-    }
-    consume(TokenType.RightBracket);
-    return node;
-  };
-  const parseContract = () => {
-    consume(TokenType.Keyword, "contract");
-    const { value: name } = consume(TokenType.Identifier);
-    consume(TokenType.LeftBracket);
-    const node = {
-      kind: "contract",
-      name
-    };
-    while (!match(TokenType.RightBracket)) {
-      const { value: keyword } = consume(TokenType.Keyword, lexer.CONTRACT_KEYWORDS);
-      switch (keyword) {
-        case "roles": {
-          node.roles = parseAccessCondition({
-            arrayBlock: true
-          });
-          break;
-        }
-        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(TokenType.RightBracket);
-    return node;
-  };
-  const parseFunctionsBlock = () => {
-    consume(TokenType.LeftBracket);
-    const functions = [];
-    const functionSets = [];
-    while (!match(TokenType.RightBracket)) {
-      try {
-        if (match(TokenType.MacroName)) {
-          const { value: macroName } = consume(TokenType.MacroName, ["include"]);
-          switch (macroName) {
-            case "include": {
-              const { value: functionSetName, location } = consume(TokenType.Identifier);
-              const functionSetSymbol = Symbol();
-              locationMap.set(functionSetSymbol, location);
-              functionSets.push([
-                functionSetName,
-                functionSetSymbol
-              ]);
-              consume(TokenType.RightParens);
-              break;
-            }
-          }
-          continue;
-        }
-        let functionNode;
-        if (current().type === TokenType.Identifier && next().type === TokenType.Dot) {
-          const { value: packageName } = match(TokenType.QuotedString) ? consume(TokenType.QuotedString) : consume(TokenType.Identifier);
-          consume(TokenType.Dot);
-          const { value: symbolName } = consume(TokenType.Identifier);
-          functionNode = {
-            kind: "function",
-            name: symbolName,
-            exportSymbol: {
-              packageName,
-              importPath: packageName,
-              symbolName
-            }
-          };
-        } else {
-          const { value: functionName } = consume(TokenType.Identifier);
-          let exportSymbol;
-          if (memoTable.defaultExportSymbols && functionName in memoTable.defaultExportSymbols) {
-            const packageName = memoTable.defaultExportSymbols[functionName];
-            exportSymbol = {
-              packageName,
-              importPath: packageName,
-              symbolName: functionName
-            };
-          }
-          functionNode = {
-            kind: "function",
-            name: functionName,
-            exportSymbol
-          };
-        }
-        functions.push(functionNode);
-        while (match(TokenType.AttributeName, "expose")) {
-          consume(TokenType.AttributeName, "expose");
-          if (match(TokenType.LeftParens)) {
-            consume(TokenType.LeftParens);
-            functionNode.accessCondition = parseAccessCondition();
-            consume(TokenType.RightParens);
-          } else {
-            functionNode.accessCondition = true;
-          }
-        }
-      } catch (err) {
-        if (err instanceof Diagnostic) {
-          let token;
-          while (token = tokens[++index]) {
-            if (token.type === TokenType.Identifier || token.type === TokenType.RightBracket) {
-              break;
-            }
-          }
-          errors.push(err);
-          continue;
-        }
-        throw err;
-      }
-    }
-    consume(TokenType.RightBracket);
-    return {
-      functions,
-      functionSets
-    };
-  };
-  const parseFunctionSet = () => {
-    consume(TokenType.Keyword, "functionset");
-    const { value: name } = consume(TokenType.Identifier);
-    const { functions, functionSets } = parseFunctionsBlock();
-    const node = {
-      kind: "functionset",
-      name,
-      functions,
-      functionSets
-    };
-    return node;
-  };
-  const parseActionsBlock = () => {
-    const actions = {};
-    consume(TokenType.LeftBracket);
-    while (!match(TokenType.RightBracket)) {
-      const { value: actionName } = consume(TokenType.Identifier);
-      consume(TokenType.LeftBracket);
-      const baseSlots = {};
-      const slots = {
-        route: {
-          route: {
-            name: ""
-          }
-        },
-        function: {},
-        event: {}
-      };
-      let actionType;
-      while (!match(TokenType.RightBracket)) {
-        const { value: keyword } = consume(TokenType.Keyword, lexer.COLLECTION_ACTIONS_KEYWORDS);
-        switch (keyword) {
-          case "icon": {
-            const { value } = consume(TokenType.QuotedString, ICON_NAMES);
-            baseSlots[keyword] = value;
-            break;
-          }
-          case "label": {
-            const { value } = consume(TokenType.QuotedString);
-            baseSlots[keyword] = value;
-            break;
-          }
-          case "ask":
-          case "button":
-          case "translate": {
-            const { value } = consume(TokenType.Boolean);
-            baseSlots[keyword] = value;
-            break;
-          }
-          case "roles": {
-            const { value, symbols } = parseArray([TokenType.Identifier]);
-            const roles = checkForValidRoles(value, symbols);
-            baseSlots[keyword] = roles;
-            break;
-          }
-          case "requires": {
-            const { value } = parseArrayBlock();
-            baseSlots[keyword] = value;
-            break;
-          }
-          case "route": {
-            const { value } = consume(TokenType.QuotedString);
-            actionType = "route";
-            slots.route.route.name = value;
-            break;
-          }
-          case "setItem":
-          case "fetchItem":
-          case "clearItem": {
-            const { value } = consume(TokenType.Boolean);
-            slots.route.route[keyword] = value;
-            break;
-          }
-          case "function": {
-            const { value } = consume(TokenType.QuotedString);
-            actionType = "function";
-            slots.function.function = value;
-            break;
-          }
-          case "effect": {
-            const { value } = consume(TokenType.QuotedString);
-            slots.function.effect = value;
-            break;
-          }
-          case "selection": {
-            const { value } = consume(TokenType.Boolean);
-            slots.function.selection = value;
-            break;
-          }
-          case "event": {
-            const { value } = consume(TokenType.QuotedString);
-            actionType = "event";
-            slots.event.event = value;
-            break;
-          }
-        }
-      }
-      if (actionType) {
-        actions[actionName] = {
-          ...baseSlots,
-          ...slots[actionType]
-        };
-      } else {
-        actions[actionName] = baseSlots;
-      }
-      consume(TokenType.RightBracket);
-    }
-    consume(TokenType.RightBracket);
-    return actions;
-  };
-  const parseSearchBlock = () => {
-    const searchSlots = {};
-    const { location } = consume(TokenType.LeftBracket);
-    let indexesSymbols;
-    while (!match(TokenType.RightBracket)) {
-      const { value: keyword } = consume(TokenType.Keyword, lexer.COLLECTION_SEARCH_KEYWORDS);
-      switch (keyword) {
-        case "indexes": {
-          const { value, symbols } = parseArrayBlock();
-          searchSlots[keyword] = value;
-          indexesSymbols = symbols;
-          break;
-        }
-        case "placeholder": {
-          const { value } = consume(TokenType.QuotedString);
-          searchSlots[keyword] = value;
-          break;
-        }
-        case "exactMatches": {
-          const { value } = consume(TokenType.Boolean);
-          searchSlots[keyword] = value;
-          break;
-        }
-      }
-    }
-    const { indexes } = searchSlots;
-    if (!indexes) {
-      throw new Diagnostic('"indexes" option is required', location);
-    }
-    consume(TokenType.RightBracket);
-    const options = {
-      ...searchSlots,
-      indexes
-    };
-    return {
-      options,
-      indexesSymbols
-    };
-  };
-  const parseLayoutBlock = () => {
-    let name;
-    const options = {};
-    const optionsSymbols = {};
-    const { location } = consume(TokenType.LeftBracket);
-    while (!match(TokenType.RightBracket)) {
-      const { value: keyword } = consume(TokenType.Keyword, lexer.COLLECTION_LAYOUT_KEYWORDS);
-      switch (keyword) {
-        case "name": {
-          name = consume(TokenType.QuotedString, LAYOUT_NAMES).value;
-          break;
-        }
-        case "options":
-          {
-            consume(TokenType.LeftBracket);
-            while (!match(TokenType.RightBracket)) {
-              const { value: optionsKeyword } = consume(TokenType.Keyword, lexer.COLLECTION_LAYOUT_OPTIONS_KEYWORDS);
-              switch (optionsKeyword) {
-                case "active":
-                case "title":
-                case "picture":
-                case "badge": {
-                  const { value, location: location2 } = consume(TokenType.Identifier);
-                  const symbol = Symbol();
-                  options[optionsKeyword] = value;
-                  optionsSymbols[optionsKeyword] = symbol;
-                  locationMap.set(symbol, location2);
-                  break;
-                }
-                case "information": {
-                  if (match(TokenType.LeftBracket)) {
-                    const { value, symbols } = parseArrayBlock();
-                    options[optionsKeyword] = value;
-                    optionsSymbols[optionsKeyword] = symbols;
-                  } else {
-                    const { value, location: location2 } = consume(TokenType.Identifier);
-                    const symbol = Symbol();
-                    options[optionsKeyword] = value;
-                    optionsSymbols[optionsKeyword] = symbol;
-                    locationMap.set(symbol, location2);
-                  }
-                  break;
-                }
-                case "translateBadge": {
-                  const { value } = consume(TokenType.Boolean);
-                  options[optionsKeyword] = value;
-                  break;
-                }
-              }
-            }
-          }
-          consume(TokenType.RightBracket);
-          break;
-      }
-    }
-    if (!name) {
-      throw new Diagnostic('layout must have a "name" property', location);
-    }
-    consume(TokenType.RightBracket);
-    return {
-      kind: "layout",
-      name,
-      options,
-      [AST.LOCATION_SYMBOL]: {
-        options: optionsSymbols
-      }
-    };
-  };
-  const parseFormLayoutBlock = () => {
-    const fields = {};
-    const node = {
-      kind: "formLayout",
-      fields,
-      [AST.LOCATION_SYMBOL]: {
-        fields: {}
-      }
-    };
-    consume(TokenType.LeftBracket);
-    while (!match(TokenType.RightBracket)) {
-      const { value: keyword, location: keywordLocation } = consume(TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
-      switch (keyword) {
-        case "fields": {
-          consume(TokenType.LeftBracket);
-          while (!match(TokenType.RightBracket)) {
-            const { value: identifier, location: identifierLocation } = consume(TokenType.Identifier);
-            const identifierSymbol = Symbol();
-            locationMap.set(identifierSymbol, identifierLocation);
-            fields[identifier] ??= {};
-            node[AST.LOCATION_SYMBOL].fields[identifier] = {
-              name: identifierSymbol,
-              field: {}
-            };
-            consume(TokenType.LeftBracket);
-            while (!match(TokenType.RightBracket)) {
-              const { value: keyword2, location: keywordLocation2 } = consume(TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
-              switch (keyword2) {
-                case "if": {
-                  const ifTerms = [];
-                  fields[identifier].if = parseCondition(ifTerms);
-                  node[AST.LOCATION_SYMBOL].terms = ifTerms;
-                  break;
-                }
-                case "span":
-                case "verticalSpacing": {
-                  fields[identifier].span = consume(TokenType.Number).value;
-                  break;
-                }
-                case "separator": {
-                  fields[identifier].separator = match(TokenType.Boolean) ? consume(TokenType.Boolean).value : consume(TokenType.QuotedString, [
-                    "top",
-                    "bottom"
-                  ]).value;
-                  break;
-                }
-                default: {
-                  throw new Diagnostic(`invalid keyword "${keyword2}"`, keywordLocation2);
-                }
-              }
-            }
-            consume(TokenType.RightBracket);
-          }
-          consume(TokenType.RightBracket);
-          break;
-        }
-        default: {
-          throw new Diagnostic(`invalid keyword "${keyword}"`, keywordLocation);
-        }
-      }
-    }
-    consume(TokenType.RightBracket);
-    return node;
-  };
-  const parseCondition = (symbols = []) => {
-    if (match(TokenType.LeftParens)) {
-      consume(TokenType.LeftParens);
-      let operatorType, newOp = operatorType;
-      const conditions = [];
-      while (!match(TokenType.RightParens)) {
-        conditions.push(parseCondition(symbols));
-        if (match(TokenType.RightParens)) {
-          break;
-        }
-        const { value: operatorSymbol2, location: location2 } = consume(TokenType.Operator);
-        switch (operatorSymbol2) {
-          case "&&":
-            newOp = "and";
-            break;
-          case "||":
-            newOp = "or";
-            break;
-          default: {
-            throw new Diagnostic(`unsupported operator: "${operatorSymbol2}"`, location2);
-          }
-        }
-        if (operatorType && operatorType !== newOp) {
-          throw new Diagnostic('having "and" or "or" in the same expression is not supported, please use parenthesis', location2);
-        }
-        operatorType = newOp;
-      }
-      consume(TokenType.RightParens);
-      switch (operatorType) {
-        case "and": {
-          return {
-            and: conditions
-          };
-        }
-        case "or": {
-          return {
-            or: conditions
-          };
-        }
-        default: {
-          return conditions[0];
-        }
-      }
-    }
-    if (match(TokenType.Operator, "!")) {
-      consume(TokenType.Operator);
-      return {
-        not: parseCondition(symbols)
-      };
-    }
-    const { value: term1, location: term1Location } = consume(TokenType.Identifier);
-    const term1Symbol = Symbol();
-    locationMap.set(term1Symbol, term1Location);
-    symbols.push([
-      term1,
-      term1Symbol
-    ]);
-    if (!match(TokenType.Operator, lexer.FINAL_OPERATORS)) {
-      return {
-        operator: "truthy",
-        term1
-      };
-    }
-    const { value: operatorSymbol, location } = consume(TokenType.Operator);
-    let term2;
-    if (match(TokenType.LeftParens)) {
-      term2 = parseCondition(symbols);
-    } else if (match(TokenType.LeftSquareBracket)) {
-      term2 = parseArray([
-        TokenType.QuotedString,
-        TokenType.Number
-      ]).value;
-    } else {
-      term2 = current().value;
-      advance();
-    }
-    let operator;
-    switch (operatorSymbol) {
-      case "==":
-        operator = "equal";
-        break;
-      case "in":
-        operator = "in";
-        break;
-      case ">=":
-        operator = "gte";
-        break;
-      case "<=":
-        operator = "lte";
-        break;
-      case ">":
-        operator = "gt";
-        break;
-      case "<":
-        operator = "lt";
-        break;
-      default: {
-        throw new Diagnostic(`unsupported operator: "${operatorSymbol}"`, location);
-      }
-    }
-    return {
-      operator,
-      term1,
-      term2
-    };
-  };
-  while (index < tokens.length) {
-    const { value: declType, location } = current();
-    try {
-      switch (declType) {
-        case "collection": {
-          const collection = parseCollection();
-          if (collection.name === "User") {
-            const { properties } = collection;
-            if ("roles" in properties && "items" in properties.roles.property && "enum" in properties.roles.property.items) {
-              memoTable.roles = properties.roles.property.items.enum;
-            }
-          }
-          ast.collections.push(collection);
-          break;
-        }
-        case "contract": {
-          ast.contracts.push(parseContract());
-          break;
-        }
-        case "functionset": {
-          ast.functionsets.push(parseFunctionSet());
-          break;
-        }
-        default:
-          throw new Diagnostic(`invalid declaration type: "${declType}"`, location);
-      }
-    } catch (err) {
-      if (err instanceof Diagnostic) {
-        errors.push(err);
-        recover(lexer.TOPLEVEL_KEYWORDS);
-        continue;
-      }
-      throw err;
-    }
-  }
-  return {
-    ast,
-    errors
-  };
-};