@mojir/lits 2.1.2 → 2.1.4

package/dist/lits.iife.js

@@ -96,9 +96,15 @@ var Lits = (function (exports) {
     }
 
     function getLitsErrorMessage(message, sourceCodeInfo) {
-        var filePathLine = (sourceCodeInfo === null || sourceCodeInfo === void 0 ? void 0 : sourceCodeInfo.filePath) ? "\n".concat(sourceCodeInfo.filePath) : '';
-        var codeLine = (sourceCodeInfo === null || sourceCodeInfo === void 0 ? void 0 : sourceCodeInfo.code) ? "\n".concat(sourceCodeInfo.code) : '';
-        var codeMarker = sourceCodeInfo && codeLine ? "\n".concat(getCodeMarker(sourceCodeInfo)) : '';
+        if (!sourceCodeInfo) {
+            return message;
+        }
+        var location = "".concat(sourceCodeInfo.position.line, ":").concat(sourceCodeInfo.position.column);
+        var filePathLine = sourceCodeInfo.filePath
+            ? "\n".concat(sourceCodeInfo.filePath, ":").concat(location)
+            : "\nLocation ".concat(location);
+        var codeLine = "\n".concat(sourceCodeInfo.code);
+        var codeMarker = "\n".concat(getCodeMarker(sourceCodeInfo));
         return "".concat(message).concat(filePathLine).concat(codeLine).concat(codeMarker);
     }
     var RecurSignal = /** @class */ (function (_super) {
@@ -211,6 +217,7 @@ var Lits = (function (exports) {
         'SomePred',
         'Fnull',
         'Builtin',
+        'SpecialBuiltin',
         'NativeJsFunction',
     ];
     var functionTypeSet = new Set(functionTypes);
@@ -1258,26 +1265,37 @@ var Lits = (function (exports) {
             paramCount: 1,
         },
         'map': {
-            evaluate: function (_a, sourceCodeInfo, contextStack, _b) {
-                var _c = __read(_a, 2), seq = _c[0], fn = _c[1];
-                var executeFunction = _b.executeFunction;
-                assertSeq(seq, sourceCodeInfo);
-                assertLitsFunction(fn, sourceCodeInfo);
-                if (Array.isArray(seq)) {
-                    return seq.map(function (elem) { return executeFunction(fn, [elem], contextStack, sourceCodeInfo); });
+            evaluate: function (params, sourceCodeInfo, contextStack, _a) {
+                var executeFunction = _a.executeFunction;
+                var fn = asLitsFunction(params.at(-1));
+                var seqs = params.slice(0, -1);
+                assertSeq(seqs[0], sourceCodeInfo);
+                var isString = typeof seqs[0] === 'string';
+                var len = seqs[0].length;
+                seqs.slice(1).forEach(function (seq) {
+                    if (isString) {
+                        assertString(seq, sourceCodeInfo);
+                    }
+                    else {
+                        assertArray(seq, sourceCodeInfo);
+                    }
+                    len = Math.min(len, seq.length);
+                });
+                var paramArray = [];
+                var _loop_1 = function (i) {
+                    paramArray.push(seqs.map(function (seq) { return seq[i]; }));
+                };
+                for (var i = 0; i < len; i++) {
+                    _loop_1(i);
                 }
-                else {
-                    return seq
-                        .split('')
-                        .map(function (elem) {
-                        var newVal = executeFunction(fn, [elem], contextStack, sourceCodeInfo);
-                        assertString(newVal, sourceCodeInfo, { char: true });
-                        return newVal;
-                    })
-                        .join('');
+                var mapped = paramArray.map(function (p) { return executeFunction(fn, p, contextStack, sourceCodeInfo); });
+                if (!isString) {
+                    return mapped;
                 }
+                mapped.forEach(function (char) { return assertString(char, sourceCodeInfo); });
+                return mapped.join('');
             },
-            paramCount: 2,
+            paramCount: { min: 2 },
         },
         'pop': {
             evaluate: function (_a, sourceCodeInfo) {
@@ -1827,7 +1845,7 @@ var Lits = (function (exports) {
                 assertSeq(input, sourceCodeInfo);
                 if (Array.isArray(input)) {
                     var result = [];
-                    var _loop_1 = function (item) {
+                    var _loop_2 = function (item) {
                         assertAny(item, sourceCodeInfo);
                         if (!result.some(function (existingItem) { return deepEqual(existingItem, item, sourceCodeInfo); })) {
                             result.push(item);
@@ -1836,7 +1854,7 @@ var Lits = (function (exports) {
                     try {
                         for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
                             var item = input_1_1.value;
-                            _loop_1(item);
+                            _loop_2(item);
                         }
                     }
                     catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -3672,6 +3690,26 @@ var Lits = (function (exports) {
             }
             return value;
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var e_2, _a;
+            var value = true;
+            try {
+                for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    var param = params_1_1.value;
+                    value = asAny(param, sourceCodeInfo);
+                    if (!value)
+                        break;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return value;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -3956,7 +3994,7 @@ var Lits = (function (exports) {
             var value = bindingNode[1][1];
             var bindingValue = evaluateNode(value, contextStack);
             var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
-            contextStack.exportValues(values);
+            contextStack.exportValues(values, target[2]);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
@@ -3968,7 +4006,7 @@ var Lits = (function (exports) {
             walkDefaults(target, function (defaultNode) {
                 addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
             });
-            contextStack.addValues(getAllBindingTargetNames(target));
+            contextStack.addValues(getAllBindingTargetNames(target), target[2]);
             return bindingResult;
         },
     };
@@ -4111,14 +4149,14 @@ var Lits = (function (exports) {
                 _b.name = functionSymbol[1],
                 _b.evaluatedfunction = evaluatedFunction,
                 _b);
-            contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c));
+            contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var _b, _c;
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             var functionName = node[1][1][1];
-            contextStack.addValues((_b = {}, _b[functionName] = true, _b));
+            contextStack.addValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
             var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
             return getFunctionUnresolvedSymbols(node[1][2], contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
         },
@@ -4139,7 +4177,7 @@ var Lits = (function (exports) {
                 _b.name = functionSymbol[1],
                 _b.evaluatedfunction = evaluatedFunctionOverloades,
                 _b);
-            contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c));
+            contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
@@ -4147,7 +4185,7 @@ var Lits = (function (exports) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             var functionName = node[1][1][1];
             var fn = node[1][2];
-            contextStack.exportValues((_b = {}, _b[functionName] = true, _b));
+            contextStack.exportValues((_b = {}, _b[functionName] = true, _b), node[1][1][2]);
             var newContext = (_c = {}, _c[functionName] = { value: true }, _c);
             return getFunctionUnresolvedSymbols(fn, contextStack, getUndefinedSymbols, builtin, evaluateNode, newContext);
         },
@@ -4259,7 +4297,7 @@ var Lits = (function (exports) {
             var value = bindingNode[1][1];
             var bindingValue = evaluateNode(value, contextStack);
             var values = evalueateBindingNodeValues(target, bindingValue, function (Node) { return evaluateNode(Node, contextStack); });
-            contextStack.addValues(values);
+            contextStack.addValues(values, target[2]);
             return null;
         },
         getUndefinedSymbols: function (node, contextStack, _a) {
@@ -4271,7 +4309,7 @@ var Lits = (function (exports) {
             walkDefaults(target, function (defaultNode) {
                 addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
             });
-            contextStack.addValues(getAllBindingTargetNames(target));
+            contextStack.addValues(getAllBindingTargetNames(target), target[2]);
             return bindingResult;
         },
     };
@@ -4542,6 +4580,26 @@ var Lits = (function (exports) {
             }
             return value;
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var e_2, _a;
+            var value = false;
+            try {
+                for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    var param = params_1_1.value;
+                    value = asAny(param, sourceCodeInfo);
+                    if (value)
+                        break;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return value;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4560,6 +4618,11 @@ var Lits = (function (exports) {
             var firstResult = evaluateNode(firstNode, contextStack);
             return firstResult !== null && firstResult !== void 0 ? firstResult : (secondNode ? evaluateNode(secondNode, contextStack) : null);
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var firstParam = asAny(params[0], sourceCodeInfo);
+            var secondParam = params[1] !== undefined ? asAny(params[1], sourceCodeInfo) : null;
+            return firstParam !== null && firstParam !== void 0 ? firstParam : secondParam;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1].filter(function (n) { return !!n; }), contextStack, builtin, evaluateNode);
@@ -4574,6 +4637,9 @@ var Lits = (function (exports) {
             var evaluatedParams = params.map(function (paramNode) { return evaluateNode(paramNode, contextStack); });
             throw new RecurSignal(evaluatedParams);
         },
+        evaluateAsNormalExpression: function (params) {
+            throw new RecurSignal(params);
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4589,6 +4655,12 @@ var Lits = (function (exports) {
             });
             throw new UserDefinedError(message, node[2]);
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var message = asString(params[0], sourceCodeInfo, {
+                nonEmpty: true,
+            });
+            throw new UserDefinedError(message, undefined);
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols([node[1][1]], contextStack, builtin, evaluateNode);
@@ -4656,6 +4728,24 @@ var Lits = (function (exports) {
             }
             return result;
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var e_2, _a;
+            var result = [];
+            try {
+                for (var params_1 = __values(params), params_1_1 = params_1.next(); !params_1_1.done; params_1_1 = params_1.next()) {
+                    var param = params_1_1.value;
+                    result.push(asAny(param, sourceCodeInfo));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (params_1_1 && !params_1_1.done && (_a = params_1.return)) _a.call(params_1);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return result;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4687,6 +4777,16 @@ var Lits = (function (exports) {
             }
             return result;
         },
+        evaluateAsNormalExpression: function (params, sourceCodeInfo) {
+            var result = {};
+            for (var i = 0; i < params.length; i += 2) {
+                var key = params[i];
+                var value = params[i + 1];
+                assertString(key, sourceCodeInfo);
+                result[key] = value !== null && value !== void 0 ? value : null;
+            }
+            return result;
+        },
         getUndefinedSymbols: function (node, contextStack, _a) {
             var getUndefinedSymbols = _a.getUndefinedSymbols, builtin = _a.builtin, evaluateNode = _a.evaluateNode;
             return getUndefinedSymbols(node[1][1], contextStack, builtin, evaluateNode);
@@ -4812,7 +4912,7 @@ var Lits = (function (exports) {
                 return findUnresolvedSymbolsInNode(node[1], contextStack, builtin, evaluateNode);
             /* v8 ignore next 2 */
             default:
-                throw new Error("Unhandled node type: ".concat(nodeType));
+                throw new LitsError("Unhandled node type: ".concat(nodeType), node[2]);
         }
     }
 
@@ -5020,6 +5120,16 @@ var Lits = (function (exports) {
             var normalExpression = asNonUndefined(allNormalExpressions[fn.normalBuitinSymbolType], sourceCodeInfo);
             return normalExpression.evaluate(params, sourceCodeInfo, contextStack, { executeFunction: executeFunction });
         },
+        SpecialBuiltin: function (fn, params, sourceCodeInfo, contextStack, _a) {
+            var executeFunction = _a.executeFunction;
+            var specialExpression = asNonUndefined(specialExpressions[fn.specialBuiltinSymbolType], sourceCodeInfo);
+            if (specialExpression.evaluateAsNormalExpression) {
+                return specialExpression.evaluateAsNormalExpression(params, sourceCodeInfo, contextStack, { executeFunction: executeFunction });
+            }
+            else {
+                throw new LitsError("Special builtin function ".concat(fn.specialBuiltinSymbolType, " is not supported as normal expression."), sourceCodeInfo);
+            }
+        },
     };
 
     function evaluate(ast, contextStack) {
@@ -5075,7 +5185,21 @@ var Lits = (function (exports) {
     function evaluateNormalExpression(node, contextStack) {
         var sourceCodeInfo = node[2];
         var paramNodes = node[1][1];
-        var params = paramNodes.map(function (paramNode) { return evaluateNode(paramNode, contextStack); });
+        var params = [];
+        paramNodes.forEach(function (paramNode) {
+            if (isSpreadNode(paramNode)) {
+                var spreadValue = evaluateNode(paramNode[1], contextStack);
+                if (Array.isArray(spreadValue)) {
+                    params.push.apply(params, __spreadArray([], __read(spreadValue), false));
+                }
+                else {
+                    throw new LitsError("Spread operator requires an array, got ".concat(valueToString(paramNode)), paramNode[2]);
+                }
+            }
+            else {
+                params.push(evaluateNode(paramNode, contextStack));
+            }
+        });
         if (isNormalExpressionNodeWithName(node)) {
             var nameSymbol = node[1][0];
             if (isNormalBuiltinSymbolNode(nameSymbol)) {
@@ -5177,19 +5301,19 @@ var Lits = (function (exports) {
             var contexts = [{}, context];
             return new ContextStackImpl({ contexts: contexts });
         };
-        ContextStackImpl.prototype.exportValues = function (values) {
+        ContextStackImpl.prototype.exportValues = function (values, sourceCodeInfo) {
             var e_1, _a;
             try {
                 for (var _b = __values(Object.entries(values)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var _d = __read(_c.value, 2), name_1 = _d[0], value = _d[1];
                     if (this.globalContext[name_1]) {
-                        throw new Error("Cannot redefine exported value \"".concat(name_1, "\""));
+                        throw new LitsError("Cannot redefine exported value \"".concat(name_1, "\""), sourceCodeInfo);
                     }
                     if (specialExpressionKeys.includes(name_1)) {
-                        throw new Error("Cannot shadow special expression \"".concat(name_1, "\""));
+                        throw new LitsError("Cannot shadow special expression \"".concat(name_1, "\""), sourceCodeInfo);
                     }
                     if (normalExpressionKeys.includes(name_1)) {
-                        throw new Error("Cannot shadow builtin function \"".concat(name_1, "\""));
+                        throw new LitsError("Cannot shadow builtin function \"".concat(name_1, "\""), sourceCodeInfo);
                     }
                     this.globalContext[name_1] = { value: value };
                 }
@@ -5201,22 +5325,22 @@ var Lits = (function (exports) {
                 }
                 finally { if (e_1) throw e_1.error; }
             }
-            this.addValues(values);
+            this.addValues(values, sourceCodeInfo);
         };
-        ContextStackImpl.prototype.addValues = function (values) {
+        ContextStackImpl.prototype.addValues = function (values, sourceCodeInfo) {
             var e_2, _a;
             var currentContext = this.contexts[0];
             try {
                 for (var _b = __values(Object.entries(values)), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var _d = __read(_c.value, 2), name_2 = _d[0], value = _d[1];
                     if (currentContext[name_2]) {
-                        throw new Error("Cannot redefine value \"".concat(name_2, "\""));
+                        throw new LitsError("Cannot redefine value \"".concat(name_2, "\""), sourceCodeInfo);
                     }
                     if (specialExpressionKeys.includes(name_2)) {
-                        throw new Error("Cannot shadow special expression \"".concat(name_2, "\""));
+                        throw new LitsError("Cannot shadow special expression \"".concat(name_2, "\""), sourceCodeInfo);
                     }
                     if (normalExpressionKeys.includes(name_2)) {
-                        throw new Error("Cannot shadow builtin function \"".concat(name_2, "\""));
+                        throw new LitsError("Cannot shadow builtin function \"".concat(name_2, "\""), sourceCodeInfo);
                     }
                     currentContext[name_2] = { value: toAny(value) };
                 }
@@ -5296,18 +5420,36 @@ var Lits = (function (exports) {
             return null;
         };
         ContextStackImpl.prototype.evaluateSymbol = function (node) {
-            var _a;
+            var _a, _b;
             if (isSpecialBuiltinSymbolNode(node)) {
-                throw new Error('Special builtin symbols should not be evaluated');
+                var functionType = node[1];
+                switch (functionType) {
+                    case specialExpressionTypes['&&']:
+                    case specialExpressionTypes['||']:
+                    case specialExpressionTypes.array:
+                    case specialExpressionTypes.object:
+                    case specialExpressionTypes['defined?']:
+                    case specialExpressionTypes.recur:
+                    case specialExpressionTypes.throw:
+                    case specialExpressionTypes['??']:
+                        return _a = {},
+                            _a[FUNCTION_SYMBOL] = true,
+                            _a.functionType = 'SpecialBuiltin',
+                            _a.specialBuiltinSymbolType = functionType,
+                            _a.sourceCodeInfo = node[2],
+                            _a;
+                    default:
+                        throw new LitsError("Unknown special builtin symbol type: ".concat(functionType), node[2]);
+                }
             }
             if (isNormalBuiltinSymbolNode(node)) {
                 var type = node[1];
-                return _a = {},
-                    _a[FUNCTION_SYMBOL] = true,
-                    _a.functionType = 'Builtin',
-                    _a.normalBuitinSymbolType = type,
-                    _a.sourceCodeInfo = node[2],
-                    _a;
+                return _b = {},
+                    _b[FUNCTION_SYMBOL] = true,
+                    _b.functionType = 'Builtin',
+                    _b.normalBuitinSymbolType = type,
+                    _b.sourceCodeInfo = node[2],
+                    _b;
             }
             var lookUpResult = this.lookUp(node);
             if (isContextEntry(lookUpResult))
@@ -5979,7 +6121,7 @@ var Lits = (function (exports) {
         }
         return node;
     }
-    function getPrecedence(operatorSign) {
+    function getPrecedence(operatorSign, sourceCodeInfo) {
         switch (operatorSign) {
             case '**': // exponentiation
                 return exponentiationPrecedence;
@@ -6018,7 +6160,7 @@ var Lits = (function (exports) {
             // leave room for binaryFunctionalOperatorPrecedence = 1
             /* v8 ignore next 2 */
             default:
-                throw new Error("Unknown binary operator: ".concat(operatorSign));
+                throw new LitsError("Unknown binary operator: ".concat(operatorSign), sourceCodeInfo);
         }
     }
     function createNamedNormalExpressionNode(symbolNode, params, sourceCodeInfo) {
@@ -6151,7 +6293,7 @@ var Lits = (function (exports) {
             while (!this.isAtExpressionEnd()) {
                 if (isA_BinaryOperatorToken(operator)) {
                     var name_1 = operator[1];
-                    var newPrecedece = getPrecedence(name_1);
+                    var newPrecedece = getPrecedence(name_1, operator[2]);
                     if (newPrecedece <= precedence
                         // ** (exponentiation) is right associative
                         && !(newPrecedece === exponentiationPrecedence && precedence === exponentiationPrecedence)) {
@@ -6231,7 +6373,7 @@ var Lits = (function (exports) {
                 this.advance();
                 var expression = this.parseExpression();
                 if (!isRParenToken(this.peek())) {
-                    throw new Error('Expected closing parenthesis');
+                    throw new LitsError('Expected closing parenthesis', this.peek()[2]);
                 }
                 this.advance();
                 return expression;
@@ -6353,7 +6495,13 @@ var Lits = (function (exports) {
             this.advance();
             var params = [];
             while (!this.isAtEnd() && !isRParenToken(this.peek())) {
-                params.push(this.parseExpression());
+                if (isOperatorToken(this.peek(), '...')) {
+                    this.advance();
+                    params.push(withSourceCodeInfo([NodeTypes.Spread, this.parseExpression()], this.peek()[2]));
+                }
+                else {
+                    params.push(this.parseExpression());
+                }
                 var nextToken = this.peek();
                 if (!isOperatorToken(nextToken, ',') && !isRParenToken(nextToken)) {
                     throw new LitsError('Expected comma or closing parenthesis', this.peek()[2]);
@@ -6409,7 +6557,7 @@ var Lits = (function (exports) {
                         throw new LitsError("".concat(type, " is not allowed"), symbol[2]);
                     /* v8 ignore next 2 */
                     default:
-                        throw new Error("Unknown special expression: ".concat(type));
+                        throw new LitsError("Unknown special expression: ".concat(type), symbol[2]);
                 }
             }
             else if (isNormalBuiltinSymbolNode(symbol) || isNormalBuiltinSymbolNode(symbol)) {
@@ -11167,19 +11315,23 @@ var Lits = (function (exports) {
                 type: 'any',
                 rest: true,
             },
-            args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { seq: {
+            args: __assign(__assign({}, getOperatorArgs('sequence', 'function')), { seqs: {
                     type: 'sequence',
+                    rest: true,
+                    description: 'At least one.',
                 }, fun: {
                     type: 'function',
                 } }),
             variants: [
-                { argumentNames: ['seq', 'fun'] },
+                { argumentNames: ['seqs', 'fun'] },
             ],
-            description: 'Creates a new array populated with the results of calling $fun on every elements in $seq.',
+            description: 'Creates a new array populated with the results of calling $fun on every element in $seqs.',
             examples: [
+                '[1, 2, 3] map -',
                 '[1, 2, 3] map -> -($)',
                 'map(["Albert", "Mojir", 42], str)',
                 'map([1, 2, 3], inc)',
+                'map([1, 2, 3], [1, 10, 100], *)',
             ],
         },
         'filter': {