@aeriajs/compiler 0.0.61 → 0.0.63

package/dist/parser.js

@@ -1,69 +1,33 @@
-"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.memoTable = exports.locationMap = void 0;
-const types_1 = require("@aeriajs/types");
-const core_1 = require("@phosphor-icons/core");
-const AST = __importStar(require("./ast.js"));
-const guards = __importStar(require("./guards.js"));
-const lexer = __importStar(require("./lexer.js"));
-const token_js_1 = require("./token.js");
-const diagnostic_js_1 = require("./diagnostic.js");
-const utils_js_1 = require("./utils.js");
+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.js';
+import * as guards from './guards.js';
+import * as lexer from './lexer.js';
+import { TokenType } from './token.js';
+import { Diagnostic } from './diagnostic.js';
+import { DEFAULT_EXPORT_SYMBOLS } from './utils.js';
 const MAX_ERROR_MESSAGE_ITEMS = 20;
-const ICON_NAMES = core_1.icons.map((icon) => icon.name);
-exports.locationMap = new WeakMap();
-exports.memoTable = {
-    defaultExportSymbols: utils_js_1.DEFAULT_EXPORT_SYMBOLS,
+const ICON_NAMES = icons.map((icon) => icon.name);
+export const locationMap = new WeakMap();
+export const memoTable = {
+    defaultExportSymbols: DEFAULT_EXPORT_SYMBOLS,
 };
 const isFileProperty = (property) => {
     return property.$ref === 'File';
 };
 const checkForValidRoles = (roles, symbols) => {
-    if (exports.memoTable.roles) {
+    if (memoTable.roles) {
         for (const [i, role] of roles.entries()) {
             const symbol = symbols[i];
-            if (!exports.memoTable.roles.includes(role)) {
-                const location = exports.locationMap.get(symbol);
-                throw new diagnostic_js_1.Diagnostic(`invalid role "${role}"`, location);
+            if (!memoTable.roles.includes(role)) {
+                const location = locationMap.get(symbol);
+                throw new Diagnostic(`invalid role "${role}"`, location);
             }
         }
     }
     return roles;
 };
-const parse = (tokens) => {
+export const parse = (tokens) => {
     let index = 0;
     const ast = {
         kind: 'program',
@@ -77,28 +41,28 @@ const parse = (tokens) => {
     const next = () => {
         const token = tokens[index + 1];
         if (!token) {
-            throw new diagnostic_js_1.Diagnostic('unexpected EOF', current().location);
+            throw new Diagnostic('unexpected EOF', current().location);
         }
         return token;
     };
     const previous = () => {
         const token = tokens[index - 1];
         if (!token) {
-            throw new diagnostic_js_1.Diagnostic('invalid position');
+            throw new Diagnostic('invalid position');
         }
         return token;
     };
     const current = () => {
         const token = tokens[index];
         if (!token) {
-            throw new diagnostic_js_1.Diagnostic('unexpected EOF', previous().location);
+            throw new Diagnostic('unexpected EOF', previous().location);
         }
         return token;
     };
     const foldBrackets = () => {
-        if (match(token_js_1.TokenType.LeftBracket)) {
+        if (match(TokenType.LeftBracket)) {
             advance();
-            while (!match(token_js_1.TokenType.RightBracket)) {
+            while (!match(TokenType.RightBracket)) {
                 foldBrackets();
                 advance();
             }
@@ -131,14 +95,14 @@ const parse = (tokens) => {
         if (Array.isArray(value) && value.length > MAX_ERROR_MESSAGE_ITEMS) {
             expectedValue += ' | ...';
         }
-        throw new diagnostic_js_1.Diagnostic(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 === token_js_1.TokenType.Keyword && keywords.includes(token.value)) {
+            if (token.type === TokenType.Keyword && keywords.includes(token.value)) {
                 break;
             }
         }
@@ -146,9 +110,9 @@ const parse = (tokens) => {
     const parseArray = (types) => {
         const array = [];
         const symbols = [];
-        const { location: openingLocation } = consume(token_js_1.TokenType.LeftSquareBracket);
-        if (match(token_js_1.TokenType.RightSquareBracket)) {
-            consume(token_js_1.TokenType.RightSquareBracket);
+        const { location: openingLocation } = consume(TokenType.LeftSquareBracket);
+        if (match(TokenType.RightSquareBracket)) {
+            consume(TokenType.RightSquareBracket);
             return {
                 value: [],
                 symbols: [],
@@ -162,19 +126,19 @@ const parse = (tokens) => {
             }
         }
         if (!type) {
-            throw new diagnostic_js_1.Diagnostic(`array got an invalid type, accepted ones are: ${types.join(' | ')}`, openingLocation);
+            throw new Diagnostic(`array got an invalid type, accepted ones are: ${types.join(' | ')}`, openingLocation);
         }
-        while (!match(token_js_1.TokenType.RightSquareBracket)) {
+        while (!match(TokenType.RightSquareBracket)) {
             const { value, location } = consume(type);
             const elemSymbol = Symbol();
             array.push(value);
             symbols.push(elemSymbol);
-            exports.locationMap.set(elemSymbol, location);
-            if (match(token_js_1.TokenType.Comma)) {
-                consume(token_js_1.TokenType.Comma);
+            locationMap.set(elemSymbol, location);
+            if (match(TokenType.Comma)) {
+                consume(TokenType.Comma);
             }
         }
-        consume(token_js_1.TokenType.RightSquareBracket);
+        consume(TokenType.RightSquareBracket);
         return {
             value: array,
             symbols,
@@ -183,18 +147,18 @@ const parse = (tokens) => {
     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);
+        consume(TokenType.LeftBracket);
+        while (!match(TokenType.RightBracket)) {
+            const { value: identifier, location } = consume(TokenType.Identifier, value);
             const elemSymbol = Symbol();
             array.push(identifier);
             symbols.push(elemSymbol);
-            exports.locationMap.set(elemSymbol, location);
-            if (match(token_js_1.TokenType.Comma)) {
-                consume(token_js_1.TokenType.Comma);
+            locationMap.set(elemSymbol, location);
+            if (match(TokenType.Comma)) {
+                consume(TokenType.Comma);
             }
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         return {
             value: array,
             symbols,
@@ -204,23 +168,23 @@ const parse = (tokens) => {
         const array = {};
         const symbols = [];
         let hasAttributes = false;
-        consume(token_js_1.TokenType.LeftBracket);
-        while (!match(token_js_1.TokenType.RightBracket)) {
-            const { value: identifier, location } = consume(token_js_1.TokenType.Identifier);
+        consume(TokenType.LeftBracket);
+        while (!match(TokenType.RightBracket)) {
+            const { value: identifier, location } = consume(TokenType.Identifier);
             array[identifier] = true;
             const elemSymbol = Symbol();
             symbols.push(elemSymbol);
-            exports.locationMap.set(elemSymbol, location);
-            if (match(token_js_1.TokenType.AttributeName)) {
+            locationMap.set(elemSymbol, location);
+            if (match(TokenType.AttributeName)) {
                 hasAttributes = true;
             }
-            while (match(token_js_1.TokenType.AttributeName)) {
+            while (match(TokenType.AttributeName)) {
                 array[identifier] = {};
-                const { value: attributeName } = consume(token_js_1.TokenType.AttributeName, allowedAttributes);
+                const { value: attributeName } = consume(TokenType.AttributeName, allowedAttributes);
                 cb(attributeName, array, identifier);
             }
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         const value = hasAttributes
             ? array
             : Object.keys(array);
@@ -231,16 +195,16 @@ const parse = (tokens) => {
     };
     const parsePropertyAttributeValue = (attributeName, property, location) => {
         const consumeBoolean = () => {
-            if (match(token_js_1.TokenType.Boolean)) {
-                const { value } = consume(token_js_1.TokenType.Boolean);
+            if (match(TokenType.Boolean)) {
+                const { value } = consume(TokenType.Boolean);
                 return value;
             }
             return true;
         };
         if ('enum' in property && attributeName === 'values') {
             property.enum = parseArray([
-                token_js_1.TokenType.QuotedString,
-                token_js_1.TokenType.Number,
+                TokenType.QuotedString,
+                TokenType.Number,
             ]).value;
             return;
         }
@@ -248,27 +212,27 @@ const parse = (tokens) => {
             const token = current();
             advance();
             switch (token.type) {
-                case token_js_1.TokenType.Number:
-                case token_js_1.TokenType.Boolean:
-                case token_js_1.TokenType.Null:
-                case token_js_1.TokenType.QuotedString: {
+                case TokenType.Number:
+                case TokenType.Boolean:
+                case TokenType.Null:
+                case TokenType.QuotedString: {
                     property.const = token.value;
                     return;
                 }
                 default: {
-                    throw new diagnostic_js_1.Diagnostic(`const received invalid value: "${token.value}"`, location);
+                    throw new Diagnostic(`const received invalid value: "${token.value}"`, location);
                 }
             }
         }
         switch (attributeName) {
             case 'icon': {
-                const { value } = consume(token_js_1.TokenType.QuotedString, ICON_NAMES);
+                const { value } = consume(TokenType.QuotedString, ICON_NAMES);
                 property[attributeName] = value;
                 return;
             }
             case 'hint':
             case 'description': {
-                const { value } = consume(token_js_1.TokenType.QuotedString);
+                const { value } = consume(TokenType.QuotedString);
                 property[attributeName] = value;
                 return;
             }
@@ -289,11 +253,11 @@ const parse = (tokens) => {
                 case 'form':
                 case 'populate':
                 case 'indexes': {
-                    property[attributeName] = parseArray([token_js_1.TokenType.Identifier]).value;
+                    property[attributeName] = parseArray([TokenType.Identifier]).value;
                     return;
                 }
                 case 'populateDepth': {
-                    const { value } = consume(token_js_1.TokenType.Number);
+                    const { value } = consume(TokenType.Number);
                     property[attributeName] = value;
                     return;
                 }
@@ -310,7 +274,7 @@ const parse = (tokens) => {
                 switch (attributeName) {
                     case 'extensions':
                     case 'accept': {
-                        property[attributeName] = parseArray([token_js_1.TokenType.QuotedString]).value;
+                        property[attributeName] = parseArray([TokenType.QuotedString]).value;
                         return;
                     }
                 }
@@ -321,44 +285,44 @@ const parse = (tokens) => {
                 case 'string': {
                     switch (attributeName) {
                         case 'format': {
-                            const { value } = consume(token_js_1.TokenType.QuotedString, types_1.PROPERTY_FORMATS);
+                            const { value } = consume(TokenType.QuotedString, PROPERTY_FORMATS);
                             property[attributeName] = value;
                             return;
                         }
                         case 'mask': {
-                            if (match(token_js_1.TokenType.LeftSquareBracket)) {
-                                property[attributeName] = parseArray([token_js_1.TokenType.QuotedString]).value;
+                            if (match(TokenType.LeftSquareBracket)) {
+                                property[attributeName] = parseArray([TokenType.QuotedString]).value;
                                 return;
                             }
                             else {
-                                const { value } = consume(token_js_1.TokenType.QuotedString);
+                                const { value } = consume(TokenType.QuotedString);
                                 property[attributeName] = value;
                                 return;
                             }
                         }
                         case 'maskedValue': {
-                            const { value } = consume(token_js_1.TokenType.Boolean);
+                            const { value } = consume(TokenType.Boolean);
                             property[attributeName] = value;
                             return;
                         }
                         case 'minLength':
                         case 'maxLength': {
-                            const { value } = consume(token_js_1.TokenType.Number);
+                            const { value } = consume(TokenType.Number);
                             property[attributeName] = value;
                             return;
                         }
                         case 'inputType': {
-                            const { value } = consume(token_js_1.TokenType.QuotedString, types_1.PROPERTY_INPUT_TYPES);
+                            const { value } = consume(TokenType.QuotedString, PROPERTY_INPUT_TYPES);
                             property[attributeName] = value;
                             return;
                         }
                         case 'element': {
-                            const { value } = consume(token_js_1.TokenType.QuotedString, types_1.PROPERTY_INPUT_ELEMENTS);
+                            const { value } = consume(TokenType.QuotedString, PROPERTY_INPUT_ELEMENTS);
                             property[attributeName] = value;
                             return;
                         }
                         case 'placeholder': {
-                            const { value } = consume(token_js_1.TokenType.QuotedString);
+                            const { value } = consume(TokenType.QuotedString);
                             property[attributeName] = value;
                             return;
                         }
@@ -372,12 +336,12 @@ const parse = (tokens) => {
                         case 'exclusiveMaximum':
                         case 'minimum':
                         case 'maximum': {
-                            const { value } = consume(token_js_1.TokenType.Number);
+                            const { value } = consume(TokenType.Number);
                             property[attributeName] = value;
                             return;
                         }
                         case 'placeholder': {
-                            const { value } = consume(token_js_1.TokenType.QuotedString);
+                            const { value } = consume(TokenType.QuotedString);
                             property[attributeName] = value;
                             return;
                         }
@@ -387,12 +351,12 @@ const parse = (tokens) => {
                 case 'array': {
                     switch (attributeName) {
                         case 'uniqueItems': {
-                            const { value } = consume(token_js_1.TokenType.Boolean);
+                            const { value } = consume(TokenType.Boolean);
                             property[attributeName] = value;
                             return;
                         }
                         case 'element': {
-                            const { value } = consume(token_js_1.TokenType.QuotedString, types_1.PROPERTY_ARRAY_ELEMENTS);
+                            const { value } = consume(TokenType.QuotedString, PROPERTY_ARRAY_ELEMENTS);
                             property[attributeName] = value;
                             return;
                         }
@@ -400,7 +364,7 @@ const parse = (tokens) => {
                 }
             }
         }
-        throw new diagnostic_js_1.Diagnostic(`invalid attribute name "${attributeName}"`, location);
+        throw new Diagnostic(`invalid attribute name "${attributeName}"`, location);
     };
     const parsePropertyType = (options = {
         allowModifiers: false,
@@ -413,24 +377,24 @@ const parse = (tokens) => {
         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.LeftSquareBracket || nextToken.type === token_js_1.TokenType.Identifier)) {
-                modifierToken = consume(token_js_1.TokenType.Identifier);
+            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(token_js_1.TokenType.LeftSquareBracket)) {
-            consume(token_js_1.TokenType.LeftSquareBracket);
+        if (match(TokenType.LeftSquareBracket)) {
+            consume(TokenType.LeftSquareBracket);
             const arrayProperty = {
                 type: 'array',
             };
-            while (!match(token_js_1.TokenType.RightSquareBracket)) {
+            while (!match(TokenType.RightSquareBracket)) {
                 const attributeSymbol = Symbol();
                 arrayProperty[AST.LOCATION_SYMBOL] ??= {
                     type: typeSymbol,
                     attributes: {},
                     arrays: {},
                 };
-                if (match(token_js_1.TokenType.Range)) {
-                    const { value: rangeSeparator } = consume(token_js_1.TokenType.Range);
+                if (match(TokenType.Range)) {
+                    const { value: rangeSeparator } = consume(TokenType.Range);
                     let attributeName;
                     const minItems = rangeSeparator[0];
                     if (!isNaN(minItems)) {
@@ -446,34 +410,34 @@ const parse = (tokens) => {
                     }
                     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);
+                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(token_js_1.TokenType.RightParens);
+                    consume(TokenType.RightParens);
                 }
                 else {
                     parsePropertyAttributeValue(attributeName, arrayProperty, location);
                 }
             }
-            consume(token_js_1.TokenType.RightSquareBracket);
+            consume(TokenType.RightSquareBracket);
             const { property: items, nestedProperties } = parsePropertyType(options);
             property = {
                 ...arrayProperty,
                 items,
             };
-            exports.locationMap.set(typeSymbol, current().location);
+            locationMap.set(typeSymbol, current().location);
             return {
                 kind: 'property',
                 property,
                 nestedProperties,
             };
         }
-        exports.locationMap.set(typeSymbol, current().location);
-        if (match(token_js_1.TokenType.LeftBracket)) {
-            consume(token_js_1.TokenType.LeftBracket);
+        locationMap.set(typeSymbol, current().location);
+        if (match(TokenType.LeftBracket)) {
+            consume(TokenType.LeftBracket);
             property = {
                 type: 'object',
                 properties: {},
@@ -483,8 +447,8 @@ const parse = (tokens) => {
                     arrays: {},
                 },
             };
-            while (!match(token_js_1.TokenType.RightBracket)) {
-                const { value: keyword, location } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_KEYWORDS);
+            while (!match(TokenType.RightBracket)) {
+                const { value: keyword, location } = consume(TokenType.Keyword, lexer.COLLECTION_KEYWORDS);
                 switch (keyword) {
                     case 'writable':
                     case 'required': {
@@ -498,8 +462,8 @@ const parse = (tokens) => {
                         break;
                     }
                     case 'additionalProperties': {
-                        if (match(token_js_1.TokenType.Boolean)) {
-                            nestedAdditionalProperties = consume(token_js_1.TokenType.Boolean).value;
+                        if (match(TokenType.Boolean)) {
+                            nestedAdditionalProperties = consume(TokenType.Boolean).value;
                         }
                         else {
                             nestedAdditionalProperties = parsePropertyType();
@@ -507,13 +471,13 @@ const parse = (tokens) => {
                         break;
                     }
                     default:
-                        throw new diagnostic_js_1.Diagnostic(`invalid keyword "${keyword}"`, location);
+                        throw new Diagnostic(`invalid keyword "${keyword}"`, location);
                 }
             }
-            consume(token_js_1.TokenType.RightBracket);
+            consume(TokenType.RightBracket);
         }
         else {
-            const { value: identifier } = consume(token_js_1.TokenType.Identifier);
+            const { value: identifier } = consume(TokenType.Identifier);
             if (guards.isNativePropertyType(identifier)) {
                 switch (identifier) {
                     case 'enum': {
@@ -542,6 +506,13 @@ const parse = (tokens) => {
                         };
                         break;
                     }
+                    case 'objectid': {
+                        property = {
+                            type: 'string',
+                            format: 'objectid',
+                        };
+                        break;
+                    }
                     default:
                         property = {
                             type: AST.PropertyType[identifier],
@@ -559,12 +530,12 @@ const parse = (tokens) => {
                 };
             }
         }
-        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);
+        while (match(TokenType.AttributeName)) {
+            const { value: attributeName, location } = consume(TokenType.AttributeName);
+            if (match(TokenType.LeftParens)) {
+                consume(TokenType.LeftParens);
                 const attributeSymbol = Symbol();
-                exports.locationMap.set(attributeSymbol, next().location);
+                locationMap.set(attributeSymbol, next().location);
                 property[AST.LOCATION_SYMBOL] ??= {
                     type: typeSymbol,
                     attributes: {},
@@ -572,7 +543,7 @@ const parse = (tokens) => {
                 };
                 property[AST.LOCATION_SYMBOL].attributes[attributeName] = attributeSymbol;
                 parsePropertyAttributeValue(attributeName, property, location);
-                consume(token_js_1.TokenType.RightParens);
+                consume(TokenType.RightParens);
             }
             else {
                 parsePropertyAttributeValue(attributeName, property, location);
@@ -592,31 +563,31 @@ const parse = (tokens) => {
     const parsePropertiesBlock = (options = {
         allowModifiers: false,
     }) => {
-        consume(token_js_1.TokenType.LeftBracket);
+        consume(TokenType.LeftBracket);
         const properties = {};
-        while (!match(token_js_1.TokenType.RightBracket)) {
+        while (!match(TokenType.RightBracket)) {
             try {
-                const { value: propName } = consume(token_js_1.TokenType.Identifier);
+                const { value: propName } = consume(TokenType.Identifier);
                 properties[propName] = parsePropertyType(options);
-                if (match(token_js_1.TokenType.Comma)) {
-                    consume(token_js_1.TokenType.Comma);
+                if (match(TokenType.Comma)) {
+                    consume(TokenType.Comma);
                 }
             }
             catch (err) {
-                if (err instanceof diagnostic_js_1.Diagnostic) {
+                if (err instanceof Diagnostic) {
                     errors.push(err);
                     recoverLoop: for (;;) {
                         switch (current().type) {
-                            case token_js_1.TokenType.RightBracket:
-                            case token_js_1.TokenType.Identifier: {
+                            case TokenType.RightBracket:
+                            case TokenType.Identifier: {
                                 break recoverLoop;
                             }
                         }
-                        while (match(token_js_1.TokenType.AttributeName)) {
+                        while (match(TokenType.AttributeName)) {
                             advance();
-                            if (match(token_js_1.TokenType.LeftParens)) {
+                            if (match(TokenType.LeftParens)) {
                                 advance();
-                                while (!match(token_js_1.TokenType.RightParens)) {
+                                while (!match(TokenType.RightParens)) {
                                     advance();
                                 }
                             }
@@ -629,19 +600,19 @@ const parse = (tokens) => {
                 throw err;
             }
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         return properties;
     };
     const parseMultiplePropertyTypes = (options = {
         allowModifiers: false,
     }) => {
-        if (match(token_js_1.TokenType.Pipe)) {
-            consume(token_js_1.TokenType.Pipe);
+        if (match(TokenType.Pipe)) {
+            consume(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);
+                if (match(TokenType.Pipe)) {
+                    consume(TokenType.Pipe);
                 }
                 else {
                     break;
@@ -654,15 +625,15 @@ const parse = (tokens) => {
     const parseAccessCondition = (options = {
         arrayBlock: false,
     }) => {
-        if (match(token_js_1.TokenType.Boolean)) {
-            const { value } = consume(token_js_1.TokenType.Boolean);
+        if (match(TokenType.Boolean)) {
+            const { value } = consume(TokenType.Boolean);
             return value;
         }
-        else if (match(token_js_1.TokenType.QuotedString, [
+        else if (match(TokenType.QuotedString, [
             'unauthenticated',
             'unauthenticated-only',
         ])) {
-            const { value } = consume(token_js_1.TokenType.QuotedString, [
+            const { value } = consume(TokenType.QuotedString, [
                 'unauthenticated',
                 'unauthenticated-only',
             ]);
@@ -671,13 +642,13 @@ const parse = (tokens) => {
         else {
             const { value, symbols } = options.arrayBlock
                 ? parseArrayBlock()
-                : parseArray([token_js_1.TokenType.QuotedString]);
+                : parseArray([TokenType.QuotedString]);
             return checkForValidRoles(value, symbols);
         }
     };
     const parseCollection = () => {
-        consume(token_js_1.TokenType.Keyword, 'collection');
-        const { value: name } = consume(token_js_1.TokenType.Identifier);
+        consume(TokenType.Keyword, 'collection');
+        const { value: name } = consume(TokenType.Identifier);
         const node = {
             kind: 'collection',
             name,
@@ -686,22 +657,22 @@ const parse = (tokens) => {
                 arrays: {},
             },
         };
-        if (match(token_js_1.TokenType.Keyword, 'extends')) {
-            consume(token_js_1.TokenType.Keyword);
-            const { value: packageName } = match(token_js_1.TokenType.QuotedString)
-                ? consume(token_js_1.TokenType.QuotedString)
-                : consume(token_js_1.TokenType.Identifier);
-            consume(token_js_1.TokenType.Dot);
-            const { value: symbolName } = consume(token_js_1.TokenType.Identifier);
+        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(token_js_1.TokenType.LeftBracket);
-        while (!match(token_js_1.TokenType.RightBracket)) {
-            const { value: keyword } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_KEYWORDS);
+        consume(TokenType.LeftBracket);
+        while (!match(TokenType.RightBracket)) {
+            const { value: keyword } = consume(TokenType.Keyword, lexer.COLLECTION_KEYWORDS);
             try {
                 switch (keyword) {
                     case 'middlewares': {
@@ -709,11 +680,11 @@ const parse = (tokens) => {
                         break;
                     }
                     case 'owned': {
-                        if (match(token_js_1.TokenType.Boolean)) {
-                            node.owned = consume(token_js_1.TokenType.Boolean).value;
+                        if (match(TokenType.Boolean)) {
+                            node.owned = consume(TokenType.Boolean).value;
                         }
                         else {
-                            node.owned = consume(token_js_1.TokenType.QuotedString, [
+                            node.owned = consume(TokenType.QuotedString, [
                                 'always',
                                 'on-write',
                             ]).value;
@@ -721,7 +692,7 @@ const parse = (tokens) => {
                         break;
                     }
                     case 'icon': {
-                        const { value } = consume(token_js_1.TokenType.QuotedString, ICON_NAMES);
+                        const { value } = consume(TokenType.QuotedString, ICON_NAMES);
                         node[keyword] = value;
                         break;
                     }
@@ -756,7 +727,7 @@ const parse = (tokens) => {
                         break;
                     }
                     case 'presets': {
-                        const { value, symbols } = parseArrayBlock(types_1.DESCRIPTION_PRESETS);
+                        const { value, symbols } = parseArrayBlock(DESCRIPTION_PRESETS);
                         node[keyword] = value;
                         node[AST.LOCATION_SYMBOL].arrays[keyword] = symbols;
                         break;
@@ -789,7 +760,7 @@ const parse = (tokens) => {
                 }
             }
             catch (err) {
-                if (err instanceof diagnostic_js_1.Diagnostic) {
+                if (err instanceof Diagnostic) {
                     errors.push(err);
                     recover(lexer.COLLECTION_KEYWORDS);
                     continue;
@@ -797,19 +768,19 @@ const parse = (tokens) => {
                 throw err;
             }
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(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);
+        consume(TokenType.Keyword, 'contract');
+        const { value: name } = consume(TokenType.Identifier);
+        consume(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);
+        while (!match(TokenType.RightBracket)) {
+            const { value: keyword } = consume(TokenType.Keyword, lexer.CONTRACT_KEYWORDS);
             switch (keyword) {
                 case 'roles': {
                     node.roles = parseAccessCondition({
@@ -837,39 +808,39 @@ const parse = (tokens) => {
                 }
             }
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         return node;
     };
     const parseFunctionsBlock = () => {
-        consume(token_js_1.TokenType.LeftBracket);
+        consume(TokenType.LeftBracket);
         const functions = [];
         const functionSets = [];
-        while (!match(token_js_1.TokenType.RightBracket)) {
+        while (!match(TokenType.RightBracket)) {
             try {
-                if (match(token_js_1.TokenType.MacroName)) {
-                    const { value: macroName } = consume(token_js_1.TokenType.MacroName, ['include']);
+                if (match(TokenType.MacroName)) {
+                    const { value: macroName } = consume(TokenType.MacroName, ['include']);
                     switch (macroName) {
                         case 'include': {
-                            const { value: functionSetName, location } = consume(token_js_1.TokenType.Identifier);
+                            const { value: functionSetName, location } = consume(TokenType.Identifier);
                             const functionSetSymbol = Symbol();
-                            exports.locationMap.set(functionSetSymbol, location);
+                            locationMap.set(functionSetSymbol, location);
                             functionSets.push([
                                 functionSetName,
                                 functionSetSymbol,
                             ]);
-                            consume(token_js_1.TokenType.RightParens);
+                            consume(TokenType.RightParens);
                             break;
                         }
                     }
                     continue;
                 }
                 let functionNode;
-                if (current().type === token_js_1.TokenType.Identifier && next().type === token_js_1.TokenType.Dot) {
-                    const { value: packageName } = match(token_js_1.TokenType.QuotedString)
-                        ? consume(token_js_1.TokenType.QuotedString)
-                        : consume(token_js_1.TokenType.Identifier);
-                    consume(token_js_1.TokenType.Dot);
-                    const { value: symbolName } = consume(token_js_1.TokenType.Identifier);
+                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,
@@ -881,10 +852,10 @@ const parse = (tokens) => {
                     };
                 }
                 else {
-                    const { value: functionName } = consume(token_js_1.TokenType.Identifier);
+                    const { value: functionName } = consume(TokenType.Identifier);
                     let exportSymbol;
-                    if (exports.memoTable.defaultExportSymbols && functionName in exports.memoTable.defaultExportSymbols) {
-                        const packageName = exports.memoTable.defaultExportSymbols[functionName];
+                    if (memoTable.defaultExportSymbols && functionName in memoTable.defaultExportSymbols) {
+                        const packageName = memoTable.defaultExportSymbols[functionName];
                         exportSymbol = {
                             packageName,
                             importPath: packageName,
@@ -898,12 +869,12 @@ const parse = (tokens) => {
                     };
                 }
                 functions.push(functionNode);
-                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);
+                while (match(TokenType.AttributeName, 'expose')) {
+                    consume(TokenType.AttributeName, 'expose');
+                    if (match(TokenType.LeftParens)) {
+                        consume(TokenType.LeftParens);
                         functionNode.accessCondition = parseAccessCondition();
-                        consume(token_js_1.TokenType.RightParens);
+                        consume(TokenType.RightParens);
                     }
                     else {
                         functionNode.accessCondition = true;
@@ -911,10 +882,10 @@ const parse = (tokens) => {
                 }
             }
             catch (err) {
-                if (err instanceof diagnostic_js_1.Diagnostic) {
+                if (err instanceof Diagnostic) {
                     let token;
                     while (token = tokens[++index]) {
-                        if (token.type === token_js_1.TokenType.Identifier || token.type === token_js_1.TokenType.RightBracket) {
+                        if (token.type === TokenType.Identifier || token.type === TokenType.RightBracket) {
                             break;
                         }
                     }
@@ -924,15 +895,15 @@ const parse = (tokens) => {
                 throw err;
             }
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         return {
             functions,
             functionSets,
         };
     };
     const parseFunctionSet = () => {
-        consume(token_js_1.TokenType.Keyword, 'functionset');
-        const { value: name } = consume(token_js_1.TokenType.Identifier);
+        consume(TokenType.Keyword, 'functionset');
+        const { value: name } = consume(TokenType.Identifier);
         const { functions, functionSets } = parseFunctionsBlock();
         const node = {
             kind: 'functionset',
@@ -944,10 +915,10 @@ const parse = (tokens) => {
     };
     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);
+        consume(TokenType.LeftBracket);
+        while (!match(TokenType.RightBracket)) {
+            const { value: actionName } = consume(TokenType.Identifier);
+            consume(TokenType.LeftBracket);
             const baseSlots = {};
             const slots = {
                 route: {
@@ -959,28 +930,28 @@ const parse = (tokens) => {
                 event: {},
             };
             let actionType;
-            while (!match(token_js_1.TokenType.RightBracket)) {
-                const { value: keyword } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_ACTIONS_KEYWORDS);
+            while (!match(TokenType.RightBracket)) {
+                const { value: keyword } = consume(TokenType.Keyword, lexer.COLLECTION_ACTIONS_KEYWORDS);
                 switch (keyword) {
                     case 'icon': {
-                        const { value } = consume(token_js_1.TokenType.QuotedString, ICON_NAMES);
+                        const { value } = consume(TokenType.QuotedString, ICON_NAMES);
                         baseSlots[keyword] = value;
                         break;
                     }
                     case 'label': {
-                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        const { value } = consume(TokenType.QuotedString);
                         baseSlots[keyword] = value;
                         break;
                     }
                     case 'ask':
                     case 'button':
                     case 'translate': {
-                        const { value } = consume(token_js_1.TokenType.Boolean);
+                        const { value } = consume(TokenType.Boolean);
                         baseSlots[keyword] = value;
                         break;
                     }
                     case 'roles': {
-                        const { value, symbols } = parseArray([token_js_1.TokenType.Identifier]);
+                        const { value, symbols } = parseArray([TokenType.Identifier]);
                         const roles = checkForValidRoles(value, symbols);
                         baseSlots[keyword] = roles;
                         break;
@@ -991,7 +962,7 @@ const parse = (tokens) => {
                         break;
                     }
                     case 'route': {
-                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        const { value } = consume(TokenType.QuotedString);
                         actionType = 'route';
                         slots.route.route.name = value;
                         break;
@@ -999,28 +970,28 @@ const parse = (tokens) => {
                     case 'setItem':
                     case 'fetchItem':
                     case 'clearItem': {
-                        const { value } = consume(token_js_1.TokenType.Boolean);
+                        const { value } = consume(TokenType.Boolean);
                         slots.route.route[keyword] = value;
                         break;
                     }
                     case 'function': {
-                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        const { value } = consume(TokenType.QuotedString);
                         actionType = 'function';
                         slots.function.function = value;
                         break;
                     }
                     case 'effect': {
-                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        const { value } = consume(TokenType.QuotedString);
                         slots.function.effect = value;
                         break;
                     }
                     case 'selection': {
-                        const { value } = consume(token_js_1.TokenType.Boolean);
+                        const { value } = consume(TokenType.Boolean);
                         slots.function.selection = value;
                         break;
                     }
                     case 'event': {
-                        const { value } = consume(token_js_1.TokenType.QuotedString);
+                        const { value } = consume(TokenType.QuotedString);
                         actionType = 'event';
                         slots.event.event = value;
                         break;
@@ -1036,17 +1007,17 @@ const parse = (tokens) => {
             else {
                 actions[actionName] = baseSlots;
             }
-            consume(token_js_1.TokenType.RightBracket);
+            consume(TokenType.RightBracket);
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         return actions;
     };
     const parseSearchBlock = () => {
         const searchSlots = {};
-        const { location } = consume(token_js_1.TokenType.LeftBracket);
+        const { location } = consume(TokenType.LeftBracket);
         let indexesSymbols;
-        while (!match(token_js_1.TokenType.RightBracket)) {
-            const { value: keyword } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_SEARCH_KEYWORDS);
+        while (!match(TokenType.RightBracket)) {
+            const { value: keyword } = consume(TokenType.Keyword, lexer.COLLECTION_SEARCH_KEYWORDS);
             switch (keyword) {
                 case 'indexes': {
                     const { value, symbols } = parseArrayBlock();
@@ -1055,12 +1026,12 @@ const parse = (tokens) => {
                     break;
                 }
                 case 'placeholder': {
-                    const { value } = consume(token_js_1.TokenType.QuotedString);
+                    const { value } = consume(TokenType.QuotedString);
                     searchSlots[keyword] = value;
                     break;
                 }
                 case 'exactMatches': {
-                    const { value } = consume(token_js_1.TokenType.Boolean);
+                    const { value } = consume(TokenType.Boolean);
                     searchSlots[keyword] = value;
                     break;
                 }
@@ -1068,9 +1039,9 @@ const parse = (tokens) => {
         }
         const { indexes } = searchSlots;
         if (!indexes) {
-            throw new diagnostic_js_1.Diagnostic('"indexes" option is required', location);
+            throw new Diagnostic('"indexes" option is required', location);
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         const options = {
             ...searchSlots,
             indexes,
@@ -1084,62 +1055,62 @@ const parse = (tokens) => {
         let name;
         const options = {};
         const optionsSymbols = {};
-        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_LAYOUT_KEYWORDS);
+        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(token_js_1.TokenType.QuotedString, types_1.LAYOUT_NAMES).value;
+                    name = consume(TokenType.QuotedString, LAYOUT_NAMES).value;
                     break;
                 }
                 case 'options':
                     {
-                        consume(token_js_1.TokenType.LeftBracket);
-                        while (!match(token_js_1.TokenType.RightBracket)) {
-                            const { value: optionsKeyword } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_LAYOUT_OPTIONS_KEYWORDS);
+                        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 } = consume(token_js_1.TokenType.Identifier);
+                                    const { value, location } = consume(TokenType.Identifier);
                                     const symbol = Symbol();
                                     options[optionsKeyword] = value;
                                     optionsSymbols[optionsKeyword] = symbol;
-                                    exports.locationMap.set(symbol, location);
+                                    locationMap.set(symbol, location);
                                     break;
                                 }
                                 case 'information': {
-                                    if (match(token_js_1.TokenType.LeftBracket)) {
+                                    if (match(TokenType.LeftBracket)) {
                                         const { value, symbols } = parseArrayBlock();
                                         options[optionsKeyword] = value;
                                         optionsSymbols[optionsKeyword] = symbols;
                                     }
                                     else {
-                                        const { value, location } = consume(token_js_1.TokenType.Identifier);
+                                        const { value, location } = consume(TokenType.Identifier);
                                         const symbol = Symbol();
                                         options[optionsKeyword] = value;
                                         optionsSymbols[optionsKeyword] = symbol;
-                                        exports.locationMap.set(symbol, location);
+                                        locationMap.set(symbol, location);
                                     }
                                     break;
                                 }
                                 case 'translateBadge': {
-                                    const { value } = consume(token_js_1.TokenType.Boolean);
+                                    const { value } = consume(TokenType.Boolean);
                                     options[optionsKeyword] = value;
                                     break;
                                 }
                             }
                         }
                     }
-                    consume(token_js_1.TokenType.RightBracket);
+                    consume(TokenType.RightBracket);
                     break;
             }
         }
         if (!name) {
-            throw new diagnostic_js_1.Diagnostic('layout must have a "name" property', location);
+            throw new Diagnostic('layout must have a "name" property', location);
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         return {
             kind: 'layout',
             name,
@@ -1158,24 +1129,24 @@ const parse = (tokens) => {
                 fields: {},
             },
         };
-        consume(token_js_1.TokenType.LeftBracket);
-        while (!match(token_js_1.TokenType.RightBracket)) {
-            const { value: keyword, location: keywordLocation } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
+        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(token_js_1.TokenType.LeftBracket);
-                    while (!match(token_js_1.TokenType.RightBracket)) {
-                        const { value: identifier, location: identifierLocation } = consume(token_js_1.TokenType.Identifier);
+                    consume(TokenType.LeftBracket);
+                    while (!match(TokenType.RightBracket)) {
+                        const { value: identifier, location: identifierLocation } = consume(TokenType.Identifier);
                         const identifierSymbol = Symbol();
-                        exports.locationMap.set(identifierSymbol, identifierLocation);
+                        locationMap.set(identifierSymbol, identifierLocation);
                         fields[identifier] ??= {};
                         node[AST.LOCATION_SYMBOL].fields[identifier] = {
                             name: identifierSymbol,
                             field: {},
                         };
-                        consume(token_js_1.TokenType.LeftBracket);
-                        while (!match(token_js_1.TokenType.RightBracket)) {
-                            const { value: keyword, location: keywordLocation } = consume(token_js_1.TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
+                        consume(TokenType.LeftBracket);
+                        while (!match(TokenType.RightBracket)) {
+                            const { value: keyword, location: keywordLocation } = consume(TokenType.Keyword, lexer.COLLECTION_FORM_LAYOUT_KEYWORDS);
                             switch (keyword) {
                                 case 'if': {
                                     const ifTerms = [];
@@ -1185,47 +1156,47 @@ const parse = (tokens) => {
                                 }
                                 case 'span':
                                 case 'verticalSpacing': {
-                                    fields[identifier].span = consume(token_js_1.TokenType.Number).value;
+                                    fields[identifier].span = consume(TokenType.Number).value;
                                     break;
                                 }
                                 case 'separator': {
-                                    fields[identifier].separator = match(token_js_1.TokenType.Boolean)
-                                        ? consume(token_js_1.TokenType.Boolean).value
-                                        : consume(token_js_1.TokenType.QuotedString, [
+                                    fields[identifier].separator = match(TokenType.Boolean)
+                                        ? consume(TokenType.Boolean).value
+                                        : consume(TokenType.QuotedString, [
                                             'top',
                                             'bottom',
                                         ]).value;
                                     break;
                                 }
                                 default: {
-                                    throw new diagnostic_js_1.Diagnostic(`invalid keyword "${keyword}"`, keywordLocation);
+                                    throw new Diagnostic(`invalid keyword "${keyword}"`, keywordLocation);
                                 }
                             }
                         }
-                        consume(token_js_1.TokenType.RightBracket);
+                        consume(TokenType.RightBracket);
                     }
-                    consume(token_js_1.TokenType.RightBracket);
+                    consume(TokenType.RightBracket);
                     break;
                 }
                 default: {
-                    throw new diagnostic_js_1.Diagnostic(`invalid keyword "${keyword}"`, keywordLocation);
+                    throw new Diagnostic(`invalid keyword "${keyword}"`, keywordLocation);
                 }
             }
         }
-        consume(token_js_1.TokenType.RightBracket);
+        consume(TokenType.RightBracket);
         return node;
     };
     const parseCondition = (symbols = []) => {
-        if (match(token_js_1.TokenType.LeftParens)) {
-            consume(token_js_1.TokenType.LeftParens);
+        if (match(TokenType.LeftParens)) {
+            consume(TokenType.LeftParens);
             let operatorType, newOp = operatorType;
             const conditions = [];
-            while (!match(token_js_1.TokenType.RightParens)) {
+            while (!match(TokenType.RightParens)) {
                 conditions.push(parseCondition(symbols));
-                if (match(token_js_1.TokenType.RightParens)) {
+                if (match(TokenType.RightParens)) {
                     break;
                 }
-                const { value: operatorSymbol, location } = consume(token_js_1.TokenType.Operator);
+                const { value: operatorSymbol, location } = consume(TokenType.Operator);
                 switch (operatorSymbol) {
                     case '&&':
                         newOp = 'and';
@@ -1234,15 +1205,15 @@ const parse = (tokens) => {
                         newOp = 'or';
                         break;
                     default: {
-                        throw new diagnostic_js_1.Diagnostic(`unsupported operator: "${operatorSymbol}"`, location);
+                        throw new Diagnostic(`unsupported operator: "${operatorSymbol}"`, location);
                     }
                 }
                 if (operatorType && operatorType !== newOp) {
-                    throw new diagnostic_js_1.Diagnostic('having "and" or "or" in the same expression is not supported, please use parenthesis', location);
+                    throw new Diagnostic('having "and" or "or" in the same expression is not supported, please use parenthesis', location);
                 }
                 operatorType = newOp;
             }
-            consume(token_js_1.TokenType.RightParens);
+            consume(TokenType.RightParens);
             switch (operatorType) {
                 case 'and': {
                     return {
@@ -1259,34 +1230,34 @@ const parse = (tokens) => {
                 }
             }
         }
-        if (match(token_js_1.TokenType.Operator, '!')) {
-            consume(token_js_1.TokenType.Operator);
+        if (match(TokenType.Operator, '!')) {
+            consume(TokenType.Operator);
             return {
                 not: parseCondition(symbols),
             };
         }
-        const { value: term1, location: term1Location } = consume(token_js_1.TokenType.Identifier);
+        const { value: term1, location: term1Location } = consume(TokenType.Identifier);
         const term1Symbol = Symbol();
-        exports.locationMap.set(term1Symbol, term1Location);
+        locationMap.set(term1Symbol, term1Location);
         symbols.push([
             term1,
             term1Symbol,
         ]);
-        if (!match(token_js_1.TokenType.Operator, lexer.FINAL_OPERATORS)) {
+        if (!match(TokenType.Operator, lexer.FINAL_OPERATORS)) {
             return {
                 operator: 'truthy',
                 term1,
             };
         }
-        const { value: operatorSymbol, location } = consume(token_js_1.TokenType.Operator);
+        const { value: operatorSymbol, location } = consume(TokenType.Operator);
         let term2;
-        if (match(token_js_1.TokenType.LeftParens)) {
+        if (match(TokenType.LeftParens)) {
             term2 = parseCondition(symbols);
         }
-        else if (match(token_js_1.TokenType.LeftSquareBracket)) {
+        else if (match(TokenType.LeftSquareBracket)) {
             term2 = parseArray([
-                token_js_1.TokenType.QuotedString,
-                token_js_1.TokenType.Number,
+                TokenType.QuotedString,
+                TokenType.Number,
             ]).value;
         }
         else {
@@ -1314,7 +1285,7 @@ const parse = (tokens) => {
                 operator = 'lt';
                 break;
             default: {
-                throw new diagnostic_js_1.Diagnostic(`unsupported operator: "${operatorSymbol}"`, location);
+                throw new Diagnostic(`unsupported operator: "${operatorSymbol}"`, location);
             }
         }
         return {
@@ -1332,7 +1303,7 @@ const parse = (tokens) => {
                     if (collection.name === 'User') {
                         const { properties } = collection;
                         if ('roles' in properties && 'items' in properties.roles.property && 'enum' in properties.roles.property.items) {
-                            exports.memoTable.roles = properties.roles.property.items.enum;
+                            memoTable.roles = properties.roles.property.items.enum;
                         }
                     }
                     ast.collections.push(collection);
@@ -1347,11 +1318,11 @@ const parse = (tokens) => {
                     break;
                 }
                 default:
-                    throw new diagnostic_js_1.Diagnostic(`invalid declaration type: "${declType}"`, location);
+                    throw new Diagnostic(`invalid declaration type: "${declType}"`, location);
             }
         }
         catch (err) {
-            if (err instanceof diagnostic_js_1.Diagnostic) {
+            if (err instanceof Diagnostic) {
                 errors.push(err);
                 recover(lexer.TOPLEVEL_KEYWORDS);
                 continue;
@@ -1364,4 +1335,3 @@ const parse = (tokens) => {
         errors,
     };
 };
-exports.parse = parse;