@mojir/lits 1.1.0 → 1.2.0

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

@@ -8,7 +8,8 @@ export declare enum AstNodeType {
     ReservedName = 207,
     Binding = 208,
     Argument = 209,
-    Partial = 210
+    Partial = 210,
+    Comment = 211
 }
 export declare const astNodeTypeName: Map<AstNodeType, string>;
 export declare function isAstNodeType(type: unknown): type is AstNodeType;
@@ -21,7 +22,9 @@ export declare enum TokenType {
     Modifier = 106,
     RegexpShorthand = 107,
     FnShorthand = 108,
-    CollectionAccessor = 109
+    CollectionAccessor = 109,
+    Comment = 110,
+    NewLine = 111
 }
 export declare const tokenTypeName: Map<TokenType, string>;
 export declare function isTokenType(type: unknown): type is TokenType;

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

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-/// <reference types="node" />
 import type { ReadLine, ReadLineOptions } from 'node:readline';
 type Options = Required<Pick<ReadLineOptions, 'completer' | 'historySize' | 'prompt'>>;
 export declare function createReadlineInterface(options: Options): ReadLine;

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

@@ -14,7 +14,8 @@ export declare class NotAFunctionError extends LitsError {
     constructor(fn: unknown, sourceCodeInfo?: SourceCodeInfo);
 }
 export declare class UserDefinedError extends LitsError {
-    constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);
+    userMessage: string;
+    constructor(message: string, sourceCodeInfo?: SourceCodeInfo);
 }
 export declare class AssertionError extends LitsError {
     constructor(message: string | Error, sourceCodeInfo?: SourceCodeInfo);

package/dist/cli/src/evaluator/ContextStack.d.ts

@@ -1,8 +1,9 @@
 import type { ExtraData, NameNode, NativeJsFunction } from '../parser/interface';
 import type { Any } from '../interface';
-import type { LazyValue } from '../Lits/Lits';
+import type { LazyValue, LitsParams } from '../Lits/Lits';
 import type { Context, LookUpResult } from './interface';
-export declare class ContextStack {
+export type ContextStack = ContextStackImpl;
+export declare class ContextStackImpl {
     private contexts;
     globalContext: Context;
     private values?;
@@ -15,7 +16,9 @@ export declare class ContextStack {
         nativeJsFunctions?: Record<string, NativeJsFunction>;
     });
     create(context: Context, extraData?: ExtraData): ContextStack;
+    clone(): ContextStack;
     getValue(name: string): unknown;
     lookUp(node: NameNode): LookUpResult;
     evaluateName(node: NameNode): Any;
 }
+export declare function createContextStack(params?: LitsParams): ContextStack;

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

@@ -1,14 +1,12 @@
-import type { SpecialExpressionName } from '../builtin/interface';
-import type { Condition } from '../builtin/specialExpressions/cond';
-import type { LoopBindingNode } from '../builtin/specialExpressions/loops';
-import type { Arity, FunctionOverload } from '../builtin/utils';
+import type { JsFunction, LazyValue } from '../Lits/Lits';
+import type { SpecialExpressionName, SpecialExpressionNode } from '../builtin';
+import type { Arity } from '../builtin/utils';
+import type { AstNodeType, FunctionType } from '../constants/constants';
 import type { Context } from '../evaluator/interface';
 import type { Any, Arr } from '../interface';
 import type { ReservedName } from '../reservedNames';
 import type { SourceCodeInfo, Token, TokenStream } from '../tokenizer/interface';
 import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
-import type { AstNodeType, FunctionType } from '../constants/constants';
-import type { JsFunction, LazyValue } from '../Lits/Lits';
 export interface EvaluatedFunctionArguments {
     mandatoryArguments: string[];
     restArgument?: string;
@@ -83,16 +81,22 @@ export interface BuiltinFunction extends GenericLitsFunction {
 export type LitsFunction = NativeJsFunction | UserDefinedFunction | BuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNilFunction;
 export type LitsFunctionType = LitsFunction['t'];
 export type ModifierName = '&' | '&let' | '&when' | '&while';
-interface GenericNode {
+export interface GenericNode {
     t: AstNodeType;
-    tkn?: Token;
+    p: AstNode[];
+    n: string | undefined;
+    debugData: {
+        token: Token;
+        lastToken: Token;
+        nameToken?: Token;
+    } | undefined;
 }
 export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
 export type ParseBinding = (tokens: TokenStream, position: number) => [number, BindingNode];
 export type ParseBindings = (tokens: TokenStream, position: number) => [number, BindingNode[]];
 export type ParseArgument = (tokens: TokenStream, position: number) => [number, ArgumentNode | ModifierNode];
 export type ParseExpression = (tokens: TokenStream, position: number) => [number, ExpressionNode];
-export type ParseTokens = (tokens: TokenStream, position: number) => [number, AstNode[]];
+export type ParseTokensUntilClosingBracket = (tokens: TokenStream, position: number) => [number, AstNode[]];
 export type ParseToken = (tokens: TokenStream, position: number) => [number, AstNode];
 export interface NumberNode extends GenericNode {
     t: AstNodeType.Number;
@@ -114,17 +118,18 @@ export interface ReservedNameNode extends GenericNode {
     t: AstNodeType.ReservedName;
     v: ReservedName;
 }
-interface NormalExpressionNodeBase extends GenericNode {
+interface CommonNormalExpressionNode extends GenericNode {
     t: AstNodeType.NormalExpression;
-    p: AstNode[];
 }
-export interface NormalExpressionNodeWithName extends NormalExpressionNodeBase {
+export interface CommonSpecialExpressionNode<T extends SpecialExpressionName> extends GenericNode {
+    t: AstNodeType.SpecialExpression;
+    n: T;
+}
+export interface NormalExpressionNodeWithName extends CommonNormalExpressionNode {
     n: string;
-    e?: ExpressionNode;
 }
-interface NormalExpressionNodeExpression extends NormalExpressionNodeBase {
-    n?: never;
-    e: ExpressionNode;
+interface NormalExpressionNodeExpression extends CommonNormalExpressionNode {
+    n: undefined;
 }
 export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
 export interface BindingNode extends GenericNode {
@@ -137,24 +142,14 @@ export interface ArgumentNode extends GenericNode {
     n: string;
     d?: AstNode;
 }
-export interface SpecialExpressionNode extends GenericNode {
-    t: AstNodeType.SpecialExpression;
-    n: SpecialExpressionName;
-    p: AstNode[];
-    b?: BindingNode;
-    bs?: BindingNode[];
-    c?: Condition[];
-    f?: AstNode;
-    o?: FunctionOverload[];
-    l?: LoopBindingNode[];
-    m?: AstNode;
-    te?: AstNode;
-    e?: NameNode;
-    ce?: AstNode;
-}
-export type AstNode = NumberNode | StringNode | ReservedNameNode | NameNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode;
+export interface CommentNode extends GenericNode {
+    t: AstNodeType.Comment;
+    v: string;
+}
+export type AstNode = NumberNode | StringNode | ReservedNameNode | NameNode | CommentNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode;
 type AstBody = AstNode[];
 export interface Ast {
     b: AstBody;
+    hasDebugData: boolean;
 }
 export {};

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

@@ -0,0 +1,11 @@
+import type { Ast, AstNode } from '../parser/interface';
+declare const removeOptions: {
+    readonly recursivelyRemoveCommentNodes: typeof recursivelyRemoveCommentNodes;
+    readonly removeCommenNodesFromArray: typeof removeCommenNodesFromArray;
+};
+export type RemoveOptions = typeof removeOptions;
+export declare function removeCommenNodes(ast: Ast): void;
+declare function recursivelyRemoveCommentNodes(astNode: AstNode): void;
+declare function removeCommenNodesFromArray(astNodes: AstNode[]): void;
+export declare function withoutCommentNodes(astNodes: AstNode[]): (import("../parser/interface").NumberNode | import("../parser/interface").StringNode | import("../parser/interface").ReservedNameNode | import("../parser/interface").NameNode | import("../parser/interface").NormalExpressionNode | import("../parser/interface").ModifierNode | import("../builtin/specialExpressions/and").AndNode | import("../builtin/specialExpressions/comment").CommentExpressionNode | import("../builtin/specialExpressions/cond").CondNode | import("../builtin/specialExpressions/def").DefNode | import("../builtin/specialExpressions/functions").DefnNode | import("../builtin/specialExpressions/functions").DefnsNode | import("../builtin/specialExpressions/defs").DefsNode | import("../builtin/specialExpressions/do").DoNode | import("../builtin/specialExpressions/loops").DoSeqNode | import("../builtin/specialExpressions/loops").ForNode | import("../builtin/specialExpressions/functions").FnNode | import("../builtin/specialExpressions/if").IfNode | import("../builtin/specialExpressions/if-let").IfLetNode | import("../builtin/specialExpressions/if-not").IfNotNode | import("../builtin/specialExpressions/let").LetNode | import("../builtin/specialExpressions/loop").LoopNode | import("../builtin/specialExpressions/or").OrNode | import("../builtin/specialExpressions/recur").RecurNode | import("../builtin/specialExpressions/throw").ThrowNode | import("../builtin/specialExpressions/time").TimeNode | import("../builtin/specialExpressions/try").TryNode | import("../builtin/specialExpressions/when").WhenNode | import("../builtin/specialExpressions/when-first").WhenFirstNode | import("../builtin/specialExpressions/when-let").WhenLetNode | import("../builtin/specialExpressions/when-not").WhenNotNode | import("../builtin/specialExpressions/declared").DeclaredNode | import("../builtin/specialExpressions/qq").QqNode)[];
+export {};

package/dist/cli/src/removeCommentNodes/removeCommentNodesFromSpecialExpression.d.ts

@@ -0,0 +1,3 @@
+import type { SpecialExpressionNode } from '../builtin';
+import type { RemoveOptions } from '.';
+export declare function removeCommentNodesFromSpecialExpression(node: SpecialExpressionNode, removeOptions: RemoveOptions): void;

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

@@ -1,2 +1,9 @@
-import type { TokenStream, TokenizeParams } from './interface';
+import { TokenType } from '../constants/constants';
+import type { MetaToken, Token, TokenStream, TokenizeParams } from './interface';
 export declare function tokenize(input: string, params: TokenizeParams): TokenStream;
+export declare function isMetaToken(token?: Token): token is MetaToken;
+export declare function assertMetaToken(token?: Token): asserts token is MetaToken;
+export declare function isCommentToken(token?: Token): token is Token<TokenType.Comment>;
+export declare function assertCommentToken(token?: Token): asserts token is Token<TokenType.Comment>;
+export declare function isNewLineToken(token?: Token): token is Token<TokenType.NewLine>;
+export declare function assertNewLineToken(token?: Token): asserts token is Token<TokenType.NewLine>;

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

@@ -7,19 +7,29 @@ export interface SourceCodeInfo {
     code?: string;
     filePath?: string;
 }
-export interface Token {
-    t: TokenType;
+export type MetaToken = Token<TokenType.NewLine> | Token<TokenType.Comment>;
+export interface MetaTokens {
+    leadingMetaTokens: MetaToken[];
+    inlineCommentToken: Token<TokenType.Comment> | null;
+}
+export interface TokenDebugData {
+    sourceCodeInfo: SourceCodeInfo;
+    metaTokens: MetaTokens;
+}
+export interface Token<T extends TokenType = TokenType> {
+    t: T;
     v: string;
     o?: Record<string, boolean>;
-    sourceCodeInfo?: SourceCodeInfo;
+    debugData: TokenDebugData | undefined;
 }
 export type TokenDescriptor = [length: number, token: Token | undefined];
-export type Tokenizer = (input: string, position: number, sourceCodeInfo?: SourceCodeInfo) => TokenDescriptor;
+export type Tokenizer = (input: string, position: number, debugData?: TokenDebugData) => TokenDescriptor;
 export interface TokenStream {
     tokens: Token[];
+    hasDebugData: boolean;
     filePath?: string;
 }
 export interface TokenizeParams {
-    debug: boolean;
+    debug?: boolean;
     filePath?: string;
 }

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

@@ -1,7 +1,8 @@
 import type { Tokenizer } from './interface';
-export declare const nameCharacters = "[@%0-9a-zA-Z\u00E0\u00E1\u00E2\u00E3\u0103\u00E4\u0101\u00E5\u00E6\u0107\u010D\u00E7\u00E8\u00E9\u00EA\u0115\u00EB\u0113\u00EC\u00ED\u00EE\u012D\u00EF\u00F0\u0142\u00F1\u00F2\u00F3\u00F4\u00F5\u00F6\u0151\u00F8\u0161\u00F9\u00FA\u00FB\u00FC\u0171\u00FD\u00FF\u00FE\u00C0\u00C1\u00C2\u00C3\u0102\u00C4\u0100\u00C5\u00C6\u0106\u010C\u00C7\u00C8\u00C9\u00CA\u0114\u00CB\u0112\u00CC\u00CD\u00CE\u012C\u00CF\u00D0\u0141\u00D1\u00D2\u00D3\u00D4\u00D5\u00D6\u0150\u00D8\u0160\u00D9\u00DA\u00DB\u00DC\u0170\u00DD\u00DE\u00DF_^?=!$%<>+*/-]";
+export declare const nameCharacters = "[\\w@%^?=!$<>+*/-]";
+export declare const tokenizeNewLine: Tokenizer;
+export declare const tokenizeComment: Tokenizer;
 export declare const skipWhiteSpace: Tokenizer;
-export declare const skipComment: Tokenizer;
 export declare const tokenizeLeftParen: Tokenizer;
 export declare const tokenizeRightParen: Tokenizer;
 export declare const tokenizeLeftBracket: Tokenizer;

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

@@ -1,7 +1,12 @@
 import type { UnknownRecord } from '../interface';
-import type { NormalExpressionNode, SpecialExpressionNode } from '../parser/interface';
+import type { GenericNode } from '../parser/interface';
 import type { SourceCodeInfo } from '../tokenizer/interface';
-export declare function assertEventNumberOfParams(node: NormalExpressionNode): void;
+type Count = number | {
+    min?: number;
+    max?: number;
+};
+export declare function assertEvenNumberOfParams(node: GenericNode): void;
+export declare function assertNumberOfParams(count: Count, node: GenericNode): 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;
@@ -9,7 +14,4 @@ export declare function assertUnreachable(_: never): never;
 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 assertNumberOfParams(count: number | {
-    min?: number;
-    max?: number;
-}, node: NormalExpressionNode | SpecialExpressionNode): void;
+export {};

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

@@ -1,4 +1,4 @@
-import { type TokenType } from '../constants/constants';
+import { TokenType } from '../constants/constants';
 import type { Token } from '../tokenizer/interface';
 type TokenAssertionOptions = {
     type: TokenType;

package/dist/cli/src/unparser/UnparseOptions.d.ts

@@ -0,0 +1,15 @@
+import type { Unparse } from './unparse';
+export declare class UnparseOptions {
+    readonly unparse: Unparse;
+    readonly lineLength: number;
+    readonly col: number;
+    readonly inlined: boolean;
+    readonly locked: boolean;
+    readonly indent: string;
+    constructor(unparse: Unparse, lineLength: number, col?: number, inlined?: boolean, locked?: boolean);
+    inc(count?: number): UnparseOptions;
+    inline(): UnparseOptions;
+    noInline(): UnparseOptions;
+    lock(): UnparseOptions;
+    assertNotOverflown(value: string): string;
+}

package/dist/cli/src/unparser/unparse.d.ts

@@ -0,0 +1,5 @@
+import type { Ast, AstNode, NormalExpressionNode } from '../parser/interface';
+import { UnparseOptions } from './UnparseOptions';
+export type ExpressionWithParamsNode = Pick<NormalExpressionNode, 'debugData' | 'n' | 'p'>;
+export type Unparse = (node: AstNode, options: UnparseOptions) => string;
+export declare function unparseAst(ast: Ast, lineLength: number): string;

package/dist/cli/src/unparser/unparseArrayLiteral.d.ts

@@ -0,0 +1,3 @@
+import type { NormalExpressionNode } from '../parser/interface';
+import type { UnparseOptions } from './UnparseOptions';
+export declare function unparseArrayLiteral(node: NormalExpressionNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseBindings.d.ts

@@ -0,0 +1,3 @@
+import type { NormalExpressionNode } from '../parser/interface';
+import type { UnparseOptions } from './UnparseOptions';
+export declare function unparseBindings(node: NormalExpressionNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseNormalExpression.d.ts

@@ -0,0 +1,3 @@
+import type { UnparseOptions } from './UnparseOptions';
+import type { ExpressionWithParamsNode } from './unparse';
+export declare function unparseNormalExpression(node: ExpressionWithParamsNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseObjectLiteral.d.ts

@@ -0,0 +1,3 @@
+import type { NormalExpressionNode } from '../parser/interface';
+import type { UnparseOptions } from './UnparseOptions';
+export declare function unparseObjectLiteral(node: NormalExpressionNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseParams.d.ts

@@ -0,0 +1,17 @@
+import type { AstNode } from '../parser/interface';
+import type { UnparseOptions } from './UnparseOptions';
+export declare function unparseParams({ params, options, prefix, inline, endBracket, body, name, noMultilineInline, pairs, }: {
+    params: AstNode[];
+    prefix: string;
+    inline: boolean;
+    endBracket: string;
+    options: UnparseOptions;
+    body?: boolean;
+    name?: string;
+    noMultilineInline?: boolean;
+    pairs?: boolean;
+}): string;
+export declare function unparseSingleLineParams(params: AstNode[], options: UnparseOptions): string;
+export declare function unparseSingleLinePairs(params: AstNode[], options: UnparseOptions): string;
+export declare function unparseMultilineParams(params: AstNode[], options: UnparseOptions): string;
+export declare function unparseMultilinePairwise(params: AstNode[], options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/index.d.ts

@@ -0,0 +1,3 @@
+import type { SpecialExpressionNode } from '../../builtin';
+import type { UnparseOptions } from '../UnparseOptions';
+export declare function unparseSpecialExpression(node: SpecialExpressionNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseCond.d.ts

@@ -0,0 +1,3 @@
+import type { CondNode } from '../../builtin/specialExpressions/cond';
+import type { UnparseOptions } from '../UnparseOptions';
+export declare function unparseCond(node: CondNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseDo.d.ts

@@ -0,0 +1,3 @@
+import type { DoNode } from '../../builtin/specialExpressions/do';
+import type { UnparseOptions } from '../UnparseOptions';
+export declare function unparseDo(node: DoNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseIfLet.d.ts

@@ -0,0 +1,3 @@
+import type { IfLetNode } from '../../builtin/specialExpressions/if-let';
+import type { UnparseOptions } from '../UnparseOptions';
+export declare function unparseIfLet(node: IfLetNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseIfOrWhenLike.d.ts

@@ -0,0 +1,6 @@
+import type { IfNode } from '../../builtin/specialExpressions/if';
+import type { IfNotNode } from '../../builtin/specialExpressions/if-not';
+import type { WhenNode } from '../../builtin/specialExpressions/when';
+import type { WhenNotNode } from '../../builtin/specialExpressions/when-not';
+import type { UnparseOptions } from '../UnparseOptions';
+export declare function unparseIfOrWhenLike(node: WhenNode | WhenNotNode | IfNode | IfNotNode, options: UnparseOptions): string;

package/dist/cli/src/unparser/unparseSpecialExpression/unparseLet.d.ts

@@ -0,0 +1,3 @@
+import type { LetNode } from '../../builtin/specialExpressions/let';
+import type { UnparseOptions } from '../UnparseOptions';
+export declare function unparseLet(node: LetNode, options: UnparseOptions): string;

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

@@ -0,0 +1,5 @@
+import type { MetaTokens } from '../tokenizer/interface';
+import type { UnparseOptions } from './UnparseOptions';
+export declare function ensureNewlineSeparator(a: string, b: string): string;
+export declare function ensureSpaceSeparator(a: string, b: string): string;
+export declare function applyMetaTokens(value: string | number, metaTokens: MetaTokens | undefined, options: UnparseOptions): string;

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

@@ -8,3 +8,4 @@ export declare function toNonNegativeInteger(num: number): number;
 export declare function toAny(value: unknown): Any;
 export declare function cloneColl<T extends Coll>(value: T): T;
 export declare function createNativeJsFunction(fn: (...args: any[]) => unknown, name?: string): NativeJsFunction;
+export declare function arrayToPairs<T>(arr: T[]): T[][];

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

@@ -1,2 +1,2 @@
-export declare const FUNCTION_SYMBOL = "__fn";
-export declare const REGEXP_SYMBOL = "__re";
+export declare const FUNCTION_SYMBOL = "^^fn^^";
+export declare const REGEXP_SYMBOL = "^^re^^";

package/dist/common/utils.d.ts

@@ -1,3 +1,2 @@
-export declare function throttle<T extends (...args: any[]) => void>(func: T): (this: any, ...args: Parameters<T>) => void;
 export declare function stringifyValue(value: unknown, html: boolean): string;
 export declare function findAllOccurrences(input: string, pattern: RegExp): Set<string>;