@mojir/lits 2.2.2 → 2.2.3

package/dist/cli/cli.js

@@ -7,7 +7,7 @@ var readline = require('node:readline');
 var os = require('node:os');
 var process$1 = require('node:process');
 
-var version = "2.2.2";
+var version = "2.2.3";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -6212,7 +6212,6 @@ const builtin = {
 };
 const normalExpressionKeys = Object.keys(normalExpressions);
 const specialExpressionKeys = Object.keys(specialExpressionTypes);
-new Set(specialExpressionKeys);
 
 const nonNumberReservedSymbolRecord = {
     true: true,
@@ -7453,6 +7452,201 @@ function untokenize(tokenStream) {
     }, '');
 }
 
+const litsCommands = new Set([...normalExpressionKeys, ...specialExpressionKeys, ...Object.keys(reservedSymbolRecord)]);
+// TODO: replace with get suggestions function
+class AutoCompleter {
+    originalProgram;
+    originalPosition;
+    prefixProgram = '';
+    suffixProgram = '';
+    searchString = '';
+    suggestions = [];
+    suggestionIndex = null;
+    constructor(originalProgram, originalPosition, lits, params) {
+        this.originalProgram = originalProgram;
+        this.originalPosition = originalPosition;
+        const partialProgram = this.originalProgram.slice(0, this.originalPosition);
+        const tokenStream = lits.tokenize(partialProgram);
+        const lastToken = tokenStream.tokens.at(-1);
+        if (!lastToken) {
+            return;
+        }
+        if (lastToken[0] === 'Error') {
+            return;
+        }
+        this.searchString = lastToken[1];
+        this.prefixProgram = this.originalProgram.slice(0, this.originalPosition - this.searchString.length);
+        this.suffixProgram = this.originalProgram.slice(this.prefixProgram.length + this.searchString.length);
+        this.originalProgram.slice(this.prefixProgram.length + this.searchString.length);
+        this.suggestions = this.generateSuggestions(params);
+    }
+    getNextSuggestion() {
+        return this.getAutoCompleteSuggestionResult(this.getNextSuggestionSymbol());
+    }
+    getPreviousSuggestion() {
+        return this.getAutoCompleteSuggestionResult(this.getPreviousSuggestionSymbol());
+    }
+    getAutoCompleteSuggestionResult(suggestion) {
+        if (suggestion === null) {
+            return null;
+        }
+        return {
+            program: this.prefixProgram + suggestion + this.suffixProgram,
+            position: this.prefixProgram.length + suggestion.length,
+        };
+    }
+    getNextSuggestionSymbol() {
+        if (this.suggestions.length === 0) {
+            return null;
+        }
+        if (this.suggestionIndex === null) {
+            this.suggestionIndex = 0;
+        }
+        else {
+            this.suggestionIndex += 1;
+            if (this.suggestionIndex >= this.suggestions.length) {
+                this.suggestionIndex = 0;
+            }
+        }
+        return this.suggestions[this.suggestionIndex];
+    }
+    getPreviousSuggestionSymbol() {
+        if (this.suggestions.length === 0) {
+            return null;
+        }
+        if (this.suggestionIndex === null) {
+            this.suggestionIndex = this.suggestions.length - 1;
+        }
+        else {
+            this.suggestionIndex -= 1;
+            if (this.suggestionIndex < 0) {
+                this.suggestionIndex = this.suggestions.length - 1;
+            }
+        }
+        return this.suggestions[this.suggestionIndex];
+    }
+    getSuggestions() {
+        return [...this.suggestions];
+    }
+    getSearchString() {
+        return this.searchString;
+    }
+    generateSuggestions(params) {
+        const blacklist = new Set(['0_def', '0_defn', '0_lambda']);
+        const startsWithCaseSensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.startsWith(this.searchString));
+        startsWithCaseSensitive.forEach(suggestion => blacklist.add(suggestion));
+        const startsWithCaseInsensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.toLowerCase().startsWith(this.searchString.toLowerCase()));
+        startsWithCaseInsensitive.forEach(suggestion => blacklist.add(suggestion));
+        const includesCaseSensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.includes(this.searchString));
+        includesCaseSensitive.forEach(suggestion => blacklist.add(suggestion));
+        const includesCaseInsensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.includes(this.searchString.toLowerCase()));
+        includesCaseInsensitive.forEach(suggestion => blacklist.add(suggestion));
+        return [...startsWithCaseSensitive, ...startsWithCaseInsensitive, ...includesCaseSensitive, ...includesCaseInsensitive];
+    }
+    generateWithPredicate(params, shouldInclude) {
+        const suggestions = new Set();
+        litsCommands.forEach((suggestion) => {
+            if (shouldInclude(suggestion)) {
+                suggestions.add(suggestion);
+            }
+        });
+        Object.keys(params.globalContext ?? {})
+            .filter(shouldInclude)
+            .forEach(suggestion => suggestions.add(suggestion));
+        params.contexts?.forEach((context) => {
+            Object.keys(context)
+                .filter(shouldInclude)
+                .forEach(suggestion => suggestions.add(suggestion));
+        });
+        Object.keys(params.jsFunctions ?? {})
+            .filter(shouldInclude)
+            .forEach(suggestion => suggestions.add(suggestion));
+        Object.keys(params.values ?? {})
+            .filter(shouldInclude)
+            .forEach(suggestion => suggestions.add(suggestion));
+        return [...suggestions].sort((a, b) => a.localeCompare(b));
+    }
+}
+
+class ParserContext {
+    tokens;
+    position;
+    storedPosition = 0;
+    parseExpression;
+    constructor(tokenStream) {
+        this.tokens = tokenStream.tokens;
+        this.position = 0;
+    }
+    advance() {
+        this.position += 1;
+    }
+    tryPeek() {
+        return this.tokens[this.position];
+    }
+    peek() {
+        const token = this.tokens[this.position];
+        if (!token) {
+            const lastToken = this.tokens.at(-1);
+            const sourceCodeInfo = lastToken ? lastToken[2] : undefined;
+            throw new LitsError('Unexpected end of input', sourceCodeInfo);
+        }
+        return token;
+    }
+    isAtEnd() {
+        return this.position >= this.tokens.length;
+    }
+    // TODO rename to getSourceCodeInfo
+    peekSourceCodeInfo() {
+        const currentToken = this.tryPeek();
+        return currentToken ? currentToken[2] : this.tokens.at(-1)?.[2];
+    }
+    storePosition() {
+        return this.storedPosition = this.position;
+    }
+    restorePosition() {
+        this.position = this.storedPosition;
+    }
+    peekAhead(count) {
+        return this.tokens[this.position + count];
+    }
+    getPosition() {
+        return this.position;
+    }
+    getTokenAt(pos) {
+        return this.tokens[pos];
+    }
+}
+
+const exponentiationPrecedence = 12;
+const binaryFunctionalOperatorPrecedence = 3;
+const conditionalOperatorPrecedence = 1;
+function withSourceCodeInfo(node, sourceCodeInfo) {
+    if (sourceCodeInfo) {
+        node[2] = sourceCodeInfo;
+    }
+    return node;
+}
+function stringToSymbolNode(value, sourceCodeInfo) {
+    if (specialExpressionTypes[value] !== undefined && value !== 'fn' && value !== 'def' && value !== 'defn') {
+        return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[value]], sourceCodeInfo);
+    }
+    if (normalExpressionTypes[value] !== undefined) {
+        return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[value]], sourceCodeInfo);
+    }
+    return withSourceCodeInfo([NodeTypes.UserDefinedSymbol, value], sourceCodeInfo);
+}
+function stringFromQuotedSymbol(value) {
+    return value.substring(1, value.length - 1)
+        .replace(/(\\{2})|(\\')|\\(.)/g, (_, backslash, singleQuote, normalChar) => {
+        if (backslash) {
+            return '\\';
+        }
+        if (singleQuote) {
+            return '\'';
+        }
+        return `\\${normalChar}`;
+    });
+}
 // Reverse lookup tables for getting symbol names from builtin types
 const normalExpressionNames = Object.entries(normalExpressionTypes).reduce((acc, [name, index]) => {
     acc[index] = name;
@@ -7478,62 +7672,6 @@ function getSymbolName(symbol) {
     // SpecialBuiltinSymbolNode
     return specialExpressionNames[symbol[1]];
 }
-const exponentiationPrecedence = 12;
-const binaryFunctionalOperatorPrecedence = 3;
-const conditionalOperatorPrecedence = 1;
-const maxShorthandLambdaArity = 20;
-const placeholderRegexp = /^\$([1-9]\d?)?$/;
-function withSourceCodeInfo(node, sourceCodeInfo) {
-    if (sourceCodeInfo) {
-        node[2] = sourceCodeInfo;
-    }
-    return node;
-}
-function getPrecedence(operatorSign, sourceCodeInfo) {
-    switch (operatorSign) {
-        case '^': // exponentiation
-            return exponentiationPrecedence;
-        case '*': // multiplication
-        case '/': // division
-        case '%': // remainder
-            return 11;
-        case '+': // addition
-        case '-': // subtraction
-            return 10;
-        case '<<': // left shift
-        case '>>': // signed right shift
-        case '>>>': // unsigned right shift
-            return 9;
-        case '++': // string concatenation
-            return 8;
-        case '<': // less than
-        case '<=': // less than or equal
-        case '≤': // less than or equal
-        case '>': // greater than
-        case '>=': // greater than or equal
-        case '≥': // greater than or equal
-            return 7;
-        case '==': // equal
-        case '!=': // not equal
-        case '≠': // not equal
-            return 6;
-        case '&': // bitwise AND
-        case 'xor': // bitwise XOR
-        case '|': // bitwise OR
-            return 5;
-        case '&&': // logical AND
-        case '||': // logical OR
-        case '??': // nullish coalescing
-            return 4;
-        // leave room for binaryFunctionalOperatorPrecedence = 3
-        case '|>': // pipe
-            return 2;
-        // leave room for conditionalOperatorPrecedence = 1
-        /* v8 ignore next 2 */
-        default:
-            throw new LitsError(`Unknown binary operator: ${operatorSign}`, sourceCodeInfo);
-    }
-}
 function createNamedNormalExpressionNode(symbolNode, params, sourceCodeInfo) {
     const node = withSourceCodeInfo([NodeTypes.NormalExpression, [symbolNode, params]], sourceCodeInfo);
     if (isNormalBuiltinSymbolNode(symbolNode)) {
@@ -7541,8 +7679,18 @@ function createNamedNormalExpressionNode(symbolNode, params, sourceCodeInfo) {
     }
     return node;
 }
-function createAccessorNode(left, right, sourceCodeInfo) {
-    return withSourceCodeInfo([NodeTypes.NormalExpression, [[NodeTypes.NormalBuiltinSymbol, normalExpressionTypes.get], [left, right]]], sourceCodeInfo);
+function isAtExpressionEnd(ctx) {
+    if (ctx.isAtEnd()) {
+        return true;
+    }
+    const token = ctx.tryPeek();
+    if (isOperatorToken(token)) {
+        return [';', ',', ':'].includes(token[1]);
+    }
+    if (isReservedSymbolToken(token)) {
+        return ['else', 'when', 'while', 'case', 'catch', 'let', 'then', 'end', 'do'].includes(token[1]);
+    }
+    return false;
 }
 function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeInfo) {
     const operatorName = operator[1];
@@ -7589,1153 +7737,1048 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
             throw new LitsError(`Unknown binary operator: ${operatorName}`, sourceCodeInfo);
     }
 }
-class Parser {
-    tokenStream;
-    parseState;
-    constructor(tokenStream, parseState) {
-        this.tokenStream = tokenStream;
-        this.parseState = parseState;
-    }
-    peek() {
-        return this.tokenStream.tokens[this.parseState.position];
-    }
-    peekSourceCodeInfo() {
-        const currentToken = this.peek();
-        return currentToken ? currentToken[2] : this.tokenStream.tokens.at(-1)?.[2];
+
+function parseSymbol(ctx) {
+    const token = ctx.peek();
+    ctx.advance();
+    if (!isSymbolToken(token)) {
+        throw new LitsError(`Expected symbol token, got ${token[0]}`, token[2]);
     }
-    peekAhead(count) {
-        return this.tokenStream.tokens[this.parseState.position + count];
+    if (token[1][0] === '\'') {
+        return stringToSymbolNode(stringFromQuotedSymbol(token[1]), token[2]);
     }
-    advance() {
-        this.parseState.position += 1;
+    else {
+        return stringToSymbolNode(token[1], token[2]);
     }
-    parse() {
-        this.tokenStream.tokens.forEach((token) => {
-            if (token[0] === 'Error') {
-                throw new LitsError(token[3], token[2]);
-            }
-        });
-        const nodes = [];
-        while (!this.isAtEnd()) {
-            nodes.push(this.parseExpression(0, true));
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else {
-                if (!this.isAtEnd()) {
-                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-                }
-            }
+}
+
+function parseBindingTarget(ctx, { requireDefaultValue, noRest } = {}) {
+    const firstToken = ctx.tryPeek();
+    // Symbol
+    if (isSymbolToken(firstToken)) {
+        const symbol = parseSymbol(ctx);
+        if (!isUserDefinedSymbolNode(symbol)) {
+            throw new LitsError('Expected user defined symbol', firstToken[2]);
+        }
+        const defaultValue = parseOptionalDefaulValue(ctx);
+        if (requireDefaultValue && !defaultValue) {
+            throw new LitsError('Expected assignment', ctx.peekSourceCodeInfo());
         }
-        return nodes;
+        return withSourceCodeInfo([bindingTargetTypes.symbol, [symbol, defaultValue]], firstToken[2]);
     }
-    parseExpression(precedence = 0, moduleScope = false) {
-        const firstToken = this.peek();
-        let left;
-        if (isSymbolToken(firstToken)) {
-            switch (firstToken[1]) {
-                case 'let':
-                    return this.parseLet(firstToken);
-                case 'if':
-                case 'unless':
-                    left = this.parseIfOrUnless(firstToken);
-                    break;
-                case 'cond':
-                    left = this.parseCond(firstToken);
-                    break;
-                case 'switch':
-                    left = this.parseSwitch(firstToken);
-                    break;
-                case 'for':
-                case 'doseq':
-                    left = this.parseForOrDoseq(firstToken);
-                    break;
-                case 'loop':
-                    left = this.parseLoop(firstToken);
-                    break;
-                case 'try':
-                    left = this.parseTry(firstToken);
-                    break;
-            }
+    // Rest
+    if (isOperatorToken(firstToken, '...')) {
+        if (noRest) {
+            throw new LitsError('Rest element not allowed', firstToken[2]);
         }
-        else if (isReservedSymbolToken(firstToken, 'do')) {
-            left = this.parseBlock()[0];
+        ctx.advance();
+        const symbol = asUserDefinedSymbolNode(parseSymbol(ctx));
+        if (isOperatorToken(ctx.tryPeek(), '=')) {
+            throw new LitsError('Rest argument can not have default value', ctx.peekSourceCodeInfo());
         }
-        else if (isReservedSymbolToken(firstToken, 'export')) {
-            if (!moduleScope) {
-                throw new LitsError('export is only allowed in module scope', firstToken[2]);
+        return withSourceCodeInfo([bindingTargetTypes.rest, [symbol[1], undefined]], firstToken[2]);
+    }
+    // Array
+    if (isLBracketToken(firstToken)) {
+        ctx.advance();
+        const elements = [];
+        let token = ctx.peek();
+        let rest = false;
+        while (!isRBracketToken(token)) {
+            if (rest) {
+                throw new LitsError('Rest argument must be last', token[2]);
             }
-            return this.parseExport(firstToken);
-        }
-        left ||= this.parseOperand();
-        let operator = this.peek();
-        while (!this.isAtExpressionEnd()) {
-            if (isA_BinaryOperatorToken(operator)) {
-                const name = operator[1];
-                const newPrecedece = getPrecedence(name, operator[2]);
-                if (newPrecedece <= precedence
-                    // ^ (exponentiation) is right associative
-                    && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
-                    break;
-                }
-                const symbol = specialExpressionTypes[name]
-                    ? withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[name]], operator[2])
-                    : withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[name]], operator[2]);
-                this.advance();
-                const right = this.parseExpression(newPrecedece);
-                left = fromBinaryOperatorToNode(operator, symbol, left, right, operator[2]);
-            }
-            else if (isSymbolToken(operator)) {
-                if (!isFunctionOperator(operator[1])) {
-                    break;
-                }
-                const newPrecedece = binaryFunctionalOperatorPrecedence;
-                if (newPrecedece <= precedence) {
-                    break;
-                }
-                const operatorSymbol = this.parseSymbol();
-                const right = this.parseExpression(newPrecedece);
-                if (isSpecialBuiltinSymbolNode(operatorSymbol)) {
-                    throw new LitsError('Special expressions are not allowed in binary functional operators', operatorSymbol[2]);
-                }
-                left = createNamedNormalExpressionNode(operatorSymbol, [left, right], operator[2]);
+            if (isOperatorToken(token, ',')) {
+                elements.push(null);
+                ctx.advance();
+                token = ctx.peek();
+                continue;
             }
-            else if (operator?.[1] === '?') {
-                if (conditionalOperatorPrecedence <= precedence) {
-                    break;
-                }
-                this.advance();
-                const trueNode = this.parseExpression();
-                if (!isOperatorToken(this.peek(), ':')) {
-                    throw new LitsError('Expected :', this.peekSourceCodeInfo());
-                }
-                this.advance();
-                const falseNode = this.parseExpression();
-                left = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [left, trueNode, falseNode]]], left[2]);
+            const target = parseBindingTarget(ctx);
+            if (target[0] === bindingTargetTypes.rest) {
+                rest = true;
             }
-            else {
-                break;
+            elements.push(target);
+            token = ctx.peek();
+            if (!isRBracketToken(token)) {
+                assertOperatorToken(token, ',');
+                ctx.advance();
             }
-            operator = this.peek();
+            token = ctx.peek();
         }
-        return left;
-    }
-    asToken(token) {
-        if (!token) {
-            throw new LitsError('Unexpected end of input', this.peekSourceCodeInfo());
+        ctx.advance();
+        const defaultValue = parseOptionalDefaulValue(ctx);
+        if (requireDefaultValue && !defaultValue) {
+            throw new LitsError('Expected assignment', ctx.peekSourceCodeInfo());
         }
-        return token;
+        return withSourceCodeInfo([bindingTargetTypes.array, [elements, defaultValue]], firstToken[2]);
     }
-    parseOperand() {
-        let operand = this.parseOperandPart();
-        let token = this.peek();
-        while (isOperatorToken(token, '.') || isLBracketToken(token) || isLParenToken(token)) {
-            if (token[1] === '.') {
-                this.advance();
-                const symbolToken = this.asToken(this.peek());
-                if (!isSymbolToken(symbolToken)) {
-                    throw new LitsError('Expected symbol', this.peekSourceCodeInfo());
-                }
-                const stringNode = withSourceCodeInfo([NodeTypes.String, symbolToken[1]], symbolToken[2]);
-                operand = createAccessorNode(operand, stringNode, token[2]);
-                this.advance();
-                token = this.peek();
-            }
-            else if (isLBracketToken(token)) {
-                this.advance();
-                const expression = this.parseExpression();
-                if (!isRBracketToken(this.peek())) {
-                    throw new LitsError('Expected closing bracket', this.peekSourceCodeInfo());
-                }
-                operand = createAccessorNode(operand, expression, token[2]);
-                this.advance();
-                token = this.peek();
-            }
-            else if (isLParenToken(token)) {
-                operand = this.parseFunctionCall(operand);
-                token = this.peek();
+    // Object
+    if (isLBraceToken(firstToken)) {
+        ctx.advance();
+        const elements = {};
+        let token = ctx.peek();
+        let rest = false;
+        while (!isRBraceToken(token)) {
+            if (rest) {
+                throw new LitsError('Rest argument must be last', token[2]);
             }
-        }
-        return operand;
-    }
-    parseOperandPart() {
-        const token = this.asToken(this.peek());
-        // Parentheses
-        if (isLParenToken(token)) {
-            const positionBefore = this.parseState.position;
-            const lamdaFunction = this.parseLambdaFunction();
-            if (lamdaFunction) {
-                return lamdaFunction;
+            if (isOperatorToken(token, '...')) {
+                rest = true;
+                ctx.advance();
             }
-            this.parseState.position = positionBefore;
-            this.advance();
-            const expression = this.parseExpression();
-            if (!isRParenToken(this.peek())) {
-                throw new LitsError('Expected closing parenthesis', this.peekSourceCodeInfo());
-            }
-            this.advance();
-            return expression;
-        }
-        else if (isOperatorToken(token)) {
-            const operatorName = token[1];
-            if (isBinaryOperator(operatorName)) {
-                this.advance();
-                if (specialExpressionTypes[operatorName] !== undefined) {
-                    return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[operatorName]], token[2]);
+            // Parse the key symbol - can be any symbol type (including builtins) when using 'as' alias
+            const keySymbol = parseSymbol(ctx);
+            const keyName = getSymbolName(keySymbol);
+            token = ctx.peek();
+            if (isReservedSymbolToken(token, 'as')) {
+                if (rest) {
+                    throw new LitsError('Rest argument can not have alias', token[2]);
                 }
-                return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[operatorName]], token[2]);
-            }
-            if (operatorName === '->') {
-                return this.parseShorthandLambdaFunction();
-            }
-            else {
-                throw new LitsError(`Illegal operator: ${operatorName}`, token[2]);
-            }
-        }
-        // Object litteral, e.g. {a: 1, b: 2}
-        if (isLBraceToken(token)) {
-            return this.parseObject();
-        }
-        // Array litteral, e.g. [1, 2]
-        if (isLBracketToken(token)) {
-            return this.parseArray();
-        }
-        const tokenType = token[0];
-        switch (tokenType) {
-            case 'Number':
-            case 'BasePrefixedNumber':
-                return this.parseNumber();
-            case 'string':
-                return this.parseString(token);
-            case 'Symbol': {
-                const positionBefore = this.parseState.position;
-                const lamdaFunction = this.parseLambdaFunction();
-                if (lamdaFunction) {
-                    return lamdaFunction;
+                ctx.advance();
+                const name = asUserDefinedSymbolNode(parseSymbol(ctx));
+                if (elements[name[1]]) {
+                    throw new LitsError(`Duplicate binding name: ${name}`, token[2]);
                 }
-                this.parseState.position = positionBefore;
-                return this.parseSymbol();
-            }
-            case 'ReservedSymbol':
-                return this.parseReservedSymbol();
-            case 'RegexpShorthand':
-                return this.parseRegexpShorthand();
-            default:
-                throw new LitsError(`Unknown token type: ${tokenType}`, token[2]);
-        }
-    }
-    parseObject() {
-        const firstToken = asLBraceToken(this.peek());
-        this.advance();
-        const params = [];
-        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
-            if (isOperatorToken(this.peek(), '...')) {
-                this.advance();
-                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peekSourceCodeInfo()));
+                elements[keyName] = withSourceCodeInfo([bindingTargetTypes.symbol, [name, parseOptionalDefaulValue(ctx)]], firstToken[2]);
             }
-            else {
-                const token = this.peek();
-                if (isStringToken(token)) {
-                    const stringNode = this.parseString(token);
-                    params.push(withSourceCodeInfo([NodeTypes.String, stringNode[1]], token[2]));
-                }
-                else if (isSymbolToken(token)) {
-                    const value = token[1].startsWith('\'')
-                        ? this.stringFromQuotedSymbol(token[1])
-                        : token[1];
-                    params.push(withSourceCodeInfo([NodeTypes.String, value], token[2]));
-                    this.advance();
+            else if (isRBraceToken(token) || isOperatorToken(token, ',') || isOperatorToken(token, '=')) {
+                // Without 'as' alias, the key becomes the binding name - must be user-defined symbol
+                const key = asUserDefinedSymbolNode(keySymbol, keySymbol[2]);
+                if (elements[key[1]]) {
+                    throw new LitsError(`Duplicate binding name: ${key}`, token[2]);
                 }
-                else if (isLBracketToken(token)) {
-                    this.advance();
-                    params.push(this.parseExpression());
-                    assertRBracketToken(this.peek());
-                    this.advance();
+                if (rest && isOperatorToken(ctx.tryPeek(), '=')) {
+                    throw new LitsError('Rest argument can not have default value', ctx.peekSourceCodeInfo());
                 }
-                else {
-                    throw new LitsError('Expected key to be a symbol or a string', this.peekSourceCodeInfo());
+                elements[key[1]] = rest
+                    ? withSourceCodeInfo([bindingTargetTypes.rest, [key[1], parseOptionalDefaulValue(ctx)]], firstToken[2])
+                    : withSourceCodeInfo([bindingTargetTypes.symbol, [key, parseOptionalDefaulValue(ctx)]], firstToken[2]);
+            }
+            else if (isOperatorToken(token, ':')) {
+                ctx.advance();
+                token = ctx.peek();
+                if (!isLBraceToken(token) && !isLBracketToken(token)) {
+                    throw new LitsError('Expected object or array', token[2]);
                 }
-                assertOperatorToken(this.peek(), ':');
-                this.advance();
-                params.push(this.parseExpression());
-            }
-            const nextToken = this.peek();
-            if (!isOperatorToken(nextToken, ',') && !isRBraceToken(nextToken)) {
-                throw new LitsError('Expected comma or closing brace', this.peekSourceCodeInfo());
+                elements[keyName] = parseBindingTarget(ctx);
             }
-            if (isOperatorToken(nextToken, ',')) {
-                this.advance();
+            if (!isRBraceToken(ctx.peek())) {
+                assertOperatorToken(ctx.peek(), ',');
+                ctx.advance();
             }
+            token = ctx.peek();
         }
-        assertRBraceToken(this.peek());
-        this.advance();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.object, params]], firstToken[2]);
+        ctx.advance();
+        token = ctx.peek();
+        const defaultValue = parseOptionalDefaulValue(ctx);
+        if (requireDefaultValue && !defaultValue) {
+            throw new LitsError('Expected assignment', token[2]);
+        }
+        return withSourceCodeInfo([bindingTargetTypes.object, [elements, defaultValue]], firstToken[2]);
     }
-    parseArray() {
-        const firstToken = asLBracketToken(this.peek());
-        this.advance();
-        const params = [];
-        while (!this.isAtEnd() && !isRBracketToken(this.peek())) {
-            if (isOperatorToken(this.peek(), '...')) {
-                this.advance();
-                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peekSourceCodeInfo()));
-            }
-            else {
-                params.push(this.parseExpression());
-            }
-            const nextToken = this.peek();
-            if (!isOperatorToken(nextToken, ',') && !isRBracketToken(nextToken)) {
-                throw new LitsError('Expected comma or closing parenthesis', this.peekSourceCodeInfo());
-            }
-            if (isOperatorToken(nextToken, ',')) {
-                this.advance();
-            }
+    throw new LitsError('Expected symbol', ctx.peekSourceCodeInfo());
+}
+function parseOptionalDefaulValue(ctx) {
+    if (isOperatorToken(ctx.tryPeek(), '=')) {
+        ctx.advance();
+        return ctx.parseExpression();
+    }
+    return undefined;
+}
+
+function parseLet(ctx, token) {
+    ctx.advance();
+    const target = parseBindingTarget(ctx, { requireDefaultValue: true, noRest: true });
+    const value = target[1][1];
+    target[1][1] = undefined;
+    const bindingTarget = withSourceCodeInfo([NodeTypes.Binding, [target, value]], token[2]);
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.let, bindingTarget]], token[2]);
+}
+
+function parseImplicitBlock(ctx, ends) {
+    const nodes = [];
+    while (!ctx.isAtEnd() && !isImplicitBlockEnd(ctx, ends)) {
+        if (isOperatorToken(ctx.tryPeek(), ';')) {
+            ctx.advance();
+        }
+        else {
+            nodes.push(ctx.parseExpression());
         }
-        assertRBracketToken(this.peek());
-        this.advance();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.array, params]], firstToken[2]);
     }
-    parseFunctionCall(symbol) {
-        this.advance();
-        const params = [];
-        while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-            if (isOperatorToken(this.peek(), '...')) {
-                this.advance();
-                params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peekSourceCodeInfo()));
-            }
-            else {
-                params.push(this.parseExpression());
-            }
-            const nextToken = this.peek();
-            if (!isOperatorToken(nextToken, ',') && !isRParenToken(nextToken)) {
-                throw new LitsError('Expected comma or closing parenthesis', this.peek()?.[2]);
-            }
-            if (isOperatorToken(nextToken, ',')) {
-                this.advance();
-            }
+    assertImplicitBlockEnd(ctx, ends);
+    if (nodes.length === 0) {
+        throw new LitsError('Expected expression', ctx.peekSourceCodeInfo());
+    }
+    return nodes.length === 1
+        ? nodes[0]
+        : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, nodes]], ctx.peekSourceCodeInfo());
+}
+function assertImplicitBlockEnd(ctx, ends) {
+    if (!isImplicitBlockEnd(ctx, ends)) {
+        throw new LitsError(`Expected ${ends.map(e => e[1]).join(' or ')}`, ctx.peekSourceCodeInfo());
+    }
+}
+function isImplicitBlockEnd(ctx, ends) {
+    for (const end of ends) {
+        if (isReservedSymbolToken(ctx.tryPeek(), end)) {
+            return true;
         }
-        if (!isRParenToken(this.peek())) {
-            throw new LitsError('Expected closing parenthesis', this.peekSourceCodeInfo());
+    }
+    return false;
+}
+
+function parseIfOrUnless(ctx, token) {
+    const isUnless = token[1] === 'unless';
+    ctx.advance();
+    const condition = ctx.parseExpression();
+    assertReservedSymbolToken(ctx.tryPeek(), 'then');
+    ctx.advance();
+    const thenExpression = parseImplicitBlock(ctx, ['else', 'end']);
+    let elseExpression;
+    if (isReservedSymbolToken(ctx.tryPeek(), 'else')) {
+        ctx.advance();
+        elseExpression = parseImplicitBlock(ctx, ['end']);
+    }
+    ctx.advance();
+    return isUnless
+        ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.unless, [condition, thenExpression, elseExpression]]], token[2])
+        : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [condition, thenExpression, elseExpression]]], token[2]);
+}
+
+function parseCond(ctx, token) {
+    ctx.advance();
+    const params = [];
+    while (!ctx.isAtEnd() && !isReservedSymbolToken(ctx.tryPeek(), 'end')) {
+        assertReservedSymbolToken(ctx.tryPeek(), 'case');
+        ctx.advance();
+        const caseExpression = ctx.parseExpression();
+        assertReservedSymbolToken(ctx.tryPeek(), 'then');
+        ctx.advance();
+        const thenExpression = parseImplicitBlock(ctx, ['case', 'end']);
+        params.push([caseExpression, thenExpression]);
+        if (isReservedSymbolToken(ctx.tryPeek(), 'end')) {
+            break;
         }
-        this.advance();
-        if (isSpecialBuiltinSymbolNode(symbol)) { // Named function
-            const specialExpressionType = symbol[1];
-            const type = specialExpressionType;
-            const specialExpression = builtin.specialExpressions[type];
-            assertNumberOfParams(specialExpression.arity, params.length, symbol[2]);
-            switch (type) {
-                case specialExpressionTypes['||']:
-                    return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
-                case specialExpressionTypes['&&']:
-                    return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
-                case specialExpressionTypes.recur:
-                    return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
-                case specialExpressionTypes.array:
-                    return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
-                case specialExpressionTypes.object:
-                    return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
-                case specialExpressionTypes['??']:
-                    return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
-                case specialExpressionTypes['defined?']: {
-                    const [param] = params;
-                    return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
-                }
-                case specialExpressionTypes.throw: {
-                    const [param] = params;
-                    return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
-                }
-                case specialExpressionTypes['0_lambda']:
-                case specialExpressionTypes['0_def']:
-                    throw new LitsError(`${type} is not allowed`, symbol[2]);
-                /* v8 ignore next 2 */
-                default:
-                    throw new LitsError(`Unknown special expression: ${type}`, symbol[2]);
-            }
+    }
+    assertReservedSymbolToken(ctx.tryPeek());
+    ctx.advance();
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.cond, params]], token[2]);
+}
+
+function parseSwitch(ctx, token) {
+    ctx.advance();
+    const valueExpression = ctx.parseExpression();
+    const params = [];
+    while (!ctx.isAtEnd() && !isReservedSymbolToken(ctx.tryPeek(), 'end')) {
+        assertReservedSymbolToken(ctx.tryPeek(), 'case');
+        ctx.advance();
+        const caseExpression = ctx.parseExpression();
+        assertReservedSymbolToken(ctx.tryPeek(), 'then');
+        ctx.advance();
+        const thenExpression = parseImplicitBlock(ctx, ['case', 'end']);
+        params.push([caseExpression, thenExpression]);
+        if (isReservedSymbolToken(ctx.tryPeek(), 'end')) {
+            break;
         }
-        else if (isNormalBuiltinSymbolNode(symbol) || isUserDefinedSymbolNode(symbol)) {
-            return createNamedNormalExpressionNode(symbol, params, symbol[2]);
+    }
+    assertReservedSymbolToken(ctx.tryPeek(), 'end');
+    ctx.advance();
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.switch, valueExpression, params]], token[2]);
+}
+
+function parseForOrDoseq(ctx, firstToken) {
+    const isDoseq = firstToken[1] === 'doseq';
+    ctx.advance();
+    assertLParenToken(ctx.tryPeek());
+    ctx.advance();
+    const forLoopBindings = [];
+    while (!ctx.isAtEnd() && !isRParenToken(ctx.tryPeek())) {
+        const loopBinding = parseForLoopBinding(ctx);
+        const existingBoundNames = forLoopBindings.flatMap(b => Object.keys(getAllBindingTargetNames(b[0][1][0])));
+        const newBoundNames = getAllBindingTargetNames(loopBinding[0][1][0]);
+        if (Object.keys(newBoundNames).some(n => existingBoundNames.includes(n))) {
+            throw new LitsError('Duplicate binding', loopBinding[0][2]);
+        }
+        forLoopBindings.push(loopBinding);
+        if (isOperatorToken(ctx.tryPeek(), ',')) {
+            ctx.advance();
+        }
+    }
+    assertRParenToken(ctx.tryPeek());
+    ctx.advance();
+    assertOperatorToken(ctx.tryPeek(), '->');
+    ctx.advance();
+    const expression = ctx.parseExpression();
+    return isDoseq
+        ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.doseq, forLoopBindings, expression]], firstToken[2])
+        : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.for, forLoopBindings, expression]], firstToken[2]);
+}
+function parseForLoopBinding(ctx) {
+    const bindingNode = parseBinding(ctx);
+    const modifiers = [];
+    let token = ctx.peek();
+    assertInternalLoopBindingDelimiter(token, ['let', 'when', 'while']);
+    const letBindings = [];
+    if (token[1] === 'let') {
+        modifiers.push('&let');
+        while (isSymbolToken(token, 'let')) {
+            const letNode = parseLet(ctx, token);
+            const existingBoundNames = letBindings.flatMap(b => Object.keys(getAllBindingTargetNames(b[1][0])));
+            const newBoundNames = Object.keys(getAllBindingTargetNames(letNode[1][1][1][0]));
+            if (newBoundNames.some(n => existingBoundNames.includes(n))) {
+                throw new LitsError('Duplicate binding', letNode[1][1][2]);
+            }
+            letBindings.push(letNode[1][1]);
+            token = ctx.peek();
+            assertInternalLoopBindingDelimiter(token, ['let', 'when', 'while']);
+            token = ctx.peek();
+        }
+    }
+    let whenNode;
+    let whileNode;
+    while (isReservedSymbolToken(token, 'when')
+        || isReservedSymbolToken(token, 'while')) {
+        ctx.advance();
+        if (token[1] === 'when') {
+            modifiers.push('&when');
+            whenNode = ctx.parseExpression();
         }
         else {
-            return withSourceCodeInfo([NodeTypes.NormalExpression, [symbol, params]], symbol[2]);
-        }
+            modifiers.push('&while');
+            whileNode = ctx.parseExpression();
+        }
+        token = ctx.peek();
+        const symbols = modifiers.includes('&when') && modifiers.includes('&while')
+            ? []
+            : modifiers.includes('&when')
+                ? ['while']
+                : ['when'];
+        assertInternalLoopBindingDelimiter(token, symbols);
+        token = ctx.peek();
+    }
+    assertInternalLoopBindingDelimiter(token, []);
+    return [bindingNode, letBindings, whenNode, whileNode];
+}
+function parseBinding(ctx) {
+    const firstToken = asSymbolToken(ctx.tryPeek());
+    const name = asUserDefinedSymbolNode(parseSymbol(ctx));
+    assertReservedSymbolToken(ctx.tryPeek(), 'in');
+    ctx.advance();
+    const value = ctx.parseExpression();
+    const node = withSourceCodeInfo([
+        NodeTypes.Binding,
+        [
+            withSourceCodeInfo([bindingTargetTypes.symbol, [name, undefined]], firstToken[2]),
+            value,
+        ],
+    ], firstToken[2]);
+    return node;
+}
+function assertInternalLoopBindingDelimiter(token, symbols) {
+    if (!isInternalLoopBindingDelimiter(token, symbols)) {
+        const symbolsString = `${[...symbols, ','].map(symbol => `"${symbol}"`).join(', ')} or ")"`;
+        throw new LitsError(`Expected symbol ${symbolsString}`, token[2]);
     }
-    parseLambdaFunction() {
-        const firstToken = this.asToken(this.peek());
-        if (isLParenToken(firstToken)
-            && isSymbolToken(this.peekAhead(1))
-            && isOperatorToken(this.peekAhead(2), '->')) {
-            return null;
+}
+function isInternalLoopBindingDelimiter(token, symbols) {
+    // end of loop binding
+    if (isOperatorToken(token, ',') || isRParenToken(token)) {
+        return true;
+    }
+    for (const symbol of symbols) {
+        if (symbol === 'let' && isSymbolToken(token, 'let')) {
+            return true;
         }
-        try {
-            const functionArguments = this.parseFunctionArguments();
-            if (!isOperatorToken(this.peek(), '->')) {
-                return null;
-            }
-            this.advance();
-            let nodes;
-            let docString = '';
-            if (isReservedSymbolToken(this.peek(), 'do')) {
-                const parsedBlock = this.parseBlock(true);
-                docString = parsedBlock[1];
-                nodes = parsedBlock[0][1][1];
-            }
-            else {
-                nodes = [this.parseExpression()];
-            }
-            return withSourceCodeInfo([
-                NodeTypes.SpecialExpression,
-                [
-                    specialExpressionTypes['0_lambda'],
-                    [
-                        functionArguments,
-                        nodes,
-                    ],
-                    docString,
-                ],
-            ], firstToken[2]);
+        if (['when', 'while'].includes(symbol) && isReservedSymbolToken(token, symbol)) {
+            return true;
         }
-        catch {
-            return null;
+    }
+    return false;
+}
+
+function parseLoop(ctx, firstToken) {
+    ctx.advance();
+    assertLParenToken(ctx.tryPeek());
+    ctx.advance();
+    const bindingNodes = [];
+    let token = ctx.tryPeek();
+    while (!ctx.isAtEnd() && !isRParenToken(token)) {
+        const target = parseBindingTarget(ctx, { requireDefaultValue: true, noRest: true });
+        const value = target[1][1];
+        target[1][1] = undefined;
+        bindingNodes.push(withSourceCodeInfo([NodeTypes.Binding, [target, value]], target[2]));
+        if (isOperatorToken(ctx.tryPeek(), ',')) {
+            ctx.advance();
         }
+        token = ctx.tryPeek();
+    }
+    if (bindingNodes.length === 0) {
+        throw new LitsError('Expected binding', ctx.peekSourceCodeInfo());
     }
-    parseFunctionArguments() {
-        const firstToken = this.peek();
-        if (isSymbolToken(firstToken)) {
-            return [withSourceCodeInfo([bindingTargetTypes.symbol, [this.parseSymbol(), undefined]], firstToken[2])];
+    assertRParenToken(token);
+    ctx.advance();
+    assertOperatorToken(ctx.tryPeek(), '->');
+    ctx.advance();
+    const expression = ctx.parseExpression();
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.loop, bindingNodes, expression]], firstToken[2]);
+}
+
+function parseTry(ctx, token) {
+    ctx.advance();
+    const tryExpression = parseImplicitBlock(ctx, ['catch']);
+    ctx.advance();
+    let errorSymbol;
+    if (isLParenToken(ctx.tryPeek())) {
+        ctx.advance();
+        errorSymbol = parseSymbol(ctx);
+        assertRParenToken(ctx.tryPeek());
+        ctx.advance();
+    }
+    const catchExpression = parseImplicitBlock(ctx, ['end']);
+    ctx.advance();
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.try, tryExpression, errorSymbol, catchExpression]], token[2]);
+}
+
+function parseString(ctx, token) {
+    ctx.advance();
+    const value = token[1].substring(1, token[1].length - 1)
+        .replace(/(\\{2})|(\\")|(\\n)|(\\t)|(\\r)|(\\b)|(\\f)|\\(.)/g, (_, backslash, doubleQuote, newline, tab, carriageReturn, backspace, formFeed, normalChar) => {
+        // If it's a double escape (\\x), return \x
+        if (backslash) {
+            return '\\';
         }
-        assertLParenToken(firstToken);
-        this.advance();
-        let rest = false;
-        let defaults = false;
-        const functionArguments = [];
-        while (!this.isAtEnd() && !isRParenToken(this.peek()) && !isSymbolToken(this.peek(), 'let')) {
-            if (rest) {
-                throw new LitsError('Rest argument must be last', this.peekSourceCodeInfo());
-            }
-            const bindingTarget = this.parseBindingTarget();
-            if (bindingTarget[1][1] !== undefined) {
-                defaults = true;
-            }
-            if (bindingTarget[0] === bindingTargetTypes.rest) {
-                rest = true;
-            }
-            if (defaults && !bindingTarget[1][1]) {
-                throw new LitsError('Default arguments must be last', this.peekSourceCodeInfo());
-            }
-            functionArguments.push(bindingTarget);
-            if (!isOperatorToken(this.peek(), ',') && !isRParenToken(this.peek()) && !isSymbolToken(this.peek(), 'let')) {
-                throw new LitsError('Expected comma or closing parenthesis', this.peekSourceCodeInfo());
-            }
-            if (isOperatorToken(this.peek(), ',')) {
-                this.advance();
-            }
+        // If it's a special character (\n, \t, \r, \b, \f), return the special character
+        else if (newline) {
+            return '\n';
         }
-        if (!isRParenToken(this.peek())) {
-            throw new LitsError('Expected closing parenthesis', this.peekSourceCodeInfo());
+        else if (tab) {
+            return '\t';
         }
-        this.advance();
-        return functionArguments;
-    }
-    parseShorthandLambdaFunction() {
-        const firstToken = this.asToken(this.peek());
-        this.advance();
-        const startPos = this.parseState.position;
-        let nodes;
-        let docString = '';
-        if (isReservedSymbolToken(this.peek(), 'do')) {
-            const parsedBlock = this.parseBlock(true);
-            docString = parsedBlock[1];
-            nodes = parsedBlock[0][1][1];
+        else if (carriageReturn) {
+            return '\r';
         }
-        else {
-            nodes = [this.parseExpression()];
-        }
-        const endPos = this.parseState.position - 1;
-        let arity = 0;
-        let dollar1 = 'NOT_SET'; // referring to argument bindings. $ = NAKED, $1, $2, $3, etc = WITH_1
-        for (let pos = startPos; pos <= endPos; pos += 1) {
-            const token = this.tokenStream.tokens[pos];
-            if (isSymbolToken(token)) {
-                const match = placeholderRegexp.exec(token[1]);
-                if (match) {
-                    const number = match[1] ?? '1';
-                    if (number === '1') {
-                        const mixedPercent1 = (!match[1] && dollar1 === 'WITH_1') || (match[1] && dollar1 === 'NAKED');
-                        if (mixedPercent1)
-                            throw new LitsError('Please make up your mind, either use $ or $1', firstToken[2]);
-                        dollar1 = match[1] ? 'WITH_1' : 'NAKED';
-                    }
-                    arity = Math.max(arity, Number(number));
-                    if (arity > maxShorthandLambdaArity)
-                        throw new LitsError('Can\'t specify more than 20 arguments', firstToken[2]);
-                }
-            }
+        else if (backspace) {
+            return '\b';
         }
-        const functionArguments = [];
-        for (let i = 1; i <= arity; i += 1) {
-            if (i === 1 && dollar1 === 'NAKED') {
-                functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, '$'], undefined]], firstToken[2]));
-            }
-            else {
-                functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, `$${i}`], undefined]], firstToken[2]));
-            }
+        else if (formFeed) {
+            return '\f';
         }
