@mojir/lits 2.1.2 → 2.1.4

package/dist/index.esm.js

@@ -93,9 +93,15 @@ function getCodeMarker(sourceCodeInfo) {
 }
 
 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) {
@@ -208,6 +214,7 @@ var functionTypes = [
     'SomePred',
     'Fnull',
     'Builtin',
+    'SpecialBuiltin',
     'NativeJsFunction',
 ];
 var functionTypeSet = new Set(functionTypes);
@@ -1255,26 +1262,37 @@ var sequenceNormalExpression = {
         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) {
@@ -1824,7 +1842,7 @@ var sequenceNormalExpression = {
             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);
@@ -1833,7 +1851,7 @@ var sequenceNormalExpression = {
                 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 }; }
@@ -3669,6 +3687,26 @@ var andSpecialExpression = {
         }
         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);
@@ -3953,7 +3991,7 @@ var defSpecialExpression = {
         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) {
@@ -3965,7 +4003,7 @@ var defSpecialExpression = {
         walkDefaults(target, function (defaultNode) {
             addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
         });
-        contextStack.addValues(getAllBindingTargetNames(target));
+        contextStack.addValues(getAllBindingTargetNames(target), target[2]);
         return bindingResult;
     },
 };
@@ -4108,14 +4146,14 @@ var functionSpecialExpression = {
             _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);
     },
@@ -4136,7 +4174,7 @@ var defnSpecialExpression = {
             _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) {
@@ -4144,7 +4182,7 @@ var defnSpecialExpression = {
         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);
     },
@@ -4256,7 +4294,7 @@ var letSpecialExpression = {
         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) {
@@ -4268,7 +4306,7 @@ var letSpecialExpression = {
         walkDefaults(target, function (defaultNode) {
             addToSet(bindingResult, getUndefinedSymbols([defaultNode], contextStack, builtin, evaluateNode));
         });
-        contextStack.addValues(getAllBindingTargetNames(target));
+        contextStack.addValues(getAllBindingTargetNames(target), target[2]);
         return bindingResult;
     },
 };
@@ -4539,6 +4577,26 @@ var orSpecialExpression = {
         }
         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);
@@ -4557,6 +4615,11 @@ var qqSpecialExpression = {
         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);
@@ -4571,6 +4634,9 @@ var recurSpecialExpression = {
         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);
@@ -4586,6 +4652,12 @@ var throwSpecialExpression = {
         });
         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);
@@ -4653,6 +4725,24 @@ var arraySpecialExpression = {
         }
         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);
@@ -4684,6 +4774,16 @@ var objectSpecialExpression = {
         }
         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);
@@ -4809,7 +4909,7 @@ function findUnresolvedSymbolsInNode(node, contextStack, builtin, evaluateNode)
             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]);
     }
 }
 
@@ -5017,6 +5117,16 @@ var functionExecutors = {
         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) {
@@ -5072,7 +5182,21 @@ function evaluateReservedSymbol(node) {
 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)) {
@@ -5174,19 +5298,19 @@ var ContextStackImpl = /** @class */ (function () {
         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 };
             }
@@ -5198,22 +5322,22 @@ var ContextStackImpl = /** @class */ (function () {
             }
             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) };
             }
@@ -5293,18 +5417,36 @@ var ContextStackImpl = /** @class */ (function () {
         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))
@@ -5976,7 +6118,7 @@ function withSourceCodeInfo(node, sourceCodeInfo) {
     }
     return node;
 }
-function getPrecedence(operatorSign) {
+function getPrecedence(operatorSign, sourceCodeInfo) {
     switch (operatorSign) {
         case '**': // exponentiation
             return exponentiationPrecedence;
@@ -6015,7 +6157,7 @@ function getPrecedence(operatorSign) {
         // 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) {
@@ -6148,7 +6290,7 @@ var Parser = /** @class */ (function () {
         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)) {
@@ -6228,7 +6370,7 @@ var Parser = /** @class */ (function () {
             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;
@@ -6350,7 +6492,13 @@ var Parser = /** @class */ (function () {
         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]);
@@ -6406,7 +6554,7 @@ var Parser = /** @class */ (function () {
                     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)) {
@@ -11164,19 +11312,23 @@ var sequenceReference = {
             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': {