@aeriajs/compiler 0.0.4 → 0.0.6

package/dist/parser.mjs

@@ -0,0 +1,851 @@
+"use strict";
+import { TokenType } from "./token.mjs";
+import { DESCRIPTION_PRESETS, PROPERTY_ARRAY_ELEMENTS, PROPERTY_FORMATS, PROPERTY_INPUT_ELEMENTS, PROPERTY_INPUT_TYPES } from "@aeriajs/types";
+import { icons } from "@phosphor-icons/core";
+import { Diagnostic } from "./diagnostic.mjs";
+import * as AST from "./ast.mjs";
+import * as guards from "./guards.mjs";
+import * as lexer from "./lexer.mjs";
+const MAX_ERROR_MESSAGE_ITEMS = 20;
+const ICON_NAMES = icons.map((icon) => icon.name);
+export const locationMap = /* @__PURE__ */ new WeakMap();
+const isFileProperty = (property) => {
+  return property.$ref === "File";
+};
+export 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("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 = (type) => {
+    consume(TokenType.LeftSquareBracket);
+    const array = [];
+    while (!match(TokenType.RightSquareBracket)) {
+      const { value } = consume(type);
+      array.push(value);
+      if (match(TokenType.Comma)) {
+        consume(TokenType.Comma);
+      }
+    }
+    consume(TokenType.RightSquareBracket);
+    return array;
+  };
+  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);
+    }
+    consume(TokenType.RightBracket);
+    return {
+      value: array,
+      symbols
+    };
+  };
+  const parseArrayBlockWithAttributes = () => {
+    const array = {};
+    let hasAttributes = false;
+    consume(TokenType.LeftBracket);
+    while (!match(TokenType.RightBracket)) {
+      const { value: identifier } = consume(TokenType.Identifier);
+      array[identifier] = {};
+      while (match(TokenType.AttributeName)) {
+        hasAttributes = true;
+        const { value: attributeName } = consume(TokenType.AttributeName);
+        if (match(TokenType.LeftParens)) {
+          consume(TokenType.LeftParens);
+          consume(TokenType.RightParens);
+        } else {
+          array[identifier][attributeName] = true;
+        }
+      }
+    }
+    consume(TokenType.RightBracket);
+    return hasAttributes ? array : Object.keys(array);
+  };
+  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);
+      return;
+    }
+    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;
+      }
+    }
+    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);
+          return;
+        }
+        case "populateDepth": {
+          const { value } = consume(TokenType.Number);
+          property[attributeName] = value;
+          return;
+        }
+      }
+      if (isFileProperty(property)) {
+        switch (attributeName) {
+          case "extensions":
+          case "accept": {
+            property[attributeName] = parseArray(TokenType.QuotedString);
+            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);
+                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 modifierToken;
+    if (match(TokenType.LeftSquareBracket)) {
+      consume(TokenType.LeftSquareBracket);
+      const arrayProperty = {
+        type: "array"
+      };
+      while (!match(TokenType.RightSquareBracket)) {
+        const attributeSymbol = Symbol();
+        arrayProperty[AST.LOCATION_SYMBOL] ??= {
+          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
+      };
+      return {
+        kind: "property",
+        property,
+        nestedProperties: nestedProperties2
+      };
+    }
+    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.Identifier)) {
+        modifierToken = consume(TokenType.Identifier);
+      }
+    }
+    if (match(TokenType.LeftBracket)) {
+      consume(TokenType.LeftBracket);
+      property = {
+        type: "object",
+        properties: {},
+        [AST.LOCATION_SYMBOL]: {
+          attributes: {},
+          arrays: {}
+        }
+      };
+      while (!match(TokenType.RightBracket)) {
+        const { value: keyword, location } = current();
+        switch (keyword) {
+          case "writable":
+          case "required": {
+            consume(TokenType.Keyword);
+            const { value, symbols } = parseArrayBlock();
+            property[keyword] = value;
+            property[AST.LOCATION_SYMBOL].arrays[keyword] = symbols;
+            break;
+          }
+          case "properties": {
+            consume(TokenType.Keyword);
+            nestedProperties = parsePropertiesBlock(options);
+            break;
+          }
+          default:
+            throw new Diagnostic(`invalid keyword "${keyword}"`, location);
+        }
+      }
+      consume(TokenType.RightBracket);
+    } else {
+      const { value: identifier, location } = consume(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((node2) => node2.name === identifier);
+        if (!collection) {
+          throw new Diagnostic(`invalid reference "${identifier}"`, location);
+        }
+        property = {
+          $ref: identifier
+        };
+      }
+    }
+    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] ??= {
+          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
+    };
+    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;
+        }
+      }
+    }
+    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 parseCollection = (ast2) => {
+    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 } = consume(TokenType.Identifier);
+      consume(TokenType.Dot);
+      const { value: symbolName } = consume(TokenType.Identifier);
+      node.extends = {
+        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 "owned": {
+            if (match(TokenType.QuotedString, [
+              "always",
+              "on-write"
+            ])) {
+              node.owned = consume(TokenType.QuotedString).value;
+            }
+            break;
+          }
+          case "icon": {
+            const { value } = consume(TokenType.QuotedString, ICON_NAMES);
+            node.icon = value;
+            break;
+          }
+          case "properties": {
+            node.properties = parsePropertiesBlock();
+            break;
+          }
+          case "functions": {
+            node.functions = parseFunctionsBlock(ast2);
+            break;
+          }
+          case "individualActions":
+          case "actions": {
+            node[keyword] = parseActionsBlock();
+            break;
+          }
+          case "required": {
+            node.required = parseArrayBlockWithAttributes();
+            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 "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) {
+          errors.push(err);
+          recover(lexer.COLLECTION_KEYWORDS);
+          continue;
+        }
+      }
+    }
+    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 "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 = (ast2) => {
+    consume(TokenType.LeftBracket);
+    const functions = {};
+    while (!match(TokenType.RightBracket)) {
+      if (match(TokenType.MacroName)) {
+        const { value: macroName } = consume(TokenType.MacroName, ["include"]);
+        switch (macroName) {
+          case "include": {
+            const { value: functionSetName, location } = consume(TokenType.Identifier);
+            const functionset = ast2.functionsets.find((node) => node.name === functionSetName);
+            if (!functionset) {
+              throw new Diagnostic(`functionset "${functionSetName}" not found`, location);
+            }
+            Object.assign(functions, functionset.functions);
+            consume(TokenType.RightParens);
+          }
+        }
+        continue;
+      }
+      const { value: functionName } = consume(TokenType.Identifier);
+      functions[functionName] = {
+        accessCondition: false
+      };
+      while (match(TokenType.AttributeName, "expose")) {
+        consume(TokenType.AttributeName, "expose");
+        if (match(TokenType.LeftParens)) {
+          consume(TokenType.LeftParens);
+          if (match(TokenType.Boolean)) {
+            const { value } = consume(TokenType.Boolean);
+            functions[functionName] = {
+              accessCondition: value
+            };
+          } else if (match(TokenType.QuotedString, [
+            "unauthenticated",
+            "unauthenticated-only"
+          ])) {
+            const { value } = consume(TokenType.QuotedString, [
+              "unauthenticated",
+              "unauthenticated-only"
+            ]);
+            functions[functionName] = {
+              accessCondition: value
+            };
+          } else {
+            const value = parseArray(TokenType.QuotedString);
+            functions[functionName] = {
+              accessCondition: value
+            };
+          }
+          consume(TokenType.RightParens);
+        } else {
+          functions[functionName] = {
+            accessCondition: true
+          };
+        }
+      }
+    }
+    consume(TokenType.RightBracket);
+    return functions;
+  };
+  const parseFunctionSet = (ast2) => {
+    consume(TokenType.Keyword, "functionset");
+    const { value: name } = consume(TokenType.Identifier);
+    const node = {
+      kind: "functionset",
+      name,
+      functions: parseFunctionsBlock(ast2)
+    };
+    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":
+          case "requires": {
+            const value = parseArray(TokenType.Identifier);
+            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);
+    while (!match(TokenType.RightBracket)) {
+      const { value: keyword } = consume(TokenType.Keyword, lexer.COLLECTION_SEARCH_KEYWORDS);
+      switch (keyword) {
+        case "placeholder": {
+          const { value } = consume(TokenType.QuotedString);
+          searchSlots[keyword] = value;
+          break;
+        }
+        case "exactMatches": {
+          const { value } = consume(TokenType.Boolean);
+          searchSlots[keyword] = value;
+          break;
+        }
+        case "indexes": {
+          const { value } = parseArrayBlock();
+          searchSlots[keyword] = value;
+          break;
+        }
+      }
+    }
+    const { indexes } = searchSlots;
+    if (!indexes) {
+      throw new Diagnostic('"indexes" option is required', location);
+    }
+    consume(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(`invalid declaration type: "${declType}"`, location);
+      }
+    } catch (err) {
+      if (err instanceof Diagnostic) {
+        errors.push(err);
+        recover(lexer.TOPLEVEL_KEYWORDS);
+        continue;
+      }
+      throw err;
+    }
+  }
+  return {
+    ast,
+    errors
+  };
+};