-        const node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_lambda'], [
-                    functionArguments,
-                    nodes,
-                ], docString]], firstToken[2]);
-        return node;
-    }
-    parseOptionalDefaulValue() {
-        if (isOperatorToken(this.peek(), '=')) {
-            this.advance();
-            return this.parseExpression();
-        }
-        return undefined;
-    }
-    parseBindingTarget({ requireDefaultValue, noRest } = {}) {
-        const firstToken = this.peek();
-        // Symbol
-        if (isSymbolToken(firstToken)) {
-            const symbol = this.parseSymbol();
-            if (!isUserDefinedSymbolNode(symbol)) {
-                throw new LitsError('Expected user defined symbol', firstToken[2]);
-            }
-            const defaultValue = this.parseOptionalDefaulValue();
-            if (requireDefaultValue && !defaultValue) {
-                throw new LitsError('Expected assignment', this.peekSourceCodeInfo());
-            }
-            return withSourceCodeInfo([bindingTargetTypes.symbol, [symbol, defaultValue]], firstToken[2]);
-        }
-        // Rest
-        if (isOperatorToken(firstToken, '...')) {
-            if (noRest) {
-                throw new LitsError('Rest element not allowed', firstToken[2]);
-            }
-            this.advance();
-            const symbol = asUserDefinedSymbolNode(this.parseSymbol());
-            if (isOperatorToken(this.peek(), '=')) {
-                throw new LitsError('Rest argument can not have default value', this.peekSourceCodeInfo());
-            }
-            return withSourceCodeInfo([bindingTargetTypes.rest, [symbol[1], undefined]], firstToken[2]);
-        }
-        // Array
-        if (isLBracketToken(firstToken)) {
-            this.advance();
-            const elements = [];
-            let token = this.asToken(this.peek());
-            let rest = false;
-            while (!isRBracketToken(token)) {
-                if (rest) {
-                    throw new LitsError('Rest argument must be last', token[2]);
-                }
-                if (isOperatorToken(token, ',')) {
-                    elements.push(null);
-                    this.advance();
-                    token = this.asToken(this.peek());
-                    continue;
-                }
-                const target = this.parseBindingTarget();
-                if (target[0] === bindingTargetTypes.rest) {
-                    rest = true;
-                }
-                elements.push(target);
-                token = this.asToken(this.peek());
-                if (!isRBracketToken(token)) {
-                    assertOperatorToken(token, ',');
-                    this.advance();
-                }
-                token = this.asToken(this.peek());
-            }
-            this.advance();
-            const defaultValue = this.parseOptionalDefaulValue();
-            if (requireDefaultValue && !defaultValue) {
-                throw new LitsError('Expected assignment', this.peekSourceCodeInfo());
-            }
-            return withSourceCodeInfo([bindingTargetTypes.array, [elements, defaultValue]], firstToken[2]);
-        }
-        // Object
-        if (isLBraceToken(firstToken)) {
-            this.advance();
-            const elements = {};
-            let token = this.asToken(this.peek());
-            let rest = false;
-            while (!isRBraceToken(token)) {
-                if (rest) {
-                    throw new LitsError('Rest argument must be last', token[2]);
-                }
-                if (isOperatorToken(token, '...')) {
-                    rest = true;
-                    this.advance();
-                }
-                // Parse the key symbol - can be any symbol type (including builtins) when using 'as' alias
-                const keySymbol = this.parseSymbol();
-                const keyName = getSymbolName(keySymbol);
-                token = this.asToken(this.peek());
-                if (isReservedSymbolToken(token, 'as')) {
-                    if (rest) {
-                        throw new LitsError('Rest argument can not have alias', token[2]);
-                    }
-                    this.advance();
-                    const name = asUserDefinedSymbolNode(this.parseSymbol());
-                    if (elements[name[1]]) {
-                        throw new LitsError(`Duplicate binding name: ${name}`, token[2]);
-                    }
-                    elements[keyName] = withSourceCodeInfo([bindingTargetTypes.symbol, [name, this.parseOptionalDefaulValue()]], firstToken[2]);
-                }
-                else if (isRBraceToken(token) || isOperatorToken(token, ',') || isOperatorToken(token, '=')) {
-                    // Without 'as' alias, the key becomes the binding name - must be user-defined symbol
-                    const key = asUserDefinedSymbolNode(keySymbol, keySymbol[2]);
-                    if (elements[key[1]]) {
-                        throw new LitsError(`Duplicate binding name: ${key}`, token[2]);
-                    }
-                    if (rest && isOperatorToken(this.peek(), '=')) {
-                        throw new LitsError('Rest argument can not have default value', this.peekSourceCodeInfo());
-                    }
-                    elements[key[1]] = rest
-                        ? withSourceCodeInfo([bindingTargetTypes.rest, [key[1], this.parseOptionalDefaulValue()]], firstToken[2])
-                        : withSourceCodeInfo([bindingTargetTypes.symbol, [key, this.parseOptionalDefaulValue()]], firstToken[2]);
-                }
-                else if (isOperatorToken(token, ':')) {
-                    this.advance();
-                    token = this.asToken(this.peek());
-                    if (!isLBraceToken(token) && !isLBracketToken(token)) {
-                        throw new LitsError('Expected object or array', token[2]);
-                    }
-                    elements[keyName] = this.parseBindingTarget();
-                }
-                if (!isRBraceToken(this.peek())) {
-                    assertOperatorToken(this.peek(), ',');
-                    this.advance();
-                }
-                token = this.asToken(this.peek());
-            }
-            this.advance();
-            token = this.asToken(this.peek());
-            const defaultValue = this.parseOptionalDefaulValue();
-            if (requireDefaultValue && !defaultValue) {
-                throw new LitsError('Expected assignment', token[2]);
-            }
-            return withSourceCodeInfo([bindingTargetTypes.object, [elements, defaultValue]], firstToken[2]);
+        else if (doubleQuote) {
+            return '"';
         }
-        throw new LitsError('Expected symbol', this.peekSourceCodeInfo());
-    }
-    parseLet(token) {
-        this.advance();
-        const target = this.parseBindingTarget({ requireDefaultValue: true, noRest: true });
-        const value = target[1][1];
-        target[1][1] = undefined;
-        const bindingTarget = withSourceCodeInfo([NodeTypes.Binding, [target, value]], token[2]);
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.let, bindingTarget]], token[2]);
+        return normalChar;
+    });
+    return withSourceCodeInfo([NodeTypes.String, value], token[2]);
+}
+
+function parseDo(ctx, allowDocString = false) {
+    const token = asReservedSymbolToken(ctx.tryPeek(), 'do');
+    ctx.advance();
+    let docString = '';
+    if (allowDocString && isDocStringToken(ctx.tryPeek())) {
+        docString = parseDocString(ctx);
     }
-    parseBlock(allowDocString = false) {
-        const token = asReservedSymbolToken(this.peek(), 'do');
-        this.advance();
-        let docString = '';
-        if (allowDocString && isDocStringToken(this.peek())) {
-            docString = this.parseDocString();
+    const expressions = [];
+    while (!ctx.isAtEnd() && !isReservedSymbolToken(ctx.tryPeek(), 'end')) {
+        expressions.push(ctx.parseExpression());
+        if (isOperatorToken(ctx.tryPeek(), ';')) {
+            ctx.advance();
         }
-        const expressions = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
-            expressions.push(this.parseExpression());
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected end', this.peekSourceCodeInfo());
-            }
+        else if (!isReservedSymbolToken(ctx.tryPeek(), 'end')) {
+            throw new LitsError('Expected end', ctx.peekSourceCodeInfo());
         }
-        assertReservedSymbolToken(this.peek(), 'end');
-        this.advance();
-        return [
-            withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]),
-            docString,
-        ];
     }
