@mojir/lits 2.1.14 → 2.1.16

package/dist/testFramework.esm.js

@@ -181,7 +181,7 @@ var specialExpressionTypes = {
     '0_def': 5,
     'defined?': 6,
     '0_defn': 7,
-    'do': 8,
+    'block': 8,
     'doseq': 9,
     '0_fn': 10,
     'for': 11,
@@ -319,7 +319,7 @@ var getUndefinedSymbols = function (ast, contextStack, builtin, evaluateNode) {
     var _b;
     var nodes = Array.isArray(ast)
         ? ast
-        : [[NodeTypes.SpecialExpression, [specialExpressionTypes.do, ast.body]]];
+        : [[NodeTypes.SpecialExpression, [specialExpressionTypes.block, ast.body]]];
     var unresolvedSymbols = new Set();
     try {
         for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
@@ -3455,7 +3455,7 @@ function isIdentical(_a) {
     return true;
 }
 var miscNormalExpression = {
-    '=': {
+    '==': {
         evaluate: function (params, sourceCodeInfo) {
             return isEqual(params, sourceCodeInfo);
         },
@@ -11598,7 +11598,7 @@ var defSpecialExpression = {
         var bindingValue = evaluateNode(value, contextStack);
         var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
         contextStack.exportValues(values, target[2]);
-        return null;
+        return bindingValue;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
@@ -11647,9 +11647,7 @@ var nonNumberReservedSymbolRecord = {
     true: true,
     false: false,
     null: null,
-    then: null,
     else: null,
-    end: null,
     case: null,
     each: null,
     in: null,
@@ -11683,10 +11681,6 @@ var numberReservedSymbolRecord = {
     'MIN_SAFE_INTEGER': Number.MIN_SAFE_INTEGER,
     'MAX_VALUE': Number.MAX_VALUE,
     'MIN_VALUE': Number.MIN_VALUE,
-    'DELTA': Number.EPSILON, // TODO use DELTA instead of DELTA δ
-    '-DELTA': -Number.EPSILON,
-    'δ': Number.EPSILON, // TODO use DELTA instead of DELTA δ
-    '-δ': -Number.EPSILON,
     'NaN': Number.NaN,
 };
 var reservedSymbolRecord = __assign(__assign({}, nonNumberReservedSymbolRecord), numberReservedSymbolRecord);
@@ -11729,7 +11723,7 @@ var functionSpecialExpression = {
             _b.evaluatedfunction = evaluatedFunction,
             _b);
         contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
-        return null;
+        return litsFunction;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var _b, _c;
@@ -11757,7 +11751,7 @@ var defnSpecialExpression = {
             _b.evaluatedfunction = evaluatedFunctionOverloades,
             _b);
         contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
-        return null;
+        return litsFunction;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var _b, _c;
@@ -11877,7 +11871,7 @@ var letSpecialExpression = {
         var bindingValue = evaluateNode(value, contextStack);
         var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
         contextStack.addValues(values, target[2]);
-        return null;
+        return bindingValue;
     },
     getUndefinedSymbols: function (node, contextStack, _a) {
         var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
@@ -12009,13 +12003,12 @@ function evaluateLoop(returnResult, loopNode, contextStack, evaluateNode) {
     var bindingIndices = loopBindings.map(function () { return 0; });
     var abort = false;
     var _loop_1 = function () {
-        var e_2, _b;
         var context = {};
         var newContextStack = contextStack.create(context);
         var skip = false;
         bindingsLoop: for (var bindingIndex = 0; bindingIndex < loopBindings.length; bindingIndex += 1) {
-            var _c = __read(loopBindings[bindingIndex], 4), bindingNode = _c[0], letBindings = _c[1], whenNode = _c[2], whileNode = _c[3];
-            var _d = __read(bindingNode[1], 2), targetNode = _d[0], valueNode = _d[1];
+            var _b = __read(loopBindings[bindingIndex], 4), bindingNode = _b[0], letBindings = _b[1], whenNode = _b[2], whileNode = _b[3];
+            var _c = __read(bindingNode[1], 2), targetNode = _c[0], valueNode = _c[1];
             var coll = asColl(evaluateNode(valueNode, newContextStack), sourceCodeInfo);
             var seq = isSeq(coll) ? coll : Object.entries(coll);
             if (seq.length === 0) {
@@ -12055,20 +12048,7 @@ function evaluateLoop(returnResult, loopNode, contextStack, evaluateNode) {
             }
         }
         if (!skip) {
-            var value = null;
-            try {
-                for (var body_1 = (e_2 = void 0, __values(body)), body_1_1 = body_1.next(); !body_1_1.done; body_1_1 = body_1.next()) {
-                    var form = body_1_1.value;
-                    value = evaluateNode(form, newContextStack);
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (body_1_1 && !body_1_1.done && (_b = body_1.return)) _b.call(body_1);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
+            var value = evaluateNode(body, newContextStack);
             if (returnResult)
                 result.push(value);
             if (bindingIndices.length > 0)
@@ -12111,7 +12091,7 @@ function analyze(loopNode, contextStack, getUndefinedSymbols, builtin, evaluateN
             });
         }
     });
-    getUndefinedSymbols(body, contextStack.create(newContext), builtin, evaluateNode).forEach(function (symbol) {
+    getUndefinedSymbols([body], contextStack.create(newContext), builtin, evaluateNode).forEach(function (symbol) {
         return result.add(symbol);
     });
     return result;
@@ -12826,11 +12806,10 @@ function isContextEntry(value) {
 
 var ContextStackImpl = /** @class */ (function () {
     function ContextStackImpl(_a) {
-        var contexts = _a.contexts, hostValues = _a.values, lazyHostValues = _a.lazyValues, nativeJsFunctions = _a.nativeJsFunctions;
+        var contexts = _a.contexts, hostValues = _a.values, nativeJsFunctions = _a.nativeJsFunctions;
         this.globalContext = asNonUndefined(contexts[0]);
         this.contexts = contexts;
         this.values = hostValues;
-        this.lazyValues = lazyHostValues;
         this.nativeJsFunctions = nativeJsFunctions;
     }
     ContextStackImpl.prototype.create = function (context) {
@@ -12838,7 +12817,6 @@ var ContextStackImpl = /** @class */ (function () {
         var contextStack = new ContextStackImpl({
             contexts: __spreadArray([context], __read(this.contexts), false),
             values: this.values,
-            lazyValues: this.lazyValues,
             nativeJsFunctions: this.nativeJsFunctions,
         });
         contextStack.globalContext = globalContext;
@@ -12872,7 +12850,9 @@ var ContextStackImpl = /** @class */ (function () {
             }
             finally { if (e_1) throw e_1.error; }
         }
-        this.addValues(values, sourceCodeInfo);
+        if (this.contexts[0] !== this.globalContext) {
+            this.addValues(values, sourceCodeInfo);
+        }
     };
     ContextStackImpl.prototype.addValues = function (values, sourceCodeInfo) {
         var e_2, _a;
@@ -12902,10 +12882,10 @@ var ContextStackImpl = /** @class */ (function () {
     };
     ContextStackImpl.prototype.getValue = function (name) {
         var e_3, _a;
-        var _b, _c, _d;
+        var _b, _c;
         try {
-            for (var _e = __values(this.contexts), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var context = _f.value;
+            for (var _d = __values(this.contexts), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var context = _e.value;
                 var contextEntry = context[name];
                 if (contextEntry)
                     return contextEntry.value;
@@ -12914,26 +12894,22 @@ var ContextStackImpl = /** @class */ (function () {
         catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
-                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
             }
             finally { if (e_3) throw e_3.error; }
         }
-        var lazyHostValue = (_b = this.lazyValues) === null || _b === void 0 ? void 0 : _b[name];
-        if (lazyHostValue)
-            return lazyHostValue.read();
-        var nativeJsFunction = (_c = this.nativeJsFunctions) === null || _c === void 0 ? void 0 : _c[name];
+        var nativeJsFunction = (_b = this.nativeJsFunctions) === null || _b === void 0 ? void 0 : _b[name];
         if (nativeJsFunction)
             return nativeJsFunction;
-        return (_d = this.values) === null || _d === void 0 ? void 0 : _d[name];
+        return (_c = this.values) === null || _c === void 0 ? void 0 : _c[name];
     };
     ContextStackImpl.prototype.lookUp = function (node) {
         var e_4, _a;
-        var _b, _c, _d;
+        var _b, _c;
         var value = node[1];
         try {
-            // const sourceCodeInfo = node[2]
-            for (var _e = __values(this.contexts), _f = _e.next(); !_f.done; _f = _e.next()) {
-                var context = _f.value;
+            for (var _d = __values(this.contexts), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var context = _e.value;
                 var contextEntry = context[value];
                 if (contextEntry)
                     return contextEntry;
@@ -12942,23 +12918,17 @@ var ContextStackImpl = /** @class */ (function () {
         catch (e_4_1) { e_4 = { error: e_4_1 }; }
         finally {
             try {
-                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
             }
             finally { if (e_4) throw e_4.error; }
         }
-        var lazyHostValue = (_b = this.lazyValues) === null || _b === void 0 ? void 0 : _b[value];
-        if (lazyHostValue !== undefined) {
-            return {
-                value: toAny(lazyHostValue.read()),
-            };
-        }
-        var hostValue = (_c = this.values) === null || _c === void 0 ? void 0 : _c[value];
+        var hostValue = (_b = this.values) === null || _b === void 0 ? void 0 : _b[value];
         if (hostValue !== undefined) {
             return {
                 value: toAny(hostValue),
             };
         }
-        var nativeJsFunction = (_d = this.nativeJsFunctions) === null || _d === void 0 ? void 0 : _d[value];
+        var nativeJsFunction = (_c = this.nativeJsFunctions) === null || _c === void 0 ? void 0 : _c[value];
         if (nativeJsFunction) {
             return {
                 value: nativeJsFunction,
@@ -13014,7 +12984,6 @@ function createContextStack(params) {
     var contextStack = new ContextStackImpl({
         contexts: contexts,
         values: params.values,
-        lazyValues: params.lazyValues,
         nativeJsFunctions: params.jsFunctions
             && Object.entries(params.jsFunctions).reduce(function (acc, _a) {
                 var _b;
@@ -13037,7 +13006,7 @@ function createContextStack(params) {
                 return acc;
             }, {}),
     });
-    return contextStack.create({});
+    return params.globalModuleScope ? contextStack : contextStack.create({});
 }
 
 var binaryOperators = [
@@ -13057,7 +13026,7 @@ var binaryOperators = [
     '>', // greater than
     '>=', // greater than or equal
     '≥', // greater than or equal
-    '=', // equal
+    '==', // equal
     '!=', // not equal
     '≠', // not equal
     '&', // bitwise AND
@@ -13075,7 +13044,8 @@ var otherOperators = [
     '...', // rest
     '.', // property accessor
     ',', // item separator
-    ':=', // property assignment
+    '=', // assignment
+    ':', // property assignment
     ';', // statement terminator
 ];
 var symbolicOperators = __spreadArray(__spreadArray([], __read(binaryOperators), false), __read(otherOperators), false);
@@ -13084,7 +13054,7 @@ var nonFunctionOperators = [
     'cond',
     'def',
     'defined?',
-    'do',
+    'block',
     'doseq',
     'if',
     'let',
@@ -13284,7 +13254,7 @@ var tokenizeNumber = function (input, position) {
         return NO_MATCH;
     }
     var nextChar = input[i];
-    if (nextChar && !postNumberRegExp.test(nextChar)) {
+    if (nextChar && nextChar !== ':' && !postNumberRegExp.test(nextChar)) {
         throw new LitsError("Invalid number format at position ".concat(i, "."), undefined);
     }
     return [length, ['Number', input.substring(position, i)]];
@@ -13361,7 +13331,10 @@ var tokenizeSymbol = function (input, position) {
             position += 1;
             char = input[position];
         }
-        return [position - initialPosition, ['Symbol', value]];
+        // : can be used as symbol character, but it must not be the last character
+        return value.endsWith(':')
+            ? [position - initialPosition - 1, ['Symbol', value.slice(0, -1)]]
+            : [position - initialPosition, ['Symbol', value]];
     }
     return NO_MATCH;
 };
@@ -13697,7 +13670,7 @@ function getPrecedence(operatorSign, sourceCodeInfo) {
         case '>=': // greater than or equal
         case '≥': // greater than or equal
             return 7;
-        case '=': // equal
+        case '==': // equal
         case '!=': // not equal
         case '≠': // not equal
             return 6;
@@ -13748,7 +13721,7 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         case '>':
         case '>=':
         case '≥':
-        case '=':
+        case '==':
         case '!=':
         case '≠':
         case '&':
@@ -13763,12 +13736,12 @@ function fromBinaryOperatorToNode(operator, symbolNode, left, right, sourceCodeI
         /* v8 ignore next 11 */
         case '.':
         case ';':
-        case ':=':
+        case ':':
+        case '=':
         case ',':
         case '->':
         case '...':
         case '?':
-        case ':':
             throw new LitsError("Unknown binary operator: ".concat(operatorName), sourceCodeInfo);
         default:
             throw new LitsError("Unknown binary operator: ".concat(operatorName), sourceCodeInfo);
@@ -13831,9 +13804,9 @@ var Parser = /** @class */ (function () {
                 case 'doseq':
                     left = this.parseForOrDoseq(firstToken);
                     break;
-                case 'do':
-                    left = this.parseDo(firstToken);
-                    break;
+                // cas:
+                //   left = this.parseDo(firstToken)
+                //   break
                 case 'loop':
                     left = this.parseLoop(firstToken);
                     break;
@@ -13976,9 +13949,17 @@ var Parser = /** @class */ (function () {
                 throw new LitsError("Illegal operator: ".concat(operatorName), token[2]);
             }
         }
-        // Object litteral, e.g. {a=1, b=2}
+        // Object litteral, e.g. {a: 1, b: 2}
+        // Or block.
         if (isLBraceToken(token)) {
-            return this.parseObject();
+            var positionBefore = this.parseState.position;
+            try {
+                return this.parseObject();
+            }
+            catch (_a) {
+                this.parseState.position = positionBefore;
+                return this.parseBlock();
+            }
         }
         // Array litteral, e.g. [1, 2]
         if (isLBracketToken(token)) {
@@ -14033,7 +14014,7 @@ var Parser = /** @class */ (function () {
                 else {
                     throw new LitsError('Expected key to be a symbol or a string', this.peekSourceCodeInfo());
                 }
-                assertOperatorToken(this.peek(), ':=');
+                assertOperatorToken(this.peek(), ':');
                 this.advance();
                 params.push(this.parseExpression());
             }
@@ -14254,7 +14235,7 @@ var Parser = /** @class */ (function () {
         return node;
     };
     Parser.prototype.parseOptionalDefaulValue = function () {
-        if (isOperatorToken(this.peek(), ':=')) {
+        if (isOperatorToken(this.peek(), '=')) {
             this.advance();
             return this.parseExpression();
         }
@@ -14282,7 +14263,7 @@ var Parser = /** @class */ (function () {
             }
             this.advance();
             var symbol = asUserDefinedSymbolNode(this.parseSymbol());
-            if (isOperatorToken(this.peek(), ':=')) {
+            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]);
@@ -14349,11 +14330,11 @@ var Parser = /** @class */ (function () {
                     }
                     elements[key[1]] = withSourceCodeInfo([bindingTargetTypes.symbol, [name_2, this.parseOptionalDefaulValue()]], firstToken[2]);
                 }
-                else if (isRBraceToken(token) || isOperatorToken(token, ',') || isOperatorToken(token, ':=')) {
+                else if (isRBraceToken(token) || isOperatorToken(token, ',') || isOperatorToken(token, '=')) {
                     if (elements[key[1]]) {
                         throw new LitsError("Duplicate binding name: ".concat(key), token[2]);
                     }
-                    if (rest && isOperatorToken(this.peek(), ':=')) {
+                    if (rest && isOperatorToken(this.peek(), '=')) {
                         throw new LitsError('Rest argument can not have default value', this.peekSourceCodeInfo());
                     }
                     elements[key[1]] = rest
@@ -14379,45 +14360,45 @@ var Parser = /** @class */ (function () {
         }
         throw new LitsError('Expected symbol', this.peekSourceCodeInfo());
     };
-    Parser.prototype.parseLet = function (token, optionalSemicolon) {
-        if (optionalSemicolon === void 0) { optionalSemicolon = false; }
+    Parser.prototype.parseLet = function (token) {
         this.advance();
         var target = this.parseBindingTarget({ requireDefaultValue: true, noRest: true });
         var value = target[1][1];
         target[1][1] = undefined;
-        if (!optionalSemicolon) {
-            assertOperatorToken(this.peek(), ';');
-        }
         var bindingTarget = withSourceCodeInfo([NodeTypes.Binding, [target, value]], token[2]);
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.let, bindingTarget]], token[2]);
     };
-    Parser.prototype.parseDo = function (token) {
+    Parser.prototype.parseBlock = function () {
+        var token = asLBraceToken(this.peek());
         this.advance();
         var expressions = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
+        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
             expressions.push(this.parseExpression());
             if (isOperatorToken(this.peek(), ';')) {
                 this.advance();
             }
-            else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
+            else if (!isRBraceToken(this.peek())) {
+                throw new LitsError('Expected }', this.peekSourceCodeInfo());
             }
         }
-        assertReservedSymbolToken(this.peek(), 'end');
+        if (expressions.length === 0) {
+            expressions.push(withSourceCodeInfo([NodeTypes.ReservedSymbol, 'null'], token[2]));
+        }
+        assertRBraceToken(this.peek());
         this.advance();
-        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, expressions]], token[2]);
+        return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]);
     };
     Parser.prototype.parseLoop = function (firstToken) {
+        this.advance();
+        assertLParenToken(this.peek());
         this.advance();
         var bindingNodes = [];
         var token = this.peek();
-        while (!this.isAtEnd() && !isSymbolToken(token, 'do')) {
-            assertSymbolToken(token, 'let');
-            this.advance();
+        while (!this.isAtEnd() && !isRParenToken(token)) {
             var target = this.parseBindingTarget({ requireDefaultValue: true, noRest: true });
             var value = target[1][1];
             target[1][1] = undefined;
-            bindingNodes.push(withSourceCodeInfo([NodeTypes.Binding, [target, value]], token[2]));
+            bindingNodes.push(withSourceCodeInfo([NodeTypes.Binding, [target, value]], target[2]));
             if (isOperatorToken(this.peek(), ',')) {
                 this.advance();
             }
@@ -14426,37 +14407,27 @@ var Parser = /** @class */ (function () {
         if (bindingNodes.length === 0) {
             throw new LitsError('Expected binding', this.peekSourceCodeInfo());
         }
-        assertSymbolToken(token, 'do');
+        assertRParenToken(token);
+        this.advance();
+        assertLBraceToken(this.peek());
         this.advance();
         var params = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
+        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
             params.push(this.parseExpression());
             if (isOperatorToken(this.peek(), ';')) {
                 this.advance();
             }
-            else if (!isReservedSymbolToken(this.peek(), 'end')) {
+            else if (!isRBraceToken(this.peek())) {
                 throw new LitsError('Expected ;', this.peekSourceCodeInfo());
             }
         }
-        assertReservedSymbolToken(this.peek(), 'end');
+        assertRBraceToken(this.peek());
         this.advance();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.loop, bindingNodes, params]], firstToken[2]);
     };
     Parser.prototype.parseTry = function (token) {
         this.advance();
-        var tryExpressions = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'catch')) {
-            tryExpressions.push(this.parseExpression());
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else if (!isReservedSymbolToken(this.peek(), 'catch')) {
-                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-            }
-        }
-        var tryExpression = tryExpressions.length === 1
-            ? tryExpressions[0]
-            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, tryExpressions]], token[2]);
+        var tryExpression = this.parseBlock();
         assertReservedSymbolToken(this.peek(), 'catch');
         this.advance();
         var errorSymbol;
@@ -14466,26 +14437,14 @@ var Parser = /** @class */ (function () {
             assertRParenToken(this.peek());
             this.advance();
         }
-        var catchExpressions = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
-            catchExpressions.push(this.parseExpression());
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-            }
-        }
-        assertReservedSymbolToken(this.peek(), 'end');
-        this.advance();
-        var catchExpression = catchExpressions.length === 1
-            ? catchExpressions[0]
-            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, catchExpressions]], token[2]);
+        var catchExpression = this.parseBlock();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.try, tryExpression, errorSymbol, catchExpression]], token[2]);
     };
     Parser.prototype.parseForOrDoseq = function (firstToken) {
         var isDoseq = firstToken[1] === 'doseq';
         this.advance();
+        assertLParenToken(this.peek());
+        this.advance();
         var forLoopBindings = [];
         var _loop_1 = function () {
             var loopBinding = this_1.parseForLoopBinding();
@@ -14495,37 +14454,27 @@ var Parser = /** @class */ (function () {
                 throw new LitsError('Duplicate binding', loopBinding[0][2]);
             }
             forLoopBindings.push(loopBinding);
+            if (isOperatorToken(this_1.peek(), ';')) {
+                this_1.advance();
+            }
         };
         var this_1 = this;
-        while (!this.isAtEnd() && !isSymbolToken(this.peek(), 'do')) {
+        while (!this.isAtEnd() && !isRParenToken(this.peek())) {
             _loop_1();
         }
-        assertSymbolToken(this.peek(), 'do');
-        this.advance();
-        var 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 ;', this.peekSourceCodeInfo());
-            }
-        }
-        assertReservedSymbolToken(this.peek(), 'end');
+        assertRParenToken(this.peek());
         this.advance();
+        var expression = this.parseExpression();
         return isDoseq
-            ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.doseq, forLoopBindings, expressions]], firstToken[2])
-            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.for, forLoopBindings, expressions]], firstToken[2]);
+            ? withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.doseq, forLoopBindings, expression]], firstToken[2])
+            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.for, forLoopBindings, expression]], firstToken[2]);
     };
     Parser.prototype.parseForLoopBinding = function () {
-        assertReservedSymbolToken(this.peek(), 'each');
-        this.advance();
         var bindingNode = this.parseBinding();
         var modifiers = [];
         var token = this.asToken(this.peek());
-        if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this.peek(), 'each') && !isOperatorToken(token, ',')) {
-            throw new LitsError('Expected do, each or comma', token[2]);
+        if (!isRParenToken(token) && !isOperatorToken(this.peek(), ';') && !isOperatorToken(token, ',')) {
+            throw new LitsError('Expected ")", ";" or ","', token[2]);
         }
         if (isOperatorToken(token, ',')) {
             this.advance();
@@ -14534,15 +14483,15 @@ var Parser = /** @class */ (function () {
         if (!isSymbolToken(token, 'let')
             && !isReservedSymbolToken(token, 'when')
             && !isReservedSymbolToken(token, 'while')
-            && !isSymbolToken(token, 'do')
-            && !isReservedSymbolToken(token, 'each')) {
-            throw new LitsError('Expected symbol each, do, let, when or while', token[2]);
+            && !isRParenToken(token)
+            && !isOperatorToken(token, ';')) {
+            throw new LitsError('Expected symbol ";", ")", let, when or while', token[2]);
         }
         var letBindings = [];
         if (token[1] === 'let') {
             modifiers.push('&let');
             var _loop_2 = function () {
-                var letNode = this_2.parseLet(token, true);
+                var letNode = this_2.parseLet(token);
                 var existingBoundNames = letBindings.flatMap(function (b) { return Object.keys(getAllBindingTargetNames(b[1][0])); });
                 var newBoundNames = Object.keys(getAllBindingTargetNames(letNode[1][1][1][0]));
                 if (newBoundNames.some(function (n) { return existingBoundNames.includes(n); })) {
@@ -14550,8 +14499,8 @@ var Parser = /** @class */ (function () {
                 }
                 letBindings.push(letNode[1][1]);
                 token = this_2.asToken(this_2.peek());
-                if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this_2.peek(), 'each') && !isOperatorToken(token, ',')) {
-                    throw new LitsError('Expected do, each or comma', token[2]);
+                if (!isRParenToken(token) && !isOperatorToken(token, ';') && !isOperatorToken(token, ',')) {
+                    throw new LitsError('Expected ")", ";" or ","', token[2]);
                 }
                 if (isOperatorToken(token, ',')) {
                     this_2.advance();
@@ -14583,7 +14532,7 @@ var Parser = /** @class */ (function () {
                 whileNode = this.parseExpression();
             }
             token = this.asToken(this.peek());
-            if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this.peek(), 'each') && !isOperatorToken(token, ',')) {
+            if (!isRParenToken(token) && !isOperatorToken(token, ';') && !isOperatorToken(token, ',')) {
                 throw new LitsError('Expected do or comma', token[2]);
             }
             if (isOperatorToken(token, ',')) {
@@ -14591,8 +14540,8 @@ var Parser = /** @class */ (function () {
             }
             token = this.asToken(this.peek());
         }
-        if (!isSymbolToken(token, 'do') && !isReservedSymbolToken(this.peek(), 'each')) {
-            throw new LitsError('Expected do or each', token[2]);
+        if (!isRParenToken(token) && !isOperatorToken(token, ';')) {
+            throw new LitsError('Expected "{" or ";"', token[2]);
         }
         return [bindingNode, letBindings, whenNode, whileNode];
     };
@@ -14614,113 +14563,95 @@ var Parser = /** @class */ (function () {
     Parser.prototype.parseIfOrUnless = function (token) {
         var isUnless = token[1] === 'unless';
         this.advance();
+        assertLParenToken(this.peek());
+        this.advance();
         var condition = this.parseExpression();
-        assertReservedSymbolToken(this.peek(), 'then');
+        assertRParenToken(this.peek());
         this.advance();
-        var thenExpressions = [];
-        while (!this.isAtEnd()
-            && !isReservedSymbolToken(this.peek(), 'else')
-            && !isReservedSymbolToken(this.peek(), 'end')) {
-            thenExpressions.push(this.parseExpression());
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else if (!isReservedSymbolToken(this.peek(), 'else') && !isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-            }
-        }
-        var thenExpression = thenExpressions.length === 1
-            ? thenExpressions[0]
-            : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, thenExpressions]], token[2]);
+        var thenExpression = this.parseExpression();
         var elseExpression;
         if (isReservedSymbolToken(this.peek(), 'else')) {
             this.advance();
-            var elseExpressions = [];
-            while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
-                elseExpressions.push(this.parseExpression());
-                if (isOperatorToken(this.peek(), ';')) {
-                    this.advance();
-                }
-                else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-                }
-            }
-            elseExpression = elseExpressions.length === 1
-                ? elseExpressions[0]
-                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, elseExpressions]], token[2]);
+            elseExpression = this.parseExpression();
         }
-        assertReservedSymbolToken(this.peek(), '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]);
     };
     Parser.prototype.parseCond = function (token) {
+        this.advance();
+        assertLBraceToken(this.peek());
         this.advance();
         var params = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
+        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
             assertReservedSymbolToken(this.peek(), 'case');
             this.advance();
             var caseExpression = this.parseExpression();
-            assertReservedSymbolToken(this.peek(), 'then');
+            assertOperatorToken(this.peek(), ':');
             this.advance();
             var expressions = [];
             while (!this.isAtEnd()
                 && !isReservedSymbolToken(this.peek(), 'case')
-                && !isReservedSymbolToken(this.peek(), 'end')) {
+                && !isRBraceToken(this.peek())) {
                 expressions.push(this.parseExpression());
                 if (isOperatorToken(this.peek(), ';')) {
                     this.advance();
                 }
-                else if (!isReservedSymbolToken(this.peek(), 'case') && !isReservedSymbolToken(this.peek(), 'end')) {
+                else if (!isReservedSymbolToken(this.peek(), 'case') && !isRBraceToken(this.peek())) {
                     throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                 }
             }
             var thenExpression = expressions.length === 1
                 ? expressions[0]
-                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, expressions]], token[2]);
+                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]);
             params.push([caseExpression, thenExpression]);
-            if (isReservedSymbolToken(this.peek(), 'end')) {
+            if (isRBraceToken(this.peek())) {
                 break;
             }
             assertReservedSymbolToken(this.peek(), 'case');
         }
-        assertReservedSymbolToken(this.peek(), 'end');
+        assertRBraceToken(this.peek());
         this.advance();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.cond, params]], token[2]);
     };
     Parser.prototype.parseSwitch = function (token) {
+        this.advance();
+        assertLParenToken(this.peek());
         this.advance();
         var valueExpression = this.parseExpression();
+        assertRParenToken(this.peek());
+        this.advance();
+        assertLBraceToken(this.peek());
+        this.advance();
         var params = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
+        while (!this.isAtEnd() && !isRBraceToken(this.peek())) {
             assertReservedSymbolToken(this.peek(), 'case');
             this.advance();
             var caseExpression = this.parseExpression();
-            assertReservedSymbolToken(this.peek(), 'then');
+            assertOperatorToken(this.peek(), ':');
             this.advance();
             var expressions = [];
             while (!this.isAtEnd()
                 && !isReservedSymbolToken(this.peek(), 'case')
-                && !isReservedSymbolToken(this.peek(), 'end')) {
+                && !isRBraceToken(this.peek())) {
                 expressions.push(this.parseExpression());
                 if (isOperatorToken(this.peek(), ';')) {
                     this.advance();
                 }
-                else if (!isReservedSymbolToken(this.peek(), 'case') && !isReservedSymbolToken(this.peek(), 'end')) {
+                else if (!isReservedSymbolToken(this.peek(), 'case') && !isRBraceToken(this.peek())) {
                     throw new LitsError('Expected ;', this.peekSourceCodeInfo());
                 }
             }
             var thenExpression = expressions.length === 1
                 ? expressions[0]
-                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.do, expressions]], token[2]);
+                : withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.block, expressions]], token[2]);
             params.push([caseExpression, thenExpression]);
-            if (isReservedSymbolToken(this.peek(), 'end')) {
+            if (isRBraceToken(this.peek())) {
                 break;
             }
             assertReservedSymbolToken(this.peek(), 'case');
         }
-        assertReservedSymbolToken(this.peek(), 'end');
+        assertRBraceToken(this.peek());
         this.advance();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.switch, valueExpression, params]], token[2]);
     };
@@ -14728,22 +14659,10 @@ var Parser = /** @class */ (function () {
         this.advance();
         var symbol = this.parseSymbol();
         var functionArguments = this.parseFunctionArguments();
-        var body = [];
-        while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
-            body.push(this.parseExpression());
-            if (isOperatorToken(this.peek(), ';')) {
-                this.advance();
-            }
-            else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-            }
-        }
-        assertReservedSymbolToken(this.peek(), 'end');
-        this.advance();
-        assertOperatorToken(this.peek(), ';');
+        var block = this.parseBlock();
         return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes.function, symbol, [
                     functionArguments,
-                    body,
+                    block[1][1],
                 ]]], token[2]);
     };
     Parser.prototype.isAtEnd = function () {
@@ -14755,39 +14674,24 @@ var Parser = /** @class */ (function () {
         }
         var token = this.peek();
         if (isOperatorToken(token)) {
-            return [';', ',', ':='].includes(token[1]);
+            return [';', ',', ':'].includes(token[1]);
         }
         if (isReservedSymbolToken(token)) {
-            return ['else', 'when', 'while', 'then', 'end', 'case', 'catch'].includes(token[1]);
+            return ['else', 'when', 'while', 'case', 'catch'].includes(token[1]);
         }
         return false;
     };
-    Parser.prototype.parseExport = function (token) {
+    Parser.prototype.parseExport = function (exportToken) {
         this.advance();
-        if (isSymbolToken(this.peek(), 'let')) {
-            var letNode = this.parseLet(asSymbolToken(this.peek()));
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], token[2]);
-        }
-        else if (isReservedSymbolToken(this.peek(), 'function')) {
-            this.advance();
-            var symbol = this.parseSymbol();
-            var functionArguments = this.parseFunctionArguments();
-            var body = [];
-            while (!this.isAtEnd() && !isReservedSymbolToken(this.peek(), 'end')) {
-                body.push(this.parseExpression());
-                if (isOperatorToken(this.peek(), ';')) {
-                    this.advance();
-                }
-                else if (!isReservedSymbolToken(this.peek(), 'end')) {
-                    throw new LitsError('Expected ;', this.peekSourceCodeInfo());
-                }
-            }
-            assertReservedSymbolToken(this.peek(), 'end');
-            this.advance();
-            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_defn'], symbol, [
-                        functionArguments,
-                        body,
-                    ]]], token[2]);
+        var token = this.peek();
+        if (isSymbolToken(token, 'let')) {
+            var letNode = this.parseLet(asSymbolToken(token));
+            return withSourceCodeInfo([NodeTypes.SpecialExpression, [specialExpressionTypes['0_def'], letNode[1][1]]], exportToken[2]);
+        }
+        else if (isReservedSymbolToken(token, 'function')) {
+            var functionNode = this.parseFunction(token);
+            functionNode[1][0] = specialExpressionTypes['0_defn'];
+            return functionNode;
         }
         else {
             throw new LitsError('Expected let or function', this.peekSourceCodeInfo());