@mojir/lits 2.1.24 → 2.1.26

package/dist/cli/src/Lits/Lits.d.ts

@@ -3,7 +3,7 @@ import type { Any } from '../interface';
 import type { Ast, LitsFunction } from '../parser/types';
 import type { TokenStream } from '../tokenizer/tokenize';
 import { AutoCompleter } from '../AutoCompleter/AutoCompleter';
-import type { ParamCount } from '../builtin/interface';
+import type { Arity } from '../builtin/interface';
 import { Cache } from './Cache';
 export interface LitsRuntimeInfo {
     astCache: Cache | null;
@@ -12,7 +12,8 @@ export interface LitsRuntimeInfo {
 }
 export interface JsFunction {
     fn: (...args: any[]) => unknown;
-    paramCount?: ParamCount;
+    arity?: Arity;
+    docString?: string;
 }
 export interface ContextParams {
     globalContext?: Context;

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

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

package/dist/cli/src/builtin/normalExpressions/categories/meta.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '../../../../reference';
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare function getMetaNormalExpression(normalExpressionReference: Record<string, FunctionReference>): BuiltinNormalExpressions;

package/dist/cli/src/builtin/normalExpressions/index.d.ts

@@ -1,5 +1,8 @@
 import type { BuiltinNormalExpression, BuiltinNormalExpressions } from '../interface';
 import type { Any } from '../../interface';
+import type { FunctionReference } from '../../../reference';
+import type { NormalExpressionName } from '../../../reference/api';
+export declare function setNormalExpressionReference(reference: Record<NormalExpressionName, FunctionReference>): void;
 export declare const normalExpressions: BuiltinNormalExpressions;
 export declare const normalExpressionTypes: Record<string, number>;
 export declare const allNormalExpressions: BuiltinNormalExpression<Any>[];

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

@@ -2,8 +2,8 @@ import { type LitsFunction, type SpecialExpressionNode, type SymbolNode } from '
 import type { BuiltinSpecialExpression } from '../interface';
 import type { Function } from '../utils';
 import type { specialExpressionTypes } from '../specialExpressionTypes';
-export type DefnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_defn'], SymbolNode, Function]>;
-export type FunctionNode = SpecialExpressionNode<[typeof specialExpressionTypes['function'], SymbolNode, Function]>;
+export type DefnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_defn'], SymbolNode, Function, string]>;
+export type FunctionNode = SpecialExpressionNode<[typeof specialExpressionTypes['function'], SymbolNode, Function, string]>;
 export type FnNode = SpecialExpressionNode<[typeof specialExpressionTypes['0_fn'], Function]>;
 export declare const functionSpecialExpression: BuiltinSpecialExpression<LitsFunction, FunctionNode>;
 export declare const defnSpecialExpression: BuiltinSpecialExpression<LitsFunction, DefnNode>;

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

@@ -46,6 +46,7 @@ export declare class Parser {
     private parseSymbol;
     private parseReservedSymbol;
     private parseNumber;
+    private parseDocString;
     private parseString;
     private parseRegexpShorthand;
 }

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

@@ -1,6 +1,6 @@
 import type { JsFunction } from '../Lits/Lits';
 import type { SpecialExpressionType } from '../builtin';
-import type { ParamCount } from '../builtin/interface';
+import type { Arity } from '../builtin/interface';
 import type { specialExpressionTypes } from '../builtin/specialExpressionTypes';
 import type { FunctionType, NodeType, NodeTypes } from '../constants/constants';
 import type { Context } from '../evaluator/interface';
@@ -16,7 +16,7 @@ interface GenericLitsFunction {
     [FUNCTION_SYMBOL]: true;
     sourceCodeInfo?: SourceCodeInfo;
     functionType: FunctionType;
-    paramCount: ParamCount;
+    arity: Arity;
 }
 export interface RegularExpression {
     [REGEXP_SYMBOL]: true;
@@ -28,11 +28,13 @@ export interface NativeJsFunction extends GenericLitsFunction {
     functionType: 'NativeJsFunction';
     name: string | undefined;
     nativeFn: JsFunction;
+    docString: string;
 }
 export interface UserDefinedFunction extends GenericLitsFunction {
     functionType: 'UserDefined';
     name: string | undefined;
     evaluatedfunction: EvaluatedFunction;
+    docString: string;
 }
 export interface PartialFunction extends GenericLitsFunction {
     functionType: 'Partial';
@@ -72,6 +74,7 @@ export interface FNullFunction extends GenericLitsFunction {
 export interface NormalBuiltinFunction extends GenericLitsFunction {
     functionType: 'Builtin';
     normalBuitinSymbolType: number;
+    name: string;
 }
 export interface SpecialBuiltinFunction extends GenericLitsFunction {
     functionType: 'SpecialBuiltin';

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

@@ -1,6 +1,6 @@
 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 declare const tokenTypes: readonly ["LBrace", "LBracket", "RBrace", "RBracket", "LParen", "RParen", "BasePrefixedNumber", "DocString", "MultiLineComment", "Number", "Operator", "RegexpShorthand", "ReservedSymbol", "SingleLineComment", "String", "Symbol", "Whitespace"];
 export type TokenType = typeof tokenTypes[number];
 declare const modifierNames: readonly ["&rest", "&let", "&when", "&while"];
 export type ModifierName = typeof modifierNames[number];
@@ -19,9 +19,10 @@ export type RegexpShorthandToken = GenericToken<'RegexpShorthand'>;
 export type ReservedSymbolToken<T extends ReservedSymbol = ReservedSymbol> = GenericToken<'ReservedSymbol', T>;
 export type SingleLineCommentToken = GenericToken<'SingleLineComment'>;
 export type StringToken = GenericToken<'String'>;
+export type DocStringToken = GenericToken<'DocString'>;
 export type SymbolToken<T extends string = string> = GenericToken<'Symbol', T>;
 export type WhitespaceToken = GenericToken<'Whitespace'>;
-export type Token = LBraceToken | LBracketToken | LParenToken | RBraceToken | RBracketToken | RParenToken | BasePrefixedNumberToken | MultiLineCommentToken | NumberToken | OperatorToken | RegexpShorthandToken | ReservedSymbolToken | SingleLineCommentToken | StringToken | SymbolToken | WhitespaceToken;
+export type Token = LBraceToken | LBracketToken | LParenToken | RBraceToken | RBracketToken | RParenToken | BasePrefixedNumberToken | DocStringToken | MultiLineCommentToken | NumberToken | OperatorToken | RegexpShorthandToken | ReservedSymbolToken | SingleLineCommentToken | StringToken | SymbolToken | WhitespaceToken;
 export type TokenDescriptor<T extends Token> = [length: number, token?: T];
 export interface SourceCodeInfo {
     position: {
@@ -76,6 +77,7 @@ export declare function asRBraceToken(token: Token | undefined): RBraceToken;
 export declare function isStringToken(token: Token | undefined): token is StringToken;
 export declare function assertStringToken(token: Token | undefined): asserts token is StringToken;
 export declare function asStringToken(token: Token | undefined): StringToken;
+export declare function isDocStringToken(token: Token | undefined): token is DocStringToken;
 export declare function isRegexpShorthandToken(token: Token | undefined): token is RegexpShorthandToken;
 export declare function assertRegexpShorthandToken(token: Token | undefined): asserts token is RegexpShorthandToken;
 export declare function asRegexpShorthandToken(token: Token | undefined): RegexpShorthandToken;

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

@@ -1,6 +1,7 @@
-import type { BasePrefixedNumberToken, LBraceToken, LBracketToken, LParenToken, MultiLineCommentToken, NumberToken, OperatorToken, RBraceToken, RBracketToken, RParenToken, RegexpShorthandToken, ReservedSymbolToken, SingleLineCommentToken, StringToken, SymbolToken, Token, TokenDescriptor, WhitespaceToken } from './token';
+import type { BasePrefixedNumberToken, DocStringToken, LBraceToken, LBracketToken, LParenToken, MultiLineCommentToken, NumberToken, OperatorToken, RBraceToken, RBracketToken, RParenToken, RegexpShorthandToken, ReservedSymbolToken, SingleLineCommentToken, StringToken, SymbolToken, Token, TokenDescriptor, WhitespaceToken } from './token';
 export type Tokenizer<T extends Token> = (input: string, position: number) => TokenDescriptor<T>;
 export declare const NO_MATCH: TokenDescriptor<never>;
+export declare const tokenizeDocString: Tokenizer<DocStringToken>;
 export declare const tokenizeWhitespace: Tokenizer<WhitespaceToken>;
 export declare const tokenizeNumber: Tokenizer<NumberToken>;
 export declare const tokenizeBasePrefixedNumber: Tokenizer<BasePrefixedNumberToken>;
@@ -9,4 +10,4 @@ export declare const tokenizeReservedSymbolToken: Tokenizer<ReservedSymbolToken>
 export declare const tokenizeOperator: Tokenizer<OperatorToken>;
 export declare const tokenizeMultiLineComment: Tokenizer<MultiLineCommentToken>;
 export declare const tokenizeSingleLineComment: Tokenizer<SingleLineCommentToken>;
-export declare const tokenizers: [Tokenizer<WhitespaceToken>, Tokenizer<MultiLineCommentToken>, Tokenizer<SingleLineCommentToken>, Tokenizer<ReservedSymbolToken>, Tokenizer<LParenToken>, Tokenizer<RParenToken>, Tokenizer<LBracketToken>, Tokenizer<RBracketToken>, Tokenizer<LBraceToken>, Tokenizer<RBraceToken>, Tokenizer<StringToken>, Tokenizer<RegexpShorthandToken>, Tokenizer<BasePrefixedNumberToken>, Tokenizer<NumberToken>, Tokenizer<OperatorToken>, Tokenizer<SymbolToken>];
+export declare const tokenizers: [Tokenizer<WhitespaceToken>, Tokenizer<MultiLineCommentToken>, Tokenizer<SingleLineCommentToken>, Tokenizer<ReservedSymbolToken>, Tokenizer<LParenToken>, Tokenizer<RParenToken>, Tokenizer<LBracketToken>, Tokenizer<RBracketToken>, Tokenizer<LBraceToken>, Tokenizer<RBraceToken>, Tokenizer<DocStringToken>, Tokenizer<StringToken>, Tokenizer<RegexpShorthandToken>, Tokenizer<BasePrefixedNumberToken>, Tokenizer<NumberToken>, Tokenizer<OperatorToken>, Tokenizer<SymbolToken>];

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

@@ -1,12 +1,8 @@
-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: 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: ParamCount): boolean;

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

@@ -0,0 +1,10 @@
+import type { Arity } from '../builtin/interface';
+import type { FunctionLike } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function arityAccepts(arity: Arity, nbrOfParams: number): boolean;
+export declare function arityAcceptsMin(arity: Arity, nbrOfParams: number): boolean;
+export declare function getCommonArityFromFunctions(params: FunctionLike[]): Arity | null;
+export declare function getArityFromFunction(param: FunctionLike): Arity;
+export declare function assertNumberOfParams(arity: Arity, length: number, sourceCodeInfo: SourceCodeInfo | undefined): void;
+export declare function canBeOperator(count: Arity): boolean;
+export declare function toFixedArity(arity: number): Arity;

package/dist/cli/src/utils/docString/generateDocString.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionReference } from '../../../reference';
+export declare function generateDocString(reference: FunctionReference): string;

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

@@ -11,3 +11,4 @@ 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 smartTrim(str: string, minIndent?: number): string;