-    parseImplicitBlock(ends) {
-        const nodes = [];
-        while (!this.isAtEnd() && !this.isImplicitBlockEnd(ends)) {
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else {
-                nodes.push(this.parseExpression());
-            }
+    assertReservedSymbolToken(ctx.tryPeek(), 'end');
+    ctx.advance();
+    return [
+        withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]),
+        docString,
+    ];
+}
+function parseDocString(ctx) {
+    const token = ctx.peek();
+    const stringToken = token[2] ? ['string', token[1].slice(2, -2), token[2]] : ['string', token[1].slice(2, -2)];
+    const stringNode = parseString(ctx, stringToken);
+    return smartTrim(stringNode[1]); // Extract the string value from the StringNode
+}
+
+function parseRegexpShorthand(ctx) {
+    const token = ctx.peek();
+    ctx.advance();
+    const endStringPosition = token[1].lastIndexOf('"');
+    const regexpString = token[1].substring(2, endStringPosition);
+    const optionsString = token[1].substring(endStringPosition + 1);
+    const stringNode = withSourceCodeInfo([NodeTypes.String, regexpString], token[2]);
+    const optionsNode = withSourceCodeInfo([NodeTypes.String, optionsString], token[2]);
+    const node = withSourceCodeInfo([
+        NodeTypes.NormalExpression,
+        [
+            withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes.regexp], token[2]),
+            [stringNode, optionsNode],
+        ],
+    ], token[2]);
+    return node;
+}
+
+function parseReservedSymbol(ctx) {
+    const token = asReservedSymbolToken(ctx.tryPeek());
+    ctx.advance();
+    const symbol = token[1];
+    if (isNumberReservedSymbol(symbol)) {
+        return withSourceCodeInfo([NodeTypes.Number, numberReservedSymbolRecord[symbol]], token[2]);
+    }
+    return withSourceCodeInfo([NodeTypes.ReservedSymbol, token[1]], token[2]);
+}
+
+function parseArray(ctx) {
+    const firstToken = asLBracketToken(ctx.tryPeek());
+    ctx.advance();
+    const params = [];
+    while (!ctx.isAtEnd() && !isRBracketToken(ctx.tryPeek())) {
+        if (isOperatorToken(ctx.tryPeek(), '...')) {
+            ctx.advance();
+            params.push(withSourceCodeInfo([NodeTypes.Spread, ctx.parseExpression()], ctx.peekSourceCodeInfo()));
         }
-        this.assertImplicitBlockEnd(ends);
-        if (nodes.length === 0) {
-            throw new LitsError('Expected expression', this.peekSourceCodeInfo());
+        else {
+            params.push(ctx.parseExpression());
         }
-        return nodes.length === 1
-            ? nodes[0]
-            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, nodes]], this.peekSourceCodeInfo());
-    }
-    assertImplicitBlockEnd(ends) {
-        if (!this.isImplicitBlockEnd(ends)) {
-            throw new LitsError(`Expected ${ends.map(e => e[1]).join(' or ')}`, this.peekSourceCodeInfo());
+        const nextToken = ctx.tryPeek();
+        if (!isOperatorToken(nextToken, ',') && !isRBracketToken(nextToken)) {
+            throw new LitsError('Expected comma or closing parenthesis', ctx.peekSourceCodeInfo());
         }
-    }
-    isImplicitBlockEnd(ends) {
-        for (const end of ends) {
-            if (isReservedSymbolToken(this.peek(), end)) {
-                return true;
-            }
+        if (isOperatorToken(nextToken, ',')) {
+            ctx.advance();
         }
-        return false;
     }
-    parseLoop(firstToken) {
-        this.advance();
-        assertLParenToken(this.peek());
-        this.advance();
-        const bindingNodes = [];
-        let token = this.peek();
-        while (!this.isAtEnd() && !isRParenToken(token)) {
-            const target = this.parseBindingTarget({ requireDefaultValue: true, noRest: true });
-            const value = target[1][1];
-            target[1][1] = undefined;
-            bindingNodes.push(withSourceCodeInfo([NodeTypes.Binding, [target, value]], target[2]));
-            if (isOperatorToken(this.peek(), ',')) {
-                this.advance();
-            }
-            token = this.peek();
-        }
-        if (bindingNodes.length === 0) {
-            throw new LitsError('Expected binding', this.peekSourceCodeInfo());
-        }
-        assertRParenToken(token);
-        this.advance();
-        assertOperatorToken(this.peek(), '->');
-        this.advance();
-        const expression = this.parseExpression();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.loop, bindingNodes, expression]], firstToken[2]);
-    }
-    parseTry(token) {
-        this.advance();
-        const tryExpression = this.parseImplicitBlock(['catch']);
-        this.advance();
-        let errorSymbol;
-        if (isLParenToken(this.peek())) {
-            this.advance();
-            errorSymbol = this.parseSymbol();
-            assertRParenToken(this.peek());
-            this.advance();
-        }
-        const catchExpression = this.parseImplicitBlock(['end']);
-        this.advance();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.try, tryExpression, errorSymbol, catchExpression]], token[2]);
-    }
-    parseForOrDoseq(firstToken) {
-        const isDoseq = firstToken[1] === 'doseq';
-        this.advance();
-        assertLParenToken(this.peek());
-        this.advance();
-        const forLoopBindings = [];
-        while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-            const loopBinding = this.parseForLoopBinding();
-            const existingBoundNames = forLoopBindings.flatMap(b => Object.keys(getAllBindingTargetNames(b[0][1][0])));
-            const newBoundNames = getAllBindingTargetNames(loopBinding[0][1][0]);
-            if (Object.keys(newBoundNames).some(n => existingBoundNames.includes(n))) {
-                throw new LitsError('Duplicate binding', loopBinding[0][2]);
-            }
-            forLoopBindings.push(loopBinding);
-            if (isOperatorToken(this.peek(), ',')) {
-                this.advance();
-            }
-        }
-        assertRParenToken(this.peek());
-        this.advance();
-        assertOperatorToken(this.peek(), '->');
-        this.advance();
-        const expression = this.parseExpression();
-        return isDoseq
-            ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.doseq, forLoopBindings, expression]], firstToken[2])
-            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.for, forLoopBindings, expression]], firstToken[2]);
-    }
-    parseForLoopBinding() {
-        const bindingNode = this.parseBinding();
-        const modifiers = [];
-        let token = this.asToken(this.peek());
-        this.assertInternalLoopBindingDelimiter(token, ['let', 'when', 'while']);
-        const letBindings = [];
-        if (token[1] === 'let') {
-            modifiers.push('&let');
-            while (isSymbolToken(token, 'let')) {
-                const letNode = this.parseLet(token);
-                const existingBoundNames = letBindings.flatMap(b => Object.keys(getAllBindingTargetNames(b[1][0])));
-                const newBoundNames = Object.keys(getAllBindingTargetNames(letNode[1][1][1][0]));
-                if (newBoundNames.some(n => existingBoundNames.includes(n))) {
-                    throw new LitsError('Duplicate binding', letNode[1][1][2]);
-                }
-                letBindings.push(letNode[1][1]);
-                token = this.asToken(this.peek());
-                this.assertInternalLoopBindingDelimiter(token, ['let', 'when', 'while']);
-                token = this.asToken(this.peek());
-            }
+    assertRBracketToken(ctx.tryPeek());
+    ctx.advance();
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.array, params]], firstToken[2]);
+}
+
+const placeholderRegexp = /^\$([1-9]\d?)?$/;
+const maxShorthandLambdaArity = 20;
+function parseLambdaFunction(ctx) {
+    const firstToken = ctx.peek();
+    if (isLParenToken(firstToken)
+        && isSymbolToken(ctx.peekAhead(1))
+        && isOperatorToken(ctx.peekAhead(2), '->')) {
+        return null;
+    }
+    try {
+        const functionArguments = parseFunctionArguments(ctx);
+        if (!isOperatorToken(ctx.peek(), '->')) {
+            return null;
         }
-        let whenNode;
-        let whileNode;
-        while (isReservedSymbolToken(token, 'when')
-            || isReservedSymbolToken(token, 'while')) {
-            this.advance();
-            if (token[1] === 'when') {
-                modifiers.push('&when');
-                whenNode = this.parseExpression();
-            }
-            else {
-                modifiers.push('&while');
-                whileNode = this.parseExpression();
-            }
-            token = this.asToken(this.peek());
-            const symbols = modifiers.includes('&when') && modifiers.includes('&while')
-                ? []
-                : modifiers.includes('&when')
-                    ? ['while']
-                    : ['when'];
-            this.assertInternalLoopBindingDelimiter(token, symbols);
-            token = this.asToken(this.peek());
-        }
-        this.assertInternalLoopBindingDelimiter(token, []);
-        return [bindingNode, letBindings, whenNode, whileNode];
-    }
-    assertInternalLoopBindingDelimiter(token, symbols) {
-        if (!this.isInternalLoopBindingDelimiter(token, symbols)) {
-            const symbolsString = `${[...symbols, ','].map(symbol => `"${symbol}"`).join(', ')} or ")"`;
-            throw new LitsError(`Expected symbol ${symbolsString}`, token[2]);
-        }
-    }
-    isInternalLoopBindingDelimiter(token, symbols) {
-        // end of loop binding
-        if (isOperatorToken(token, ',') || isRParenToken(token)) {
-            return true;
+        ctx.advance();
+        let nodes;
+        let docString = '';
+        if (isReservedSymbolToken(ctx.peek(), 'do')) {
+            const parsedDo = parseDo(ctx, true);
+            docString = parsedDo[1];
+            nodes = parsedDo[0][1][1];
         }
-        for (const symbol of symbols) {
-            if (symbol === 'let' && isSymbolToken(token, 'let')) {
-                return true;
-            }
-            if (['when', 'while'].includes(symbol) && isReservedSymbolToken(token, symbol)) {
-                return true;
-            }
+        else {
+            nodes = [ctx.parseExpression()];
         }
-        return false;
-    }
-    parseBinding() {
-        const firstToken = asSymbolToken(this.peek());
-        const name = asUserDefinedSymbolNode(this.parseSymbol());
-        assertReservedSymbolToken(this.peek(), 'in');
-        this.advance();
-        const value = this.parseExpression();
-        const node = withSourceCodeInfo([
-            NodeTypes.Binding,
+        return withSourceCodeInfo([
+            NodeTypes.SpecialExpression,
             [
-                withSourceCodeInfo([bindingTargetTypes.symbol, [name, undefined]], firstToken[2]),
-                value,
+                specialExpressionTypes['0_lambda'],
+                [
+                    functionArguments,
+                    nodes,
+                ],
+                docString,
             ],
         ], firstToken[2]);
-        return node;
-    }
-    parseIfOrUnless(token) {
-        const isUnless = token[1] === 'unless';
-        this.advance();
-        const condition = this.parseExpression();
-        assertReservedSymbolToken(this.peek(), 'then');
-        this.advance();
-        const thenExpression = this.parseImplicitBlock(['else', 'end']);
-        let elseExpression;
-        if (isReservedSymbolToken(this.peek(), 'else')) {
-            this.advance();
-            elseExpression = this.parseImplicitBlock(['end']);
-        }
-        this.advance();
-        return isUnless
-            ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.unless, [condition, thenExpression, elseExpression]]], token[2])
-            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [condition, thenExpression, elseExpression]]], token[2]);
-    }
-    parseCond(token) {
-        this.advance();
-        const params = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
-            assertReservedSymbolToken(this.peek(), 'case');
-            this.advance();
-            const caseExpression = this.parseExpression();
-            assertReservedSymbolToken(this.peek(), 'then');
-            this.advance();
-            const thenExpression = this.parseImplicitBlock(['case', 'end']);
-            params.push([caseExpression, thenExpression]);
-            if (isReservedSymbolToken(this.peek(), 'end')) {
-                break;
-            }
-        }
-        assertReservedSymbolToken(this.peek());
-        this.advance();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.cond, params]], token[2]);
-    }
-    parseSwitch(token) {
-        this.advance();
-        const valueExpression = this.parseExpression();
-        const params = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
-            assertReservedSymbolToken(this.peek(), 'case');
-            this.advance();
-            const caseExpression = this.parseExpression();
-            assertReservedSymbolToken(this.peek(), 'then');
-            this.advance();
-            const thenExpression = this.parseImplicitBlock(['case', 'end']);
-            params.push([caseExpression, thenExpression]);
-            if (isReservedSymbolToken(this.peek(), 'end')) {
-                break;
-            }
-        }
-        assertReservedSymbolToken(this.peek(), 'end');
-        this.advance();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.switch, valueExpression, params]], token[2]);
     }
