@mojir/lits 2.0.7 → 2.0.9

package/dist/index.js

@@ -392,6 +392,7 @@ var AlgebraicOperators = [
     '<<', // left shift
     '>>', // signed right shift
     '>>>', // unsigned right shift
+    '++', // string concatenation
     '<', // less than
     '<=', // less than or equal
     '>', // greater than
@@ -3162,7 +3163,7 @@ var mathNormalExpression = {
     },
 };
 
-var version = "2.0.7";
+var version = "2.0.9";
 
 var uuidTemplate = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
 var xyRegexp = /[xy]/g;
@@ -7113,24 +7114,27 @@ function parseString(tokenStream, parseState) {
     };
 }
 
-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
@@ -7228,6 +7232,11 @@ function fromBinaryAlgebraicToAstNode(operator, left, right) {
             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 '<=':
@@ -7339,7 +7348,7 @@ var AlgebraicParser = /** @class */ (function () {
         // Parentheses
         if (isLParenToken(token)) {
             var positionBefore = this.parseState.position;
-            var lamdaFunction = this.parseLamdaFunction();
+            var lamdaFunction = this.parseLambdaFunction();
             if (lamdaFunction) {
                 return lamdaFunction;
             }
@@ -7360,6 +7369,9 @@ var AlgebraicParser = /** @class */ (function () {
                 var operand = this.parseOperand();
                 return fromUnaryAlgebraicToAstNode(token, operand);
             }
+            else if (operatorName === '=>') {
+                return this.parseShorthandLamdaFunction();
+            }
             else {
                 throw new Error("Unknown unary operator: ".concat(operatorName));
             }
@@ -7506,6 +7518,8 @@ var AlgebraicParser = /** @class */ (function () {
                     case 'or':
                     case 'when':
                     case 'when-not':
+                    case 'do':
+                    case 'throw':
                         return {
                             t: exports.AstNodeType.SpecialExpression,
                             n: name_1,
@@ -7522,13 +7536,11 @@ var AlgebraicParser = /** @class */ (function () {
                     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));
@@ -7545,7 +7557,7 @@ var AlgebraicParser = /** @class */ (function () {
             };
         }
     };
-    AlgebraicParser.prototype.parseLamdaFunction = function () {
+    AlgebraicParser.prototype.parseLambdaFunction = function () {
         var _a;
         var firstToken = this.peek();
         this.advance();
@@ -7604,6 +7616,62 @@ var AlgebraicParser = /** @class */ (function () {
             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;
     };
@@ -7962,7 +8030,7 @@ function parseToken(tokenStream, parseState) {
 
 var polishIdentifierCharacterClass = '[\\w@%^?=!$<>+*/:-]';
 var polishIdentifierFirstCharacterClass = '[a-zA-Z_@%^?=!$<>+*/-]';
-var algebraicIdentifierCharacterClass = '[\\w$:!]';
+var algebraicIdentifierCharacterClass = '[\\w$:!?]';
 var algebraicIdentifierFirstCharacterClass = '[a-zA-Z_$]';
 
 var NO_MATCH = [0];
@@ -8269,13 +8337,11 @@ var algebraicReservedNamesRecord = {
     '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);