@mojir/lits 2.0.7 → 2.0.9

package/dist/lits.iife.js

@@ -393,6 +393,7 @@ var Lits = (function (exports) {
         '<<', // left shift
         '>>', // signed right shift
         '>>>', // unsigned right shift
+        '++', // string concatenation
         '<', // less than
         '<=', // less than or equal
         '>', // greater than
@@ -3163,7 +3164,7 @@ var Lits = (function (exports) {
         },
     };
 
-    var version = "2.0.7";
+    var version = "2.0.9";
 
     var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
     var xyRegexp = /[xy]/g;
@@ -7114,24 +7115,27 @@ var Lits = (function (exports) {
         };
     }
 
-    var exponentiationPrecedence = 8;
+    var exponentiationPrecedence = 9;
+    var placeholderRegexp$1 = /^\$([1-9]\d?)?$/;
     function getPrecedence(operator) {
         var operatorSign = operator[1];
         switch (operatorSign) {
             case '.': // accessor
-                return 9;
+                return 10;
             case '**': // exponentiation
                 return exponentiationPrecedence;
             case '*': // multiplication
             case '/': // division
             case '%': // remainder
-                return 7;
+                return 8;
             case '+': // addition
             case '-': // subtraction
-                return 6;
+                return 7;
             case '<<': // left shift
             case '>>': // signed right shift
             case '>>>': // unsigned right shift
+                return 6;
+            case '++': // string concatenation
                 return 5;
             case '<': // less than
             case '<=': // less than or equal
@@ -7229,6 +7233,11 @@ var Lits = (function (exports) {
                 return createNamedNormalExpressionNode('bit-shift-right', [left, right], token);
             case '>>>':
                 return createNamedNormalExpressionNode('unsigned-bit-shift-right', [left, right], token);
+            case '++': {
+                var leftString = createNamedNormalExpressionNode('str', [left], token);
+                var rightString = createNamedNormalExpressionNode('str', [right], token);
+                return createNamedNormalExpressionNode('str', [leftString, rightString], token);
+            }
             case '<':
                 return createNamedNormalExpressionNode('<', [left, right], token);
             case '<=':
@@ -7340,7 +7349,7 @@ var Lits = (function (exports) {
             // Parentheses
             if (isLParenToken(token)) {
                 var positionBefore = this.parseState.position;
-                var lamdaFunction = this.parseLamdaFunction();
+                var lamdaFunction = this.parseLambdaFunction();
                 if (lamdaFunction) {
                     return lamdaFunction;
                 }
@@ -7361,6 +7370,9 @@ var Lits = (function (exports) {
                     var operand = this.parseOperand();
                     return fromUnaryAlgebraicToAstNode(token, operand);
                 }
+                else if (operatorName === '=>') {
+                    return this.parseShorthandLamdaFunction();
+                }
                 else {
                     throw new Error("Unknown unary operator: ".concat(operatorName));
                 }
@@ -7507,6 +7519,8 @@ var Lits = (function (exports) {
                         case 'or':
                         case 'when':
                         case 'when-not':
+                        case 'do':
+                        case 'throw':
                             return {
                                 t: exports.AstNodeType.SpecialExpression,
                                 n: name_1,
@@ -7523,13 +7537,11 @@ var Lits = (function (exports) {
                         case 'defn':
                         case 'defns':
                         case 'try':
-                        case 'throw':
                         case 'recur':
                         case 'loop':
                         case 'time!':
                         case 'doseq':
                         case 'for':
-                        case 'do':
                             throw new Error("Special expression ".concat(name_1, " is not available in algebraic notation"));
                         default:
                             throw new Error("Unknown special expression: ".concat(name_1));
@@ -7546,7 +7558,7 @@ var Lits = (function (exports) {
                 };
             }
         };
-        AlgebraicParser.prototype.parseLamdaFunction = function () {
+        AlgebraicParser.prototype.parseLambdaFunction = function () {
             var _a;
             var firstToken = this.peek();
             this.advance();
@@ -7605,6 +7617,62 @@ var Lits = (function (exports) {
                 token: getTokenDebugData(firstToken) && firstToken,
             };
         };
+        AlgebraicParser.prototype.parseShorthandLamdaFunction = function () {
+            var _a, _b, _c, _d;
+            var firstToken = this.peek();
+            this.advance();
+            var startPos = this.parseState.position;
+            var exprNode = this.parseExpression();
+            var endPos = this.parseState.position - 1;
+            var arity = 0;
+            var percent1 = 'NOT_SET'; // referring to argument bindings. % = NAKED, %1, %2, %3, etc = WITH_1
+            for (var pos = startPos; pos <= endPos; pos += 1) {
+                var tkn = this.tokenStream.tokens[pos];
+                if (isA_SymbolToken(tkn)) {
+                    var match = placeholderRegexp$1.exec(tkn[1]);
+                    if (match) {
+                        var number = (_a = match[1]) !== null && _a !== void 0 ? _a : '1';
+                        if (number === '1') {
+                            var mixedPercent1 = (!match[1] && percent1 === 'WITH_1') || (match[1] && percent1 === 'NAKED');
+                            if (mixedPercent1)
+                                throw new LitsError('Please make up your mind, either use $ or $1', (_b = getTokenDebugData(firstToken)) === null || _b === void 0 ? void 0 : _b.sourceCodeInfo);
+                            percent1 = match[1] ? 'WITH_1' : 'NAKED';
+                        }
+                        arity = Math.max(arity, Number(number));
+                        if (arity > 20)
+                            throw new LitsError('Can\'t specify more than 20 arguments', (_c = getTokenDebugData(firstToken)) === null || _c === void 0 ? void 0 : _c.sourceCodeInfo);
+                    }
+                }
+                if (isA_OperatorToken(tkn, '=>')) {
+                    throw new LitsError('Nested shortcut functions are not allowed', (_d = getTokenDebugData(firstToken)) === null || _d === void 0 ? void 0 : _d.sourceCodeInfo);
+                }
+            }
+            var mandatoryArguments = [];
+            for (var i = 1; i <= arity; i += 1) {
+                if (i === 1 && percent1 === 'NAKED')
+                    mandatoryArguments.push('$');
+                else
+                    mandatoryArguments.push("$".concat(i));
+            }
+            var args = {
+                b: [],
+                m: mandatoryArguments,
+            };
+            var node = {
+                t: exports.AstNodeType.SpecialExpression,
+                n: 'fn',
+                p: [],
+                o: [
+                    {
+                        as: args,
+                        b: [exprNode],
+                        a: args.m.length,
+                    },
+                ],
+                token: getTokenDebugData(firstToken) && firstToken,
+            };
+            return node;
+        };
         AlgebraicParser.prototype.isAtEnd = function () {
             return this.parseState.position >= this.tokenStream.tokens.length;
         };
@@ -7963,7 +8031,7 @@ var Lits = (function (exports) {
 
     var polishIdentifierCharacterClass = '[\\w@%^?=!$<>+*/:-]';
     var polishIdentifierFirstCharacterClass = '[a-zA-Z_@%^?=!$<>+*/-]';
-    var algebraicIdentifierCharacterClass = '[\\w$:!]';
+    var algebraicIdentifierCharacterClass = '[\\w$:!?]';
     var algebraicIdentifierFirstCharacterClass = '[a-zA-Z_$]';
 
     var NO_MATCH = [0];
@@ -8270,13 +8338,11 @@ var Lits = (function (exports) {
         'defn': { value: null, forbidden: true },
         'defns': { value: null, forbidden: true },
         'try': { value: null, forbidden: true },
-        'throw': { value: null, forbidden: true },
         'recur': { value: null, forbidden: true },
         'loop': { value: null, forbidden: true },
         'time!': { value: null, forbidden: true },
         'doseq': { value: null, forbidden: true },
         'for': { value: null, forbidden: true },
-        'do': { value: null, forbidden: true },
     };
 
     var identifierRegExp = new RegExp(algebraicIdentifierCharacterClass);