-    isAtEnd() {
-        return this.parseState.position >= this.tokenStream.tokens.length;
+    catch {
+        return null;
     }
-    isAtExpressionEnd() {
-        if (this.isAtEnd()) {
-            return true;
-        }
-        const token = this.peek();
-        if (isOperatorToken(token)) {
-            return [';', ',', ':'].includes(token[1]);
+}
+function parseFunctionArguments(ctx) {
+    const firstToken = ctx.peek();
+    if (isSymbolToken(firstToken)) {
+        return [withSourceCodeInfo([bindingTargetTypes.symbol, [parseSymbol(ctx), undefined]], firstToken[2])];
+    }
+    assertLParenToken(firstToken);
+    ctx.advance();
+    let rest = false;
+    let defaults = false;
+    const functionArguments = [];
+    while (!ctx.isAtEnd() && !isRParenToken(ctx.peek()) && !isSymbolToken(ctx.peek(), 'let')) {
+        if (rest) {
+            throw new LitsError('Rest argument must be last', ctx.peekSourceCodeInfo());
         }
-        if (isReservedSymbolToken(token)) {
-            return ['else', 'when', 'while', 'case', 'catch', 'let', 'then', 'end', 'do'].includes(token[1]);
+        const bindingTarget = parseBindingTarget(ctx);
+        if (bindingTarget[1][1] !== undefined) {
+            defaults = true;
         }
-        return false;
-    }
-    parseExport(exportToken) {
-        this.advance();
-        const token = this.peek();
-        if (isSymbolToken(token, 'let')) {
-            const letNode = this.parseLet(asSymbolToken(token));
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], exportToken[2]);
+        if (bindingTarget[0] === bindingTargetTypes.rest) {
+            rest = true;
         }
-        else {
-            throw new LitsError('Expected let', this.peekSourceCodeInfo());
+        if (defaults && !bindingTarget[1][1]) {
+            throw new LitsError('Default arguments must be last', ctx.peekSourceCodeInfo());
         }
-    }
-    stringToSymbolNode(value, sourceCodeInfo) {
-        if (specialExpressionTypes[value] !== undefined && value !== 'fn' && value !== 'def' && value !== 'defn') {
-            return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[value]], sourceCodeInfo);
+        functionArguments.push(bindingTarget);
+        if (!isOperatorToken(ctx.peek(), ',') && !isRParenToken(ctx.peek()) && !isSymbolToken(ctx.peek(), 'let')) {
+            throw new LitsError('Expected comma or closing parenthesis', ctx.peekSourceCodeInfo());
         }
-        if (normalExpressionTypes[value] !== undefined) {
-            return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[value]], sourceCodeInfo);
+        if (isOperatorToken(ctx.peek(), ',')) {
+            ctx.advance();
         }
-        return withSourceCodeInfo([NodeTypes.UserDefinedSymbol, value], sourceCodeInfo);
     }
-    stringFromQuotedSymbol(value) {
-        return value.substring(1, value.length - 1)
-            .replace(/(\\{2})|(\\')|\\(.)/g, (_, backslash, singleQuote, normalChar) => {
-            if (backslash) {
-                return '\\';
-            }
-            if (singleQuote) {
-                return '\'';
-            }
-            return `\\${normalChar}`;
-        });
+    if (!isRParenToken(ctx.peek())) {
+        throw new LitsError('Expected closing parenthesis', ctx.peekSourceCodeInfo());
+    }
+    ctx.advance();
+    return functionArguments;
+}
+function parseShorthandLambdaFunction(ctx) {
+    const firstToken = ctx.peek();
+    ctx.advance();
+    // TODO, do not like this...
+    const startPos = ctx.getPosition();
+    let nodes;
+    let docString = '';
+    if (isReservedSymbolToken(ctx.peek(), 'do')) {
+        const parsedDo = parseDo(ctx, true);
+        docString = parsedDo[1];
+        nodes = parsedDo[0][1][1];
     }
-    parseSymbol() {
-        const token = this.asToken(this.peek());
-        this.advance();
-        if (!isSymbolToken(token)) {
-            throw new LitsError(`Expected symbol token, got ${token[0]}`, token[2]);
+    else {
+        nodes = [ctx.parseExpression()];
+    }
+    const endPos = ctx.getPosition() - 1;
+    let arity = 0;
+    let dollar1 = 'NOT_SET'; // referring to argument bindings. $ = NAKED, $1, $2, $3, etc = WITH_1
+    for (let pos = startPos; pos <= endPos; pos += 1) {
+        const token = ctx.getTokenAt(pos);
+        if (isSymbolToken(token)) {
+            const match = placeholderRegexp.exec(token[1]);
+            if (match) {
+                const number = match[1] ?? '1';
+                if (number === '1') {
+                    const mixedPercent1 = (!match[1] && dollar1 === 'WITH_1') || (match[1] && dollar1 === 'NAKED');
+                    if (mixedPercent1)
+                        throw new LitsError('Please make up your mind, either use $ or $1', firstToken[2]);
+                    dollar1 = match[1] ? 'WITH_1' : 'NAKED';
+                }
+                arity = Math.max(arity, Number(number));
+                if (arity > maxShorthandLambdaArity)
+                    throw new LitsError('Can\'t specify more than 20 arguments', firstToken[2]);
+            }
         }
-        if (token[1][0] === '\'') {
-            return this.stringToSymbolNode(this.stringFromQuotedSymbol(token[1]), token[2]);
+    }
+    const functionArguments = [];
+    for (let i = 1; i <= arity; i += 1) {
+        if (i === 1 && dollar1 === 'NAKED') {
+            functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, '$'], undefined]], firstToken[2]));
         }
         else {
-            return this.stringToSymbolNode(token[1], token[2]);
+            functionArguments.push(withSourceCodeInfo([bindingTargetTypes.symbol, [[NodeTypes.UserDefinedSymbol, `$${i}`], undefined]], firstToken[2]));
         }
     }
-    parseReservedSymbol() {
-        const token = asReservedSymbolToken(this.peek());
-        this.advance();
-        const symbol = token[1];
-        if (isNumberReservedSymbol(symbol)) {
-            return withSourceCodeInfo([NodeTypes.Number, numberReservedSymbolRecord[symbol]], token[2]);
+    const node = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_lambda'], [
+                functionArguments,
+                nodes,
+            ], docString]], firstToken[2]);
+    return node;
+}
+
+function parseFunctionCall(ctx, symbol) {
+    ctx.advance();
+    const params = [];
+    while (!ctx.isAtEnd() && !isRParenToken(ctx.tryPeek())) {
+        if (isOperatorToken(ctx.tryPeek(), '...')) {
+            ctx.advance();
+            params.push(withSourceCodeInfo([NodeTypes.Spread, ctx.parseExpression()], ctx.peekSourceCodeInfo()));
+        }
+        else {
+            params.push(ctx.parseExpression());
+        }
+        const nextToken = ctx.tryPeek();
+        if (!isOperatorToken(nextToken, ',') && !isRParenToken(nextToken)) {
+            throw new LitsError('Expected comma or closing parenthesis', ctx.tryPeek()?.[2]);
+        }
+        if (isOperatorToken(nextToken, ',')) {
+            ctx.advance();
+        }
+    }
+    if (!isRParenToken(ctx.tryPeek())) {
+        throw new LitsError('Expected closing parenthesis', ctx.peekSourceCodeInfo());
+    }
+    ctx.advance();
+    if (isSpecialBuiltinSymbolNode(symbol)) { // Named function
+        const specialExpressionType = symbol[1];
+        const type = specialExpressionType;
+        const specialExpression = builtin.specialExpressions[type];
+        assertNumberOfParams(specialExpression.arity, params.length, symbol[2]);
+        switch (type) {
+            case specialExpressionTypes['||']:
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+            case specialExpressionTypes['&&']:
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+            case specialExpressionTypes.recur:
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+            case specialExpressionTypes.array:
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+            case specialExpressionTypes.object:
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+            case specialExpressionTypes['??']:
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, params]], symbol[2]);
+            case specialExpressionTypes['defined?']: {
+                const [param] = params;
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
+            }
+            case specialExpressionTypes.throw: {
+                const [param] = params;
+                return withSourceCodeInfo([NodeTypes.SpecialExpression, [type, param]], symbol[2]);
+            }
+            case specialExpressionTypes['0_lambda']:
+            case specialExpressionTypes['0_def']:
+                throw new LitsError(`${type} is not allowed`, symbol[2]);
+            /* v8 ignore next 2 */
+            default:
+                throw new LitsError(`Unknown special expression: ${type}`, symbol[2]);
         }
