@mojir/lits 2.1.20 → 2.1.22

package/dist/cli/cli.js

@@ -92,7 +92,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-var version = "2.1.20";
+var version = "2.1.22";
 
 function getCodeMarker(sourceCodeInfo) {
     if (!sourceCodeInfo.position || !sourceCodeInfo.code)
@@ -918,6 +918,91 @@ function approxEqual(a, b, epsilon) {
 function approxZero(value) {
     return Math.abs(value) < EPSILON;
 }
+function paramCountAccepts(paramsCount, nbrOfParams) {
+    if (typeof paramsCount === 'number') {
+        return paramsCount === nbrOfParams;
+    }
+    var min = paramsCount.min, max = paramsCount.max, even = paramsCount.even, odd = paramsCount.odd;
+    if (even && nbrOfParams % 2 !== 0) {
+        return false;
+    }
+    if (odd && nbrOfParams % 2 !== 1) {
+        return false;
+    }
+    if (typeof min === 'number' && nbrOfParams < min) {
+        return false;
+    }
+    if (typeof max === 'number' && nbrOfParams > max) {
+        return false;
+    }
+    return true;
+}
+function paramCountAcceptsMin(paramsCount, nbrOfParams) {
+    if (typeof paramsCount === 'number') {
+        return nbrOfParams >= paramsCount;
+    }
+    var min = paramsCount.min;
+    if (typeof min === 'number' && nbrOfParams < min) {
+        return false;
+    }
+    return true;
+}
+function getCommonParamCount(params) {
+    return params.reduce(function (acc, param) {
+        if (acc === null) {
+            return null;
+        }
+        var paramCount = (typeof param === 'number' || isColl(param)) ? 1 : param.paramCount;
+        if (typeof acc === 'number' && typeof paramCount === 'number') {
+            return acc === paramCount ? acc : null;
+        }
+        if (typeof paramCount === 'number') {
+            if (paramCountAccepts(acc, paramCount)) {
+                return paramCount;
+            }
+            return null;
+        }
+        if (typeof acc === 'number') {
+            if (paramCountAccepts(paramCount, acc)) {
+                return acc;
+            }
+            return null;
+        }
+        var aMin = paramCount.min, aMax = paramCount.max, aEven = paramCount.even, aOdd = paramCount.odd;
+        var bMin = acc.min, bMax = acc.max, bEven = acc.even, bOdd = acc.odd;
+        var min = typeof aMin === 'number' && typeof bMin === 'number'
+            ? Math.max(aMin, bMin)
+            : typeof aMin === 'number' ? aMin : typeof bMin === 'number' ? bMin : undefined;
+        var max = typeof aMax === 'number' && typeof bMax === 'number'
+            ? Math.min(aMax, bMax)
+            : typeof aMax === 'number' ? aMax : typeof bMax === 'number' ? bMax : undefined;
+        var even = aEven !== null && aEven !== void 0 ? aEven : bEven;
+        var odd = aOdd !== null && aOdd !== void 0 ? aOdd : bOdd;
+        if (min !== undefined && max !== undefined && min > max) {
+            return null;
+        }
+        if (even && odd) {
+            return null;
+        }
+        if (odd && min !== undefined && min < 1) {
+            return null;
+        }
+        return { min: min, max: max, even: even, odd: odd };
+    }, {});
+}
+function getParamCount(param) {
+    return (typeof param === 'number' || isColl(param)) ? 1 : param.paramCount;
+}
+function paramCountMinus(paramCount, count) {
+    if (typeof paramCount === 'number') {
+        return paramCount - count;
+    }
+    var min = paramCount.min === undefined ? undefined : paramCount.min - count;
+    var max = paramCount.max === undefined ? undefined : paramCount.max - count;
+    var even = paramCount.even === undefined ? undefined : count % 2 === 0 ? true : undefined;
+    var odd = paramCount.odd === undefined ? undefined : count % 2 === 0 ? true : undefined;
+    return { min: min, max: max, even: even, odd: odd };
+}
 
 // isArray not needed, use Array.isArary
 function asArray(value, sourceCodeInfo) {
@@ -4581,11 +4666,13 @@ var functionalNormalExpression = {
     'comp': {
         evaluate: function (params, sourceCodeInfo) {
             var _a;
+            params.forEach(function (param) { return assertFunctionLike(param, sourceCodeInfo); });
             return _a = {},
                 _a[FUNCTION_SYMBOL] = true,
                 _a.sourceCodeInfo = sourceCodeInfo,
                 _a.functionType = 'Comp',
                 _a.params = params,
+                _a.paramCount = params.length > 0 ? getParamCount(params.at(-1)) : 1,
                 _a;
         },
         paramCount: {},
@@ -4599,6 +4686,7 @@ var functionalNormalExpression = {
                 _b.sourceCodeInfo = sourceCodeInfo,
                 _b.functionType = 'Constantly',
                 _b.value = toAny(value),
+                _b.paramCount = {},
                 _b;
         },
         paramCount: 1,
@@ -4606,11 +4694,17 @@ var functionalNormalExpression = {
     'juxt': {
         evaluate: function (params, sourceCodeInfo) {
             var _a;
+            params.forEach(function (param) { return assertFunctionLike(param, sourceCodeInfo); });
+            var paramCount = getCommonParamCount(params);
+            if (paramCount === null) {
+                throw new LitsError('All functions must accept the same number of arguments', sourceCodeInfo);
+            }
             return _a = {},
                 _a[FUNCTION_SYMBOL] = true,
                 _a.sourceCodeInfo = sourceCodeInfo,
                 _a.functionType = 'Juxt',
                 _a.params = params,
+                _a.paramCount = paramCount,
                 _a;
         },
         paramCount: { min: 1 },
@@ -4619,11 +4713,13 @@ var functionalNormalExpression = {
         evaluate: function (_a, sourceCodeInfo) {
             var _b;
             var _c = __read(_a, 1), fn = _c[0];
+            var fun = asFunctionLike(fn, sourceCodeInfo);
             return _b = {},
                 _b[FUNCTION_SYMBOL] = true,
                 _b.sourceCodeInfo = sourceCodeInfo,
                 _b.functionType = 'Complement',
-                _b.function = asFunctionLike(fn, sourceCodeInfo),
+                _b.function = fun,
+                _b.paramCount = getParamCount(fun),
                 _b;
         },
         paramCount: 1,
@@ -4636,6 +4732,7 @@ var functionalNormalExpression = {
                 _a.sourceCodeInfo = sourceCodeInfo,
                 _a.functionType = 'EveryPred',
                 _a.params = params,
+                _a.paramCount = 1,
                 _a;
         },
         paramCount: { min: 1 },
@@ -4648,6 +4745,7 @@ var functionalNormalExpression = {
                 _a.sourceCodeInfo = sourceCodeInfo,
                 _a.functionType = 'SomePred',
                 _a.params = params,
+                _a.paramCount = 1,
                 _a;
         },
         paramCount: { min: 1 },
@@ -4656,12 +4754,14 @@ var functionalNormalExpression = {
         evaluate: function (_a, sourceCodeInfo) {
             var _b;
             var _c = __read(_a), fn = _c[0], params = _c.slice(1);
+            var fun = asFunctionLike(fn, sourceCodeInfo);
             return _b = {},
                 _b[FUNCTION_SYMBOL] = true,
                 _b.sourceCodeInfo = sourceCodeInfo,
                 _b.functionType = 'Fnull',
-                _b.function = asFunctionLike(fn, sourceCodeInfo),
+                _b.function = fun,
                 _b.params = params,
+                _b.paramCount = getParamCount(fun),
                 _b;
         },
         paramCount: { min: 2 },
@@ -11706,9 +11806,8 @@ var numberReservedSymbolRecord = {
     'NaN': Number.NaN,
 };
 var reservedSymbolRecord = __assign(__assign({}, nonNumberReservedSymbolRecord), numberReservedSymbolRecord);
-var validReservedSymbolRecord = __assign(__assign({}, nonNumberReservedSymbolRecord), numberReservedSymbolRecord);
 function isReservedSymbol(symbol) {
-    return symbol in validReservedSymbolRecord;
+    return symbol in reservedSymbolRecord;
 }
 function isNumberReservedSymbol(symbol) {
     return symbol in numberReservedSymbolRecord;
@@ -11737,12 +11836,16 @@ var functionSpecialExpression = {
         assertUserDefinedSymbolNode(functionSymbol, node[2]);
         assertNameNotDefined(functionSymbol[1], contextStack, builtin, node[2]);
         var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
+        var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
+        var max = evaluatedFunction[0].some(function (arg) { return arg[0] === bindingTargetTypes.rest; }) ? undefined : evaluatedFunction[0].length;
+        var paramCount = min === max ? min : { min: min, max: max };
         var litsFunction = (_b = {},
             _b[FUNCTION_SYMBOL] = true,
             _b.sourceCodeInfo = node[2],
             _b.functionType = 'UserDefined',
             _b.name = functionSymbol[1],
             _b.evaluatedfunction = evaluatedFunction,
+            _b.paramCount = paramCount,
             _b);
         contextStack.addValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
         return litsFunction;
@@ -11764,13 +11867,17 @@ var defnSpecialExpression = {
         var _d = __read(node[1], 3), functionSymbol = _d[1], fn = _d[2];
         assertUserDefinedSymbolNode(functionSymbol, node[2]);
         assertNameNotDefined(functionSymbol[1], contextStack, builtin, node[2]);
-        var evaluatedFunctionOverloades = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
+        var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
+        var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
+        var max = evaluatedFunction[0].some(function (arg) { return arg[0] === bindingTargetTypes.rest; }) ? undefined : evaluatedFunction[0].length;
+        var paramCount = min === max ? min : { min: min, max: max };
         var litsFunction = (_b = {},
             _b[FUNCTION_SYMBOL] = true,
             _b.sourceCodeInfo = node[2],
             _b.functionType = 'UserDefined',
             _b.name = functionSymbol[1],
-            _b.evaluatedfunction = evaluatedFunctionOverloades,
+            _b.evaluatedfunction = evaluatedFunction,
+            _b.paramCount = paramCount,
             _b);
         contextStack.exportValues((_c = {}, _c[functionSymbol[1]] = litsFunction, _c), functionSymbol[2]);
         return litsFunction;
@@ -11792,12 +11899,16 @@ var fnSpecialExpression = {
         var builtin = _a.builtin, getUndefinedSymbols = _a.getUndefinedSymbols, evaluateNode = _a.evaluateNode;
         var fn = node[1][1];
         var evaluatedFunction = evaluateFunction(fn, contextStack, builtin, getUndefinedSymbols, evaluateNode);
+        var min = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
+        var max = evaluatedFunction[0].some(function (arg) { return arg[0] === bindingTargetTypes.rest; }) ? undefined : evaluatedFunction[0].length;
+        var paramCount = min === max ? min : { min: min, max: max };
         var litsFunction = (_b = {},
             _b[FUNCTION_SYMBOL] = true,
             _b.sourceCodeInfo = node[2],
             _b.functionType = 'UserDefined',
             _b.name = undefined,
             _b.evaluatedfunction = evaluatedFunction,
+            _b.paramCount = paramCount,
             _b);
         return litsFunction;
     },
@@ -12413,12 +12524,6 @@ new Set(specialExpressionKeys);
 // TODO, remove
 // console.log('builtin', [...specialExpressionKeys, ...normalExpressionKeys].length)
 
-function checkParams(evaluatedFunction, nbrOfParams, sourceCodeInfo) {
-    var minArity = evaluatedFunction[0].filter(function (arg) { return arg[0] !== bindingTargetTypes.rest && arg[1][1] === undefined; }).length;
-    if (nbrOfParams < minArity) {
-        throw new LitsError("Unexpected number of arguments. Expected at least ".concat(minArity, ", got ").concat(nbrOfParams, "."), sourceCodeInfo);
-    }
-}
 var functionExecutors = {
     NativeJsFunction: function (fn, params, sourceCodeInfo) {
         var _a;
@@ -12438,7 +12543,10 @@ var functionExecutors = {
         var evaluateNode = _a.evaluateNode;
         var _loop_1 = function () {
             var e_1, _b;
-            checkParams(fn.evaluatedfunction, params.length, sourceCodeInfo);
+            if (!paramCountAcceptsMin(fn.paramCount, params.length)) {
+                throw new LitsError("Expected ".concat(fn.paramCount, " arguments, got ").concat(params.length, "."), sourceCodeInfo);
+            }
+            // checkParams(fn.evaluatedfunction, params.length, sourceCodeInfo)
             var evaluatedFunction = fn.evaluatedfunction;
             var args = evaluatedFunction[0];
             var nbrOfNonRestArgs = args.filter(function (arg) { return arg[0] !== bindingTargetTypes.rest; }).length;
@@ -12735,6 +12843,7 @@ function evaluateNormalExpression(node, contextStack) {
                 _a.params = params,
                 _a.placeholders = placeholders,
                 _a.sourceCodeInfo = sourceCodeInfo,
+                _a.paramCount = paramCountMinus(getParamCount(fn), params.length),
                 _a);
             return partialFunction;
         }
@@ -12757,11 +12866,12 @@ function evaluateNormalExpression(node, contextStack) {
         if (placeholders.length > 0) {
             var partialFunction = (_b = {},
                 _b[FUNCTION_SYMBOL] = true,
-                _b.function = asFunctionLike(fn, sourceCodeInfo),
+                _b.function = fn,
                 _b.functionType = 'Partial',
                 _b.params = params,
                 _b.placeholders = placeholders,
                 _b.sourceCodeInfo = sourceCodeInfo,
+                _b.paramCount = paramCountMinus(getParamCount(fn), params.length),
                 _b);
             return partialFunction;
         }
@@ -12983,11 +13093,13 @@ var ContextStackImpl = /** @class */ (function () {
         }
         if (isNormalBuiltinSymbolNode(node)) {
             var type = node[1];
+            var normalExpression = allNormalExpressions[type];
             return _b = {},
                 _b[FUNCTION_SYMBOL] = true,
                 _b.functionType = 'Builtin',
                 _b.normalBuitinSymbolType = type,
                 _b.sourceCodeInfo = node[2],
+                _b.paramCount = normalExpression.paramCount,
                 _b;
         }
         var lookUpResult = this.lookUp(node);
@@ -13024,6 +13136,7 @@ function createContextStack(params) {
                         name: name
                     },
                     _b[FUNCTION_SYMBOL] = true,
+                    _b.paramCount = {},
                     _b);
                 return acc;
             }, {}),
@@ -14822,7 +14935,7 @@ var Parser = /** @class */ (function () {
     return Parser;
 }());
 
-var litsCommands = new Set(__spreadArray(__spreadArray([], __read(normalExpressionKeys), false), __read(specialExpressionKeys), false));
+var litsCommands = new Set(__spreadArray(__spreadArray(__spreadArray([], __read(normalExpressionKeys), false), __read(specialExpressionKeys), false), __read(Object.keys(reservedSymbolRecord)), false));
 // TODO: replace with get suggestions function
 var AutoCompleter = /** @class */ (function () {
     function AutoCompleter(originalProgram, originalPosition, lits, params) {

package/dist/cli/src/builtin/interface.d.ts

@@ -5,7 +5,7 @@ import type { Any, Arr } from '../interface';
 import type { SpecialExpressionNode } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
 import type { SpecialExpressions } from '.';
-export type Count = number | {
+export type ParamCount = number | {
     min?: number;
     max?: number;
     even?: true;
@@ -16,7 +16,7 @@ export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceC
 }) => T;
 export interface BuiltinNormalExpression<T> {
     evaluate: NormalExpressionEvaluator<T>;
-    paramCount: Count;
+    paramCount: ParamCount;
     aliases?: string[];
 }
 export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
@@ -29,7 +29,7 @@ export interface EvaluateHelpers {
 export interface BuiltinSpecialExpression<T, N extends SpecialExpressionNode> {
     evaluate: (node: N, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
     evaluateAsNormalExpression?: NormalExpressionEvaluator<T>;
-    paramCount: Count;
+    paramCount: ParamCount;
     getUndefinedSymbols: (node: N, contextStack: ContextStack, params: {
         getUndefinedSymbols: GetUndefinedSymbols;
         builtin: Builtin;

package/dist/cli/src/builtin/specialExpressions/functions.d.ts

@@ -1,4 +1,4 @@
-import type { LitsFunction, SpecialExpressionNode, SymbolNode } from '../../parser/types';
+import { type LitsFunction, type SpecialExpressionNode, type SymbolNode } from '../../parser/types';
 import type { BuiltinSpecialExpression } from '../interface';
 import type { Function } from '../utils';
 import type { specialExpressionTypes } from '../specialExpressionTypes';

package/dist/cli/src/parser/types.d.ts

@@ -1,5 +1,6 @@
 import type { JsFunction } from '../Lits/Lits';
 import type { SpecialExpressionType } from '../builtin';
+import type { ParamCount } from '../builtin/interface';
 import type { specialExpressionTypes } from '../builtin/specialExpressionTypes';
 import type { FunctionType, NodeType, NodeTypes } from '../constants/constants';
 import type { Context } from '../evaluator/interface';
@@ -15,6 +16,7 @@ interface GenericLitsFunction {
     [FUNCTION_SYMBOL]: true;
     sourceCodeInfo?: SourceCodeInfo;
     functionType: FunctionType;
+    paramCount: ParamCount;
 }
 export interface RegularExpression {
     [REGEXP_SYMBOL]: true;

package/dist/cli/src/tokenizer/reservedNames.d.ts

@@ -58,44 +58,6 @@ export declare const reservedSymbolRecord: {
     readonly as: null;
     readonly _: null;
 };
-export declare const validReservedSymbolRecord: {
-    readonly E: number;
-    readonly '-E': number;
-    readonly ε: number;
-    readonly '-\u03B5': number;
-    readonly PI: number;
-    readonly '-PI': number;
-    readonly π: number;
-    readonly '-\u03C0': number;
-    readonly PHI: number;
-    readonly '-PHI': number;
-    readonly φ: number;
-    readonly '-\u03C6': number;
-    readonly POSITIVE_INFINITY: number;
-    readonly '\u221E': number;
-    readonly NEGATIVE_INFINITY: number;
-    readonly '-\u221E': number;
-    readonly MAX_SAFE_INTEGER: number;
-    readonly MIN_SAFE_INTEGER: number;
-    readonly MAX_VALUE: number;
-    readonly MIN_VALUE: number;
-    readonly NaN: number;
-    readonly true: true;
-    readonly false: false;
-    readonly null: null;
-    readonly else: null;
-    readonly case: null;
-    readonly each: null;
-    readonly in: null;
-    readonly when: null;
-    readonly while: null;
-    readonly catch: null;
-    readonly function: null;
-    readonly export: null;
-    readonly as: null;
-    readonly _: null;
-};
-export type ValidReservedSymbol = keyof typeof validReservedSymbolRecord;
 export type ReservedSymbol = keyof typeof reservedSymbolRecord;
-export declare function isReservedSymbol(symbol: string): symbol is keyof typeof validReservedSymbolRecord;
+export declare function isReservedSymbol(symbol: string): symbol is keyof typeof reservedSymbolRecord;
 export declare function isNumberReservedSymbol(symbol: string): symbol is keyof typeof numberReservedSymbolRecord;

package/dist/cli/src/tokenizer/token.d.ts

@@ -1,4 +1,4 @@
-import type { ValidReservedSymbol } from './reservedNames';
+import type { ReservedSymbol } from './reservedNames';
 import { type SymbolicBinaryOperator, type SymbolicOperator } from './operators';
 export declare const tokenTypes: readonly ["LBrace", "LBracket", "RBrace", "RBracket", "LParen", "RParen", "BasePrefixedNumber", "MultiLineComment", "Number", "Operator", "RegexpShorthand", "ReservedSymbol", "SingleLineComment", "String", "Symbol", "Whitespace"];
 export type TokenType = typeof tokenTypes[number];
@@ -16,7 +16,7 @@ export type MultiLineCommentToken = GenericToken<'MultiLineComment'>;
 export type NumberToken = GenericToken<'Number'>;
 export type OperatorToken<T extends SymbolicOperator = SymbolicOperator> = GenericToken<'Operator', T>;
 export type RegexpShorthandToken = GenericToken<'RegexpShorthand'>;
-export type ReservedSymbolToken<T extends ValidReservedSymbol = ValidReservedSymbol> = GenericToken<'ReservedSymbol', T>;
+export type ReservedSymbolToken<T extends ReservedSymbol = ReservedSymbol> = GenericToken<'ReservedSymbol', T>;
 export type SingleLineCommentToken = GenericToken<'SingleLineComment'>;
 export type StringToken = GenericToken<'String'>;
 export type SymbolToken<T extends string = string> = GenericToken<'Symbol', T>;
@@ -34,9 +34,9 @@ export interface SourceCodeInfo {
 export declare function isSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): token is SymbolToken<T>;
 export declare function assertSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): asserts token is SymbolToken<T>;
 export declare function asSymbolToken<T extends string>(token: Token | undefined | undefined, symbolName?: T): SymbolToken<T>;
-export declare function isReservedSymbolToken<T extends ValidReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): token is ReservedSymbolToken<T>;
-export declare function assertReservedSymbolToken<T extends ValidReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): asserts token is ReservedSymbolToken<T>;
-export declare function asReservedSymbolToken<T extends ValidReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): ReservedSymbolToken<T>;
+export declare function isReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): token is ReservedSymbolToken<T>;
+export declare function assertReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): asserts token is ReservedSymbolToken<T>;
+export declare function asReservedSymbolToken<T extends ReservedSymbol>(token: Token | undefined | undefined, symbolName?: T): ReservedSymbolToken<T>;
 export declare function isSingleLineCommentToken(token: Token | undefined): token is SingleLineCommentToken;
 export declare function assertSingleLineCommentToken(token: Token | undefined): asserts token is SingleLineCommentToken;
 export declare function asSingleLineCommentToken(token: Token | undefined): SingleLineCommentToken;

package/dist/cli/src/typeGuards/index.d.ts

@@ -1,12 +1,12 @@
-import type { Count } from '../builtin/interface';
+import type { ParamCount } from '../builtin/interface';
 import type { UnknownRecord } from '../interface';
 import type { NormalExpressionNodeWithName } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
-export declare function assertNumberOfParams(count: Count, node: NormalExpressionNodeWithName): void;
+export declare function assertNumberOfParams(count: ParamCount, node: NormalExpressionNodeWithName): void;
 export declare function isNonUndefined<T>(value: T | undefined): value is T;
 export declare function asNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): T;
 export declare function assertNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): asserts value is T;
 export declare function isUnknownRecord(value: unknown): value is Record<string, unknown>;
 export declare function assertUnknownRecord(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is UnknownRecord;
 export declare function asUnknownRecord(value: unknown, sourceCodeInfo?: SourceCodeInfo): UnknownRecord;
-export declare function canBeOperator(count: Count): boolean;
+export declare function canBeOperator(count: ParamCount): boolean;

package/dist/cli/src/utils/index.d.ts

@@ -1,6 +1,7 @@
 import type { Any, Coll } from '../interface';
-import type { NativeJsFunction } from '../parser/types';
+import type { FunctionLike, NativeJsFunction, NormalExpressionNodeWithName } from '../parser/types';
 import type { SourceCodeInfo } from '../tokenizer/token';
+import type { ParamCount } from '../builtin/interface';
 export declare function collHasKey(coll: unknown, key: string | number): boolean;
 export declare function compare<T extends string | number>(a: T, b: T, sourceCodeInfo: SourceCodeInfo | undefined): number;
 export declare function deepEqual(a: unknown, b: unknown, sourceCodeInfo?: SourceCodeInfo): boolean;
@@ -13,3 +14,9 @@ export declare function addToSet<T>(target: Set<T>, source: Set<T>): void;
 export declare const EPSILON = 1e-10;
 export declare function approxEqual(a: number, b: number, epsilon?: number): boolean;
 export declare function approxZero(value: number): boolean;
+export declare function mergeParamCounts(count: ParamCount, node: NormalExpressionNodeWithName): void;
+export declare function assertNumberOfParams(count: ParamCount, node: NormalExpressionNodeWithName): void;
+export declare function paramCountAcceptsMin(paramsCount: ParamCount, nbrOfParams: number): boolean;
+export declare function getCommonParamCount(params: FunctionLike[]): ParamCount | null;
+export declare function getParamCount(param: FunctionLike): ParamCount;
+export declare function paramCountMinus(paramCount: ParamCount, count: number): ParamCount;