-        return withSourceCodeInfo([NodeTypes.ReservedSymbol, token[1]], token[2]);
     }
-    parseNumber() {
-        const token = this.asToken(this.peek());
-        this.advance();
-        const value = token[1];
-        const negative = value[0] === '-';
-        const numberString = (negative ? value.substring(1) : value).replace(/_/g, '');
-        return withSourceCodeInfo([NodeTypes.Number, negative ? -Number(numberString) : Number(numberString)], token[2]);
+    else if (isNormalBuiltinSymbolNode(symbol) || isUserDefinedSymbolNode(symbol)) {
+        return createNamedNormalExpressionNode(symbol, params, symbol[2]);
     }
-    parseDocString() {
-        const token = this.asToken(this.peek());
-        const stringToken = token[2] ? ['string', token[1].slice(2, -2), token[2]] : ['string', token[1].slice(2, -2)];
-        const stringNode = this.parseString(stringToken);
-        return smartTrim(stringNode[1]); // Extract the string value from the StringNode
+    else {
+        return withSourceCodeInfo([NodeTypes.NormalExpression, [symbol, params]], symbol[2]);
     }
-    parseString(token) {
-        this.advance();
-        const value = token[1].substring(1, token[1].length - 1)
-            .replace(/(\\{2})|(\\")|(\\n)|(\\t)|(\\r)|(\\b)|(\\f)|\\(.)/g, (_, backslash, doubleQuote, newline, tab, carriageReturn, backspace, formFeed, normalChar) => {
-            // If it's a double escape (\\x), return \x
-            if (backslash) {
-                return '\\';
-            }
-            // If it's a special character (\n, \t, \r, \b, \f), return the special character
-            else if (newline) {
-                return '\n';
-            }
-            else if (tab) {
-                return '\t';
-            }
-            else if (carriageReturn) {
-                return '\r';
-            }
-            else if (backspace) {
-                return '\b';
+}
+
+function parseNumber(ctx) {
+    const token = ctx.peek();
+    ctx.advance();
+    const value = token[1];
+    const negative = value[0] === '-';
+    const numberString = (negative ? value.substring(1) : value).replace(/_/g, '');
+    return withSourceCodeInfo([NodeTypes.Number, negative ? -Number(numberString) : Number(numberString)], token[2]);
+}
+
+function parseObject(ctx) {
+    const firstToken = asLBraceToken(ctx.tryPeek());
+    ctx.advance();
+    const params = [];
+    while (!ctx.isAtEnd() && !isRBraceToken(ctx.tryPeek())) {
+        if (isOperatorToken(ctx.tryPeek(), '...')) {
+            ctx.advance();
+            params.push(withSourceCodeInfo([NodeTypes.Spread, ctx.parseExpression()], ctx.peekSourceCodeInfo()));
+        }
+        else {
+            const token = ctx.tryPeek();
+            if (isStringToken(token)) {
+                const stringNode = parseString(ctx, token);
+                params.push(withSourceCodeInfo([NodeTypes.String, stringNode[1]], token[2]));
+            }
+            else if (isSymbolToken(token)) {
+                const value = token[1].startsWith('\'')
+                    ? stringFromQuotedSymbol(token[1])
+                    : token[1];
+                params.push(withSourceCodeInfo([NodeTypes.String, value], token[2]));
+                ctx.advance();
             }
-            else if (formFeed) {
-                return '\f';
+            else if (isLBracketToken(token)) {
+                ctx.advance();
+                params.push(ctx.parseExpression());
+                assertRBracketToken(ctx.tryPeek());
+                ctx.advance();
             }
-            else if (doubleQuote) {
-                return '"';
+            else {
+                throw new LitsError('Expected key to be a symbol or a string', ctx.peekSourceCodeInfo());
             }
-            return normalChar;
-        });
-        return withSourceCodeInfo([NodeTypes.String, value], token[2]);
-    }
-    parseRegexpShorthand() {
-        const token = this.asToken(this.peek());
-        this.advance();
-        const endStringPosition = token[1].lastIndexOf('"');
-        const regexpString = token[1].substring(2, endStringPosition);
-        const optionsString = token[1].substring(endStringPosition + 1);
-        const stringNode = withSourceCodeInfo([NodeTypes.String, regexpString], token[2]);
-        const optionsNode = withSourceCodeInfo([NodeTypes.String, optionsString], token[2]);
-        const node = withSourceCodeInfo([
-            NodeTypes.NormalExpression,
-            [
-                withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes.regexp], token[2]),
-                [stringNode, optionsNode],
-            ],
-        ], token[2]);
-        return node;
+            assertOperatorToken(ctx.tryPeek(), ':');
+            ctx.advance();
+            params.push(ctx.parseExpression());
+        }
+        const nextToken = ctx.tryPeek();
+        if (!isOperatorToken(nextToken, ',') && !isRBraceToken(nextToken)) {
+            throw new LitsError('Expected comma or closing brace', ctx.peekSourceCodeInfo());
+        }
+        if (isOperatorToken(nextToken, ',')) {
+            ctx.advance();
+        }
     }
+    assertRBraceToken(ctx.tryPeek());
+    ctx.advance();
+    return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.object, params]], firstToken[2]);
 }
 
-const litsCommands = new Set([...normalExpressionKeys, ...specialExpressionKeys, ...Object.keys(reservedSymbolRecord)]);
-// TODO: replace with get suggestions function
-class AutoCompleter {
-    originalProgram;
-    originalPosition;
-    prefixProgram = '';
-    suffixProgram = '';
-    searchString = '';
-    suggestions = [];
-    suggestionIndex = null;
-    constructor(originalProgram, originalPosition, lits, params) {
-        this.originalProgram = originalProgram;
-        this.originalPosition = originalPosition;
-        const partialProgram = this.originalProgram.slice(0, this.originalPosition);
-        const tokenStream = lits.tokenize(partialProgram);
-        const lastToken = tokenStream.tokens.at(-1);
-        if (!lastToken) {
-            return;
+function parseOperand(ctx) {
+    let operand = parseOperandPart(ctx);
+    let token = ctx.tryPeek();
+    while (isOperatorToken(token, '.') || isLBracketToken(token) || isLParenToken(token)) {
+        if (token[1] === '.') {
+            ctx.advance();
+            const symbolToken = ctx.tryPeek();
+            if (!isSymbolToken(symbolToken)) {
+                throw new LitsError('Expected symbol', ctx.peekSourceCodeInfo());
+            }
+            const stringNode = withSourceCodeInfo([NodeTypes.String, symbolToken[1]], symbolToken[2]);
+            operand = createAccessorNode(operand, stringNode, token[2]);
+            ctx.advance();
+            token = ctx.tryPeek();
         }
-        if (lastToken[0] === 'Error') {
-            return;
+        else if (isLBracketToken(token)) {
+            ctx.advance();
+            const expression = ctx.parseExpression();
+            if (!isRBracketToken(ctx.tryPeek())) {
+                throw new LitsError('Expected closing bracket', ctx.peekSourceCodeInfo());
+            }
+            operand = createAccessorNode(operand, expression, token[2]);
+            ctx.advance();
+            token = ctx.tryPeek();
+        }
+        else if (isLParenToken(token)) {
+            operand = parseFunctionCall(ctx, operand);
+            token = ctx.tryPeek();
         }
-        this.searchString = lastToken[1];
-        this.prefixProgram = this.originalProgram.slice(0, this.originalPosition - this.searchString.length);
-        this.suffixProgram = this.originalProgram.slice(this.prefixProgram.length + this.searchString.length);
-        this.originalProgram.slice(this.prefixProgram.length + this.searchString.length);
-        this.suggestions = this.generateSuggestions(params);
-    }
-    getNextSuggestion() {
-        return this.getAutoCompleteSuggestionResult(this.getNextSuggestionSymbol());
-    }
-    getPreviousSuggestion() {
-        return this.getAutoCompleteSuggestionResult(this.getPreviousSuggestionSymbol());
     }
-    getAutoCompleteSuggestionResult(suggestion) {
-        if (suggestion === null) {
-            return null;
+    return operand;
+}
+function parseOperandPart(ctx) {
+    const token = ctx.peek();
+    // Parentheses
+    if (isLParenToken(token)) {
+        ctx.storePosition();
+        const lamdaFunction = parseLambdaFunction(ctx);
+        if (lamdaFunction) {
+            return lamdaFunction;
         }
-        return {
-            program: this.prefixProgram + suggestion + this.suffixProgram,
-            position: this.prefixProgram.length + suggestion.length,
-        };
+        ctx.restorePosition();
+        ctx.advance();
+        const expression = ctx.parseExpression();
+        if (!isRParenToken(ctx.peek())) {
+            throw new LitsError('Expected closing parenthesis', ctx.peekSourceCodeInfo());
+        }
+        ctx.advance();
+        return expression;
     }
-    getNextSuggestionSymbol() {
-        if (this.suggestions.length === 0) {
-            return null;
+    else if (isOperatorToken(token)) {
+        const operatorName = token[1];
+        if (isBinaryOperator(operatorName)) {
+            ctx.advance();
+            if (specialExpressionTypes[operatorName] !== undefined) {
+                return withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[operatorName]], token[2]);
+            }
+            return withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[operatorName]], token[2]);
         }
-        if (this.suggestionIndex === null) {
-            this.suggestionIndex = 0;
+        if (operatorName === '->') {
+            return parseShorthandLambdaFunction(ctx);
         }
         else {
-            this.suggestionIndex += 1;
-            if (this.suggestionIndex >= this.suggestions.length) {
-                this.suggestionIndex = 0;
+            throw new LitsError(`Illegal operator: ${operatorName}`, token[2]);
+        }
+    }
+    // Object litteral, e.g. {a: 1, b: 2}
+    if (isLBraceToken(token)) {
+        return parseObject(ctx);
+    }
+    // Array litteral, e.g. [1, 2]
+    if (isLBracketToken(token)) {
+        return parseArray(ctx);
+    }
+    const tokenType = token[0];
+    switch (tokenType) {
+        case 'Number':
+        case 'BasePrefixedNumber':
+            return parseNumber(ctx);
+        case 'string':
+            return parseString(ctx, token);
+        case 'Symbol': {
+            ctx.storePosition();
+            const lamdaFunction = parseLambdaFunction(ctx);
+            if (lamdaFunction) {
+                return lamdaFunction;
             }
+            ctx.restorePosition();
+            return parseSymbol(ctx);
         }
-        return this.suggestions[this.suggestionIndex];
+        case 'ReservedSymbol':
+            return parseReservedSymbol(ctx);
+        case 'RegexpShorthand':
+            return parseRegexpShorthand(ctx);
+        default:
+            throw new LitsError(`Unknown token type: ${tokenType}`, token[2]);
     }
-    getPreviousSuggestionSymbol() {
-        if (this.suggestions.length === 0) {
-            return null;
+}
+function createAccessorNode(left, right, sourceCodeInfo) {
+    return withSourceCodeInfo([NodeTypes.NormalExpression, [[NodeTypes.NormalBuiltinSymbol, normalExpressionTypes.get], [left, right]]], sourceCodeInfo);
+}
+
+function getPrecedence(operatorSign, sourceCodeInfo) {
+    switch (operatorSign) {
+        case '^': // exponentiation
+            return exponentiationPrecedence;
+        case '*': // multiplication
+        case '/': // division
+        case '%': // remainder
+            return 11;
+        case '+': // addition
+        case '-': // subtraction
+            return 10;
+        case '<<': // left shift
+        case '>>': // signed right shift
+        case '>>>': // unsigned right shift
+            return 9;
+        case '++': // string concatenation
+            return 8;
+        case '<': // less than
+        case '<=': // less than or equal
+        case '≤': // less than or equal
+        case '>': // greater than
+        case '>=': // greater than or equal
+        case '≥': // greater than or equal
+            return 7;
+        case '==': // equal
+        case '!=': // not equal
+        case '≠': // not equal
+            return 6;
+        case '&': // bitwise AND
+        case 'xor': // bitwise XOR
+        case '|': // bitwise OR
+            return 5;
+        case '&&': // logical AND
+        case '||': // logical OR
+        case '??': // nullish coalescing
+            return 4;
+        // leave room for binaryFunctionalOperatorPrecedence = 3
+        case '|>': // pipe
+            return 2;
+        // leave room for conditionalOperatorPrecedence = 1
+        /* v8 ignore next 2 */
+        default:
+            throw new LitsError(`Unknown binary operator: ${operatorSign}`, sourceCodeInfo);
+    }
+}
+
+function parse(tokenStream) {
+    tokenStream.tokens.forEach((token) => {
+        if (token[0] === 'Error') {
+            throw new LitsError(token[3], token[2]);
         }
-        if (this.suggestionIndex === null) {
-            this.suggestionIndex = this.suggestions.length - 1;
+    });
+    const nodes = [];
+    const ctx = new ParserContext(tokenStream);
+    ctx.parseExpression = (precedence = 0, moduleScope = false) => parseExpression(ctx, precedence, moduleScope);
+    while (!ctx.isAtEnd()) {
+        nodes.push(parseExpression(ctx, 0, true));
+        if (isOperatorToken(ctx.tryPeek(), ';')) {
+            ctx.advance();
         }
         else {
-            this.suggestionIndex -= 1;
-            if (this.suggestionIndex < 0) {
-                this.suggestionIndex = this.suggestions.length - 1;
+            if (!ctx.isAtEnd()) {
+                throw new LitsError('Expected ;', ctx.peekSourceCodeInfo());
             }
         }
-        return this.suggestions[this.suggestionIndex];
     }
-    getSuggestions() {
-        return [...this.suggestions];
+    return nodes;
+}
+function parseExpression(ctx, precedence = 0, moduleScope = false) {
+    const token = ctx.tryPeek();
+    let left;
+    if (isSymbolToken(token)) {
+        switch (token[1]) {
+            case 'let':
+                return parseLet(ctx, token);
+            case 'if':
+            case 'unless':
+                left = parseIfOrUnless(ctx, token);
+                break;
+            case 'cond':
+                left = parseCond(ctx, token);
+                break;
+            case 'switch':
+                left = parseSwitch(ctx, token);
+                break;
+            case 'for':
+            case 'doseq':
+                left = parseForOrDoseq(ctx, token);
+                break;
+            case 'loop':
+                left = parseLoop(ctx, token);
+                break;
+            case 'try':
+                left = parseTry(ctx, token);
+                break;
+        }
     }
-    getSearchString() {
-        return this.searchString;
+    else if (isReservedSymbolToken(token, 'do')) {
+        left = parseDo(ctx)[0];
     }
-    generateSuggestions(params) {
-        const blacklist = new Set(['0_def', '0_defn', '0_lambda']);
-        const startsWithCaseSensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.startsWith(this.searchString));
-        startsWithCaseSensitive.forEach(suggestion => blacklist.add(suggestion));
-        const startsWithCaseInsensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.toLowerCase().startsWith(this.searchString.toLowerCase()));
-        startsWithCaseInsensitive.forEach(suggestion => blacklist.add(suggestion));
-        const includesCaseSensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.includes(this.searchString));
-        includesCaseSensitive.forEach(suggestion => blacklist.add(suggestion));
-        const includesCaseInsensitive = this.generateWithPredicate(params, suggestion => !blacklist.has(suggestion) && suggestion.includes(this.searchString.toLowerCase()));
-        includesCaseInsensitive.forEach(suggestion => blacklist.add(suggestion));
-        return [...startsWithCaseSensitive, ...startsWithCaseInsensitive, ...includesCaseSensitive, ...includesCaseInsensitive];
+    else if (isReservedSymbolToken(token, 'export')) {
+        if (!moduleScope) {
+            throw new LitsError('export is only allowed in module scope', token[2]);
+        }
+        return parseExport(ctx, token);
     }
-    generateWithPredicate(params, shouldInclude) {
-        const suggestions = new Set();
-        litsCommands.forEach((suggestion) => {
-            if (shouldInclude(suggestion)) {
-                suggestions.add(suggestion);
+    left ||= parseOperand(ctx);
+    let operator = ctx.tryPeek();
+    while (!isAtExpressionEnd(ctx)) {
+        if (isA_BinaryOperatorToken(operator)) {
+            const name = operator[1];
+            const newPrecedece = getPrecedence(name, operator[2]);
+            if (newPrecedece <= precedence
+                // ^ (exponentiation) is right associative
+                && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
+                break;
             }
-        });
-        Object.keys(params.globalContext ?? {})
-            .filter(shouldInclude)
-            .forEach(suggestion => suggestions.add(suggestion));
-        params.contexts?.forEach((context) => {
-            Object.keys(context)
-                .filter(shouldInclude)
-                .forEach(suggestion => suggestions.add(suggestion));
-        });
-        Object.keys(params.jsFunctions ?? {})
-            .filter(shouldInclude)
-            .forEach(suggestion => suggestions.add(suggestion));
-        Object.keys(params.values ?? {})
-            .filter(shouldInclude)
-            .forEach(suggestion => suggestions.add(suggestion));
-        return [...suggestions].sort((a, b) => a.localeCompare(b));
+            const symbol = specialExpressionTypes[name]
+                ? withSourceCodeInfo([NodeTypes.SpecialBuiltinSymbol, specialExpressionTypes[name]], operator[2])
+                : withSourceCodeInfo([NodeTypes.NormalBuiltinSymbol, normalExpressionTypes[name]], operator[2]);
+            ctx.advance();
+            const right = parseExpression(ctx, newPrecedece);
+            left = fromBinaryOperatorToNode(operator, symbol, left, right, operator[2]);
+        }
+        else if (isSymbolToken(operator)) {
+            if (!isFunctionOperator(operator[1])) {
+                break;
+            }
+            const newPrecedence = binaryFunctionalOperatorPrecedence;
+            if (newPrecedence <= precedence) {
+                break;
+            }
+            const operatorSymbol = parseSymbol(ctx);
+            const right = parseExpression(ctx, newPrecedence);
+            if (isSpecialBuiltinSymbolNode(operatorSymbol)) {
+                throw new LitsError('Special expressions are not allowed in binary functional operators', operatorSymbol[2]);
+            }
+            left = createNamedNormalExpressionNode(operatorSymbol, [left, right], operator[2]);
+        }
+        else if (operator?.[1] === '?') {
+            if (conditionalOperatorPrecedence <= precedence) {
+                break;
+            }
+            ctx.advance();
+            const trueNode = parseExpression(ctx);
+            if (!isOperatorToken(ctx.tryPeek(), ':')) {
+                throw new LitsError('Expected :', ctx.peekSourceCodeInfo());
+            }
+            ctx.advance();
+            const falseNode = parseExpression(ctx);
+            left = withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.if, [left, trueNode, falseNode]]], left[2]);
+        }
+        else {
+            break;
+        }
+        operator = ctx.tryPeek();
+    }
+    return left;
+}
+function parseExport(ctx, exportToken) {
+    ctx.advance();
+    const token = ctx.tryPeek();
+    if (isSymbolToken(token, 'let')) {
+        const letNode = parseLet(ctx, asSymbolToken(token));
+        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], exportToken[2]);
+    }
+    else {
+        throw new LitsError('Expected let', ctx.peekSourceCodeInfo());
     }
 }
 
@@ -8846,10 +8889,7 @@ class Lits {
             body: [],
             hasDebugData: tokenStream.hasDebugData,
         };
-        const parseState = {
-            position: 0,
-        };
-        ast.body = new Parser(tokenStream, parseState).parse();
+        ast.body = parse(tokenStream);
         return ast;
     }
     evaluate(ast, params) {