@mojir/lits 2.0.23 → 2.1.1

package/dist/cli/src/tokenizer/polish/polishTokens.d.ts

@@ -1,55 +0,0 @@
-import type { CommonSimpleToken, CommonSimpleTokenType, CommonValueToken, CommonValueTokenType } from '../common/commonTokens';
-import type { Token } from '../tokens';
-import { type TokenDebugData } from '../utils';
-export declare const modifierNames: readonly ["&rest", "&let", "&when", "&while"];
-export type ModifierName = typeof modifierNames[number];
-export declare const polishOnlySimpleTokenTypes: ["P_FnShorthand"];
-export declare const polishSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "P_FnShorthand"];
-export declare const polishOnlyValueTokenTypes: ["P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export declare const polishValueTokenTypes: readonly ["String", "RegexpShorthand", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export declare const polishTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "P_FnShorthand", "String", "RegexpShorthand", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export type PolishSimpleTokenType = typeof polishSimpleTokenTypes[number];
-export type PolishValueTokenType = typeof polishValueTokenTypes[number];
-export type PolishTokenType = typeof polishTokenTypes[number];
-type GenericPolishSimpleToken<T extends Exclude<PolishSimpleTokenType, CommonSimpleTokenType>> = [T] | [T, TokenDebugData];
-type GenericPolishValueToken<T extends Exclude<PolishValueTokenType, CommonValueTokenType>, V extends string = string> = [T, V] | [T, V, TokenDebugData];
-export type P_FnShorthandToken = GenericPolishSimpleToken<'P_FnShorthand'>;
-export type P_ModifierToken = GenericPolishValueToken<'P_Modifier', ModifierName>;
-export type P_StringShorthandToken = GenericPolishValueToken<'P_StringShorthand'>;
-export type P_SymbolToken = GenericPolishValueToken<'P_Symbol'>;
-export type P_ReservedSymbolToken = GenericPolishValueToken<'P_ReservedSymbol'>;
-export type P_CollectionAccessorToken = GenericPolishValueToken<'P_CollectionAccessor', '.' | '#'>;
-export type P_CommentToken = GenericPolishValueToken<'P_Comment'>;
-export type P_WhitespaceToken = GenericPolishValueToken<'P_Whitespace'>;
-export type P_NumberToken = GenericPolishValueToken<'P_Number'>;
-export type PolishOnlySimpleToken = P_FnShorthandToken;
-export type PolishOnlyValueToken = P_ModifierToken | P_StringShorthandToken | P_SymbolToken | P_ReservedSymbolToken | P_CollectionAccessorToken | P_CommentToken | P_WhitespaceToken | P_NumberToken;
-export type PolishToken = PolishOnlySimpleToken | PolishOnlyValueToken | CommonSimpleToken | CommonValueToken;
-export declare function isP_StringShorthandToken(token?: Token): token is P_StringShorthandToken;
-export declare function assertP_StringShorthandToken(token?: Token): asserts token is P_StringShorthandToken;
-export declare function asP_StringShorthandToken(token?: Token): P_StringShorthandToken;
-export declare function isP_SymbolToken(token?: Token): token is P_SymbolToken;
-export declare function assertP_SymbolToken(token?: Token): asserts token is P_SymbolToken;
-export declare function asP_SymbolToken(token?: Token): P_SymbolToken;
-export declare function isP_ReservedSymbolToken(token?: Token): token is P_ReservedSymbolToken;
-export declare function assertP_ReservedSymbolToken(token?: Token): asserts token is P_ReservedSymbolToken;
-export declare function asP_ReservedSymbolToken(token?: Token): P_ReservedSymbolToken;
-export declare function isP_ModifierToken(token?: Token): token is P_ModifierToken;
-export declare function assertP_ModifierToken(token?: Token): asserts token is P_ModifierToken;
-export declare function asP_ModifierToken(token?: Token): P_ModifierToken;
-export declare function isP_FnShorthandToken(token?: Token): token is P_FnShorthandToken;
-export declare function assertP_FnShorthandToken(token?: Token): asserts token is P_FnShorthandToken;
-export declare function asP_FnShorthandToken(token?: Token): P_FnShorthandToken;
-export declare function isP_CollectionAccessorToken(token?: Token): token is P_CollectionAccessorToken;
-export declare function assertP_CollectionAccessorToken(token?: Token): asserts token is P_CollectionAccessorToken;
-export declare function asP_CollectionAccessorToken(token?: Token): P_CollectionAccessorToken;
-export declare function isP_CommentToken(token?: Token): token is P_CommentToken;
-export declare function assertP_CommentToken(token?: Token): asserts token is P_CommentToken;
-export declare function asP_CommentToken(token?: Token): P_CommentToken;
-export declare function isP_WhitespaceToken(token?: Token): token is P_WhitespaceToken;
-export declare function assertP_WhitespaceToken(token?: Token): asserts token is P_WhitespaceToken;
-export declare function asP_WhitespaceToken(token?: Token): P_WhitespaceToken;
-export declare function isP_NumberToken(token?: Token): token is P_NumberToken;
-export declare function assertP_NumberToken(token?: Token): asserts token is P_NumberToken;
-export declare function asP_NumberToken(token?: Token): P_NumberToken;
-export {};

package/dist/cli/src/tokenizer/sugar/applyCollectionAccessor.d.ts

@@ -1,2 +0,0 @@
-import type { SugarFunction } from '.';
-export declare const applyCollectionAccessors: SugarFunction;

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

@@ -1,3 +0,0 @@
-import type { TokenStream } from '../interface';
-export type SugarFunction = (tokenStream: TokenStream) => TokenStream;
-export declare function getSugar(): SugarFunction[];

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

@@ -1,20 +0,0 @@
-import type { CommonSimpleToken, CommonValueToken } from './common/commonTokens';
-import type { AlgebraicOnlyValueToken } from './algebraic/algebraicTokens';
-import type { PolishOnlySimpleToken, PolishOnlyValueToken } from './polish/polishTokens';
-export declare const simpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "P_FnShorthand"];
-export declare const valueTokenTypes: readonly ["String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export declare const tokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "P_FnShorthand", "String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export type TokenType = typeof tokenTypes[number];
-export type SimpleToken = CommonSimpleToken | PolishOnlySimpleToken;
-export type ValueToken = CommonValueToken | AlgebraicOnlyValueToken | PolishOnlyValueToken;
-export type Token = SimpleToken | ValueToken;
-export declare function isTokenType(type: string): type is TokenType;
-export declare function isToken(token?: Token): token is Token;
-export declare function assertToken(token?: Token): asserts token is Token;
-export declare function asToken(token?: Token): Token;
-export declare function isSimpleToken(token?: Token): token is SimpleToken;
-export declare function assertSimpleToken(token?: Token): asserts token is SimpleToken;
-export declare function asSimpleToken(token?: Token): SimpleToken;
-export declare function isValueToken(token?: Token): token is ValueToken;
-export declare function assertValueToken(token?: Token): asserts token is ValueToken;
-export declare function asValueToken(token?: Token): ValueToken;

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

@@ -1,9 +0,0 @@
-import type { SourceCodeInfo } from './interface';
-import type { Token, TokenType } from './tokens';
-export type TokenDebugData = {
-    sourceCodeInfo: SourceCodeInfo;
-};
-export declare function getTokenDebugData(token?: Token): TokenDebugData | undefined;
-export declare function hasTokenDebugData(token?: Token): boolean;
-export declare function addTokenDebugData(token: Token, debugData: TokenDebugData): void;
-export declare function throwUnexpectedToken(expected: TokenType, expectedValue: string | undefined, actual?: Token): never;

package/dist/common/clojureDocs.d.ts

@@ -1 +0,0 @@
-export declare function getClojureDocsLink(functionName: string, clojureDocs?: string | null): string | null;

package/dist/src/analyze/findUnresolvedIdentifiers.d.ts

@@ -1,2 +0,0 @@
-import type { FindUnresolvedIdentifiers } from '.';
-export declare const findUnresolvedIdentifiers: FindUnresolvedIdentifiers;

package/dist/src/analyze/index.d.ts

@@ -1,15 +0,0 @@
-import type { LitsParams } from '../Lits/Lits';
-import type { Builtin } from '../builtin/interface';
-import { type ContextStack } from '../evaluator/ContextStack';
-import type { Ast, AstNode } from '../parser/interface';
-import type { Token } from '../tokenizer/tokens';
-export interface UnresolvedIdentifier {
-    symbol: string;
-    token: Token | undefined;
-}
-export type UnresolvedIdentifiers = Set<UnresolvedIdentifier>;
-export interface Analysis {
-    unresolvedIdentifiers: UnresolvedIdentifiers;
-}
-export type FindUnresolvedIdentifiers = (ast: Ast | AstNode[], contextStack: ContextStack, builtin: Builtin) => UnresolvedIdentifiers;
-export declare function analyze(ast: Ast, params: LitsParams): Analysis;

package/dist/src/analyze/utils.d.ts

@@ -1,4 +0,0 @@
-import type { UnresolvedIdentifiers } from '.';
-export declare function joinAnalyzeResults(...results: UnresolvedIdentifiers[]): UnresolvedIdentifiers;
-export declare function addAnalyzeResults(target: UnresolvedIdentifiers, source: UnresolvedIdentifiers): void;
-export declare function combinate<T>(arrays: T[][]): T[][];

package/dist/src/builtin/specialExpressions/comment.d.ts

@@ -1,5 +0,0 @@
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
-import type { BuiltinSpecialExpression } from '../interface';
-export interface CommentExpressionNode extends CommonSpecialExpressionNode<'comment'> {
-}
-export declare const commentSpecialExpression: BuiltinSpecialExpression<null, CommentExpressionNode>;

package/dist/src/builtin/specialExpressions/commonParser.d.ts

@@ -1,4 +0,0 @@
-import type { CommonSpecialExpressionName, GenericCommonSpecialExpressionNode } from '..';
-import type { Any } from '../../interface';
-import type { BuiltinSpecialExpression } from '../interface';
-export declare function getCommonPolishSpecialExpressionParser<T extends CommonSpecialExpressionName>(name: T): BuiltinSpecialExpression<Any, GenericCommonSpecialExpressionNode<T>>['polishParse'];

package/dist/src/builtin/specialExpressions/declared.d.ts

@@ -1,5 +0,0 @@
-import type { CommonSpecialExpressionNode } from '../../parser/interface';
-import type { BuiltinSpecialExpression } from '../interface';
-export interface DeclaredNode extends CommonSpecialExpressionNode<'defined?'> {
-}
-export declare const declaredSpecialExpression: BuiltinSpecialExpression<boolean, DeclaredNode>;

package/dist/src/identifier.d.ts

@@ -1,4 +0,0 @@
-export declare const polishIdentifierCharacterClass = "[\\w@%^?=!$<>+*/:&|~-]";
-export declare const polishIdentifierFirstCharacterClass = "[a-zA-Z_@%^?=!$<>+*/&|~-]";
-export declare const algebraicIdentifierCharacterClass = "[\\w$:!?]";
-export declare const algebraicIdentifierFirstCharacterClass = "[a-zA-Z_$]";

package/dist/src/parser/AlgebraicParser.d.ts

@@ -1,44 +0,0 @@
-import type { CondNode } from '../builtin/specialExpressions/cond';
-import type { IfNode } from '../builtin/specialExpressions/if';
-import type { LetNode } from '../builtin/specialExpressions/let';
-import type { SwitchNode } from '../builtin/specialExpressions/switch';
-import type { UnlessNode } from '../builtin/specialExpressions/unless';
-import type { Arity, FunctionArguments } from '../builtin/utils';
-import type { A_ReservedSymbolToken, A_SymbolToken } from '../tokenizer/algebraic/algebraicTokens';
-import type { TokenStream } from '../tokenizer/interface';
-import type { AstNode, ParseState } from './interface';
-export declare class AlgebraicParser {
-    private readonly tokenStream;
-    private parseState;
-    constructor(tokenStream: TokenStream, parseState: ParseState);
-    private peek;
-    private peekAhead;
-    private advance;
-    parse(): AstNode[];
-    private parseExpression;
-    private parseOperand;
-    private parseOperandPart;
-    private parseObject;
-    private parseArray;
-    private parseFunctionCall;
-    parseLambdaFunction(): AstNode | null;
-    parseFunctionArguments(): {
-        functionArguments: FunctionArguments;
-        arity: Arity;
-    };
-    private parseShorthandLamdaFunction;
-    private parseLet;
-    private parseDo;
-    private parseLoop;
-    private parseTry;
-    private parseForOrDoseq;
-    private parseForLoopBinding;
-    private parseBinding;
-    parseIfOrUnless(token: A_SymbolToken): IfNode | UnlessNode;
-    parseCond(token: A_SymbolToken): CondNode;
-    parseSwitch(token: A_SymbolToken): SwitchNode;
-    parseFunction(token: A_ReservedSymbolToken<'function'>): LetNode;
-    private isAtEnd;
-    private isAtExpressionEnd;
-    private parseExport;
-}

package/dist/src/parser/PolishTokenParsers.d.ts

@@ -1,3 +0,0 @@
-import type { TokenStream } from '../tokenizer/interface';
-import type { AstNode, ParseState } from './interface';
-export declare function parsePolishToken(tokenStream: TokenStream, parseState: ParseState): AstNode;

package/dist/src/parser/commonTokenParsers.d.ts

@@ -1,7 +0,0 @@
-import type { TokenStream } from '../tokenizer/interface';
-import type { NormalExpressionNodeWithName, NumberNode, ParseState, ReservedSymbolNode, StringNode, SymbolNode } from './interface';
-export declare function parseSymbol(tokenStream: TokenStream, parseState: ParseState): SymbolNode;
-export declare function parseReservedSymbol(tokenStream: TokenStream, parseState: ParseState): ReservedSymbolNode;
-export declare function parseNumber(tokenStream: TokenStream, parseState: ParseState): NumberNode;
-export declare function parseString(tokenStream: TokenStream, parseState: ParseState): StringNode;
-export declare function parseRegexpShorthand(tokenStream: TokenStream, parseState: ParseState): NormalExpressionNodeWithName;

package/dist/src/parser/index.d.ts

@@ -1,3 +0,0 @@
-import type { TokenStream } from '../tokenizer/interface';
-import type { Ast } from './interface';
-export declare function parse(tokenStream: TokenStream): Ast;

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

@@ -1,160 +0,0 @@
-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 { PolishReservedName } from '../tokenizer/polish/polishReservedNames';
-import type { SourceCodeInfo, TokenStream } from '../tokenizer/interface';
-import type { FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
-import type { Token } from '../tokenizer/tokens';
-import type { ModifierName } from '../tokenizer/polish/polishTokens';
-export interface ParseState {
-    position: number;
-    parseToken: ParseToken;
-}
-export interface EvaluatedFunctionArguments {
-    mandatoryArguments: string[];
-    restArgument?: string;
-}
-export interface EvaluatedFunctionOverload {
-    as: EvaluatedFunctionArguments;
-    b: AstNode[];
-    a: Arity;
-    f: Context;
-}
-export type ExtraData = Record<string, LazyValue>;
-interface GenericLitsFunction {
-    [FUNCTION_SYMBOL]: true;
-    sourceCodeInfo?: SourceCodeInfo;
-    t: FunctionType;
-}
-export interface RegularExpression {
-    [REGEXP_SYMBOL]: true;
-    sourceCodeInfo?: SourceCodeInfo;
-    s: string;
-    f: string;
-}
-export interface NativeJsFunction extends GenericLitsFunction {
-    t: FunctionType.NativeJsFunction;
-    n: string | undefined;
-    f: JsFunction;
-}
-export interface UserDefinedFunction extends GenericLitsFunction {
-    t: FunctionType.UserDefined;
-    n: string | undefined;
-    o: EvaluatedFunctionOverload[];
-    x?: ExtraData;
-}
-export interface PartialFunction extends GenericLitsFunction {
-    t: FunctionType.Partial;
-    f: Any;
-    p: Arr;
-}
-export interface CompFunction extends GenericLitsFunction {
-    t: FunctionType.Comp;
-    f: Arr;
-}
-export interface ConstantlyFunction extends GenericLitsFunction {
-    t: FunctionType.Constantly;
-    v: Any;
-}
-export interface JuxtFunction extends GenericLitsFunction {
-    t: FunctionType.Juxt;
-    f: Arr;
-}
-export interface ComplementFunction extends GenericLitsFunction {
-    t: FunctionType.Complement;
-    f: Any;
-}
-export interface EveryPredFunction extends GenericLitsFunction {
-    t: FunctionType.EveryPred;
-    f: Arr;
-}
-export interface SomePredFunction extends GenericLitsFunction {
-    t: FunctionType.SomePred;
-    f: Arr;
-}
-export interface FNilFunction extends GenericLitsFunction {
-    t: FunctionType.Fnil;
-    f: Any;
-    p: Arr;
-}
-export interface BuiltinFunction extends GenericLitsFunction {
-    t: FunctionType.Builtin;
-    n: string;
-}
-export type LitsFunction = NativeJsFunction | UserDefinedFunction | BuiltinFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNilFunction;
-export type LitsFunctionType = LitsFunction['t'];
-export type DebugData = {
-    token: Token;
-    nameToken?: Token;
-};
-export interface GenericNode {
-    t: AstNodeType;
-    p: AstNode[];
-    n: string | undefined;
-    token: Token | undefined;
-}
-export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
-export type ParseBinding = (tokens: TokenStream, parseState: ParseState) => BindingNode;
-export type ParseBindings = (tokens: TokenStream, parseState: ParseState) => BindingNode[];
-export type ParseArgument = (tokens: TokenStream, parseState: ParseState) => ArgumentNode | ModifierNode;
-export type ParseExpression = (tokens: TokenStream, parseState: ParseState) => ExpressionNode;
-export type ParseTokensUntilClosingBracket = (tokens: TokenStream, parseState: ParseState) => AstNode[];
-export type ParseToken = (tokens: TokenStream, parseState: ParseState) => AstNode;
-export interface NumberNode extends GenericNode {
-    t: AstNodeType.Number;
-    v: number;
-}
-export interface StringNode extends GenericNode {
-    t: AstNodeType.String;
-    v: string;
-}
-export interface SymbolNode extends GenericNode {
-    t: AstNodeType.Symbol;
-    v: string;
-}
-export interface ModifierNode extends GenericNode {
-    t: AstNodeType.Modifier;
-    v: ModifierName;
-}
-export interface ReservedSymbolNode extends GenericNode {
-    t: AstNodeType.ReservedSymbol;
-    v: PolishReservedName;
-}
-interface CommonNormalExpressionNode extends GenericNode {
-    t: AstNodeType.NormalExpression;
-}
-export interface CommonSpecialExpressionNode<T extends SpecialExpressionName> extends GenericNode {
-    t: AstNodeType.SpecialExpression;
-    n: T;
-}
-export interface NormalExpressionNodeWithName extends CommonNormalExpressionNode {
-    n: string;
-}
-interface NormalExpressionNodeExpression extends CommonNormalExpressionNode {
-    n: undefined;
-}
-export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
-export interface BindingNode extends GenericNode {
-    t: AstNodeType.Binding;
-    n: string;
-    v: AstNode;
-}
-export interface ArgumentNode extends GenericNode {
-    t: AstNodeType.Argument;
-    n: string;
-    d?: AstNode;
-}
-export interface CommentNode extends GenericNode {
-    t: AstNodeType.Comment;
-    v: string;
-}
-export type AstNode = NumberNode | StringNode | ReservedSymbolNode | SymbolNode | CommentNode | NormalExpressionNode | ModifierNode | SpecialExpressionNode;
-type AstBody = AstNode[];
-export interface Ast {
-    b: AstBody;
-    hasDebugData: boolean;
-}
-export {};

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

@@ -1,11 +0,0 @@
-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").ReservedSymbolNode | import("../parser/interface").SymbolNode | import("../parser/interface").NormalExpressionNode | import("../parser/interface").ModifierNode | import("../builtin").SpecialExpressionNode)[];
-export {};

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

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

package/dist/src/tokenizer/algebraic/algebraicReservedNames.d.ts

@@ -1,107 +0,0 @@
-declare const validAlgebraicReservedNamesRecord: {
-    readonly true: {
-        readonly value: true;
-        readonly forbidden: false;
-    };
-    readonly false: {
-        readonly value: false;
-        readonly forbidden: false;
-    };
-    readonly nil: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly null: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly then: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly else: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly end: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly case: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly when: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly while: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly function: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly export: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-};
-export declare const algebraicReservedNamesRecord: {
-    readonly fn: {
-        readonly value: null;
-        readonly forbidden: true;
-    };
-    readonly true: {
-        readonly value: true;
-        readonly forbidden: false;
-    };
-    readonly false: {
-        readonly value: false;
-        readonly forbidden: false;
-    };
-    readonly nil: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly null: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly then: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly else: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly end: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly case: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly when: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly while: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly function: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-    readonly export: {
-        readonly value: null;
-        readonly forbidden: false;
-    };
-};
-export type ValidAlgebraicReservedName = keyof typeof validAlgebraicReservedNamesRecord;
-export type AlgebraicReservedName = keyof typeof algebraicReservedNamesRecord;
-export {};

package/dist/src/tokenizer/algebraic/algebraicTokenizers.d.ts

@@ -1,11 +0,0 @@
-import type { Tokenizer } from '../interface';
-import type { A_BasePrefixedNumberToken, A_MultiLineCommentToken, A_NumberToken, A_OperatorToken, A_ReservedSymbolToken, A_SingleLineCommentToken, A_SymbolToken, A_WhitespaceToken } from './algebraicTokens';
-export declare const tokenizeA_Whitespace: Tokenizer<A_WhitespaceToken>;
-export declare const tokenizeA_Number: Tokenizer<A_NumberToken>;
-export declare const tokenizeA_BasePrefixedNumber: Tokenizer<A_BasePrefixedNumberToken>;
-export declare const tokenizeA_Symbol: Tokenizer<A_SymbolToken>;
-export declare const tokenizeA_ReservedSymbolToken: Tokenizer<A_ReservedSymbolToken>;
-export declare const tokenizeA_Operator: Tokenizer<A_OperatorToken>;
-export declare const tokenizeA_MultiLineComment: Tokenizer<A_MultiLineCommentToken>;
-export declare const tokenizeA_SingleLineComment: Tokenizer<A_SingleLineCommentToken>;
-export declare const algebraicTokenizers: [Tokenizer<A_WhitespaceToken>, Tokenizer<A_MultiLineCommentToken>, Tokenizer<A_SingleLineCommentToken>, Tokenizer<import("../common/commonTokens").LParenToken>, Tokenizer<import("../common/commonTokens").RParenToken>, Tokenizer<import("../common/commonTokens").LBracketToken>, Tokenizer<import("../common/commonTokens").RBracketToken>, Tokenizer<import("../common/commonTokens").LBraceToken>, Tokenizer<import("../common/commonTokens").RBraceToken>, Tokenizer<import("../common/commonTokens").StringToken>, Tokenizer<import("../common/commonTokens").RegexpShorthandToken>, Tokenizer<A_BasePrefixedNumberToken>, Tokenizer<A_NumberToken>, Tokenizer<A_OperatorToken>, Tokenizer<A_ReservedSymbolToken>, Tokenizer<A_SymbolToken>];

package/dist/src/tokenizer/algebraic/algebraicTokens.d.ts

@@ -1,66 +0,0 @@
-import type { CommonSimpleToken, CommonValueToken, CommonValueTokenType } from '../common/commonTokens';
-import type { Token } from '../tokens';
-import { type TokenDebugData } from '../utils';
-import type { ValidAlgebraicReservedName } from './algebraicReservedNames';
-export declare const algebraicSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen"];
-export declare const algebraicOnlyValueTokenTypes: ["A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
-export declare const algebraicValueTokenTypes: readonly ["String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
-export declare const algebraicTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
-declare const symbolicUnaryOperators: readonly ["!", "~", "+", "-"];
-declare const symbolicBinaryOperators: readonly ["**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??"];
-declare const symbolicOperators: readonly ["!", "~", "+", "-", "**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??", "=>", "...", ".", ",", "=", ";"];
-export declare function isFunctionOperator(operator: string): boolean;
-export type SymbolicUnaryOperator = typeof symbolicUnaryOperators[number];
-export type SymbolicBinaryOperator = typeof symbolicBinaryOperators[number];
-export type SymbolicOperator = typeof symbolicOperators[number];
-export declare function isSymbolicUnaryOperator(operator: string): operator is SymbolicUnaryOperator;
-export declare function assertSymbolicUnaryOperator(operator: string): asserts operator is SymbolicUnaryOperator;
-export declare function asSymbolicUnaryOperator(operator: string): SymbolicUnaryOperator;
-export declare function isSymbolicBinaryOperator(operator: string): operator is SymbolicBinaryOperator;
-export declare function assertSymbolicBinaryOperator(operator: string): asserts operator is SymbolicBinaryOperator;
-export declare function asSymbolicBinaryOperator(operator: string): SymbolicBinaryOperator;
-export declare function isSymbolicOperator(operator: string): operator is SymbolicOperator;
-export declare function assertSymbolicOperator(operator: string): asserts operator is SymbolicOperator;
-export declare function asSymbolicOperator(operator: string): SymbolicOperator;
-export type AlgebraicSimpleTokenType = typeof algebraicSimpleTokenTypes[number];
-export type AlgebraicValueTokenType = typeof algebraicValueTokenTypes[number];
-export type AlgebraicTokenType = typeof algebraicTokenTypes[number];
-type GenericAlgebraicValueToken<T extends Exclude<AlgebraicValueTokenType, CommonValueTokenType>, V extends string = string> = [T, V] | [T, V, TokenDebugData];
-export type A_WhitespaceToken = GenericAlgebraicValueToken<'A_Whitespace'>;
-export type A_NumberToken = GenericAlgebraicValueToken<'A_Number'>;
-export type A_BasePrefixedNumberToken = GenericAlgebraicValueToken<'A_BasePrefixedNumber'>;
-export type A_OperatorToken<T extends SymbolicOperator = SymbolicOperator> = GenericAlgebraicValueToken<'A_Operator', T>;
-export type A_SymbolToken<T extends string = string> = GenericAlgebraicValueToken<'A_Symbol', T>;
-export type A_ReservedSymbolToken<T extends ValidAlgebraicReservedName = ValidAlgebraicReservedName> = GenericAlgebraicValueToken<'A_ReservedSymbol', T>;
-export type A_SingleLineCommentToken = GenericAlgebraicValueToken<'A_SingleLineComment'>;
-export type A_MultiLineCommentToken = GenericAlgebraicValueToken<'A_MultiLineComment'>;
-export type AlgebraicOnlyValueToken = A_WhitespaceToken | A_NumberToken | A_BasePrefixedNumberToken | A_OperatorToken | A_SymbolToken | A_ReservedSymbolToken | A_SingleLineCommentToken | A_MultiLineCommentToken;
-export type AlgebraicToken = AlgebraicOnlyValueToken | CommonSimpleToken | CommonValueToken;
-export declare function isA_SymbolToken<T extends string>(token: Token | undefined, symbolName?: T): token is A_SymbolToken<T>;
-export declare function assertA_SymbolToken<T extends string>(token: Token | undefined, symbolName?: T): asserts token is A_SymbolToken<T>;
-export declare function asA_SymbolToken<T extends string>(token: Token | undefined, symbolName?: T): A_SymbolToken<T>;
-export declare function isA_BinaryOperatorToken(token: Token | undefined): token is A_OperatorToken<SymbolicBinaryOperator>;
-export declare function assertA_BinaryOperatorToken(token: Token | undefined): asserts token is A_OperatorToken<SymbolicBinaryOperator>;
-export declare function asA_BinaryOperatorToken(token: Token | undefined): A_OperatorToken<SymbolicBinaryOperator>;
-export declare function isA_ReservedSymbolToken<T extends ValidAlgebraicReservedName>(token: Token | undefined, symbolName?: T): token is A_ReservedSymbolToken<T>;
-export declare function assertA_ReservedSymbolToken<T extends ValidAlgebraicReservedName>(token: Token | undefined, symbolName?: T): asserts token is A_ReservedSymbolToken<T>;
-export declare function asA_ReservedSymbolToken<T extends ValidAlgebraicReservedName>(token: Token | undefined, symbolName?: T): A_ReservedSymbolToken<T>;
-export declare function isA_CommentToken(token: Token | undefined): token is A_SingleLineCommentToken;
-export declare function assertA_CommentToken(token: Token | undefined): asserts token is A_SingleLineCommentToken;
-export declare function asA_CommentToken(token: Token | undefined): A_SingleLineCommentToken;
-export declare function isA_MultiLineCommentToken(token: Token | undefined): token is A_MultiLineCommentToken;
-export declare function assertA_MultiLineCommentToken(token: Token | undefined): asserts token is A_MultiLineCommentToken;
-export declare function asA_MultiLineCommentToken(token: Token | undefined): A_MultiLineCommentToken;
-export declare function isA_OperatorToken<T extends SymbolicOperator>(token: Token | undefined, operatorName?: T): token is A_OperatorToken<T>;
-export declare function assertA_OperatorToken<T extends SymbolicOperator>(token: Token | undefined, operatorName?: T): asserts token is A_OperatorToken<T>;
-export declare function asA_OperatorToken<T extends SymbolicOperator>(token: Token | undefined, operatorName?: T): A_OperatorToken<T>;
-export declare function isA_WhitespaceToken(token: Token | undefined): token is A_WhitespaceToken;
-export declare function assertA_WhitespaceToken(token: Token | undefined): asserts token is A_WhitespaceToken;
-export declare function asA_WhitespaceToken(token: Token | undefined): A_WhitespaceToken;
-export declare function isA_NumberToken(token: Token | undefined): token is A_NumberToken;
-export declare function assertA_NumberToken(token: Token | undefined): asserts token is A_NumberToken;
-export declare function asA_NumberToken(token: Token | undefined): A_NumberToken;
-export declare function isA_BasePrefixedNumberToken(token: Token | undefined): token is A_BasePrefixedNumberToken;
-export declare function assertA_BasePrefixedNumberToken(token: Token | undefined): asserts token is A_BasePrefixedNumberToken;
-export declare function asA_BasePrefixedNumberToken(token: Token | undefined): A_BasePrefixedNumberToken;
-export {};

package/dist/src/tokenizer/common/commonTokenizers.d.ts

@@ -1,9 +0,0 @@
-import type { TokenDescriptor, Tokenizer } from '../interface';
-import type { SimpleToken } from '../tokens';
-import type { LBraceToken, LBracketToken, LParenToken, RBraceToken, RBracketToken, RParenToken, RegexpShorthandToken, StringToken } from './commonTokens';
-export declare const NO_MATCH: TokenDescriptor<never>;
-export declare function isNoMatch(tokenDescriptor: TokenDescriptor<any>): tokenDescriptor is TokenDescriptor<never>;
-export declare const tokenizeString: Tokenizer<StringToken>;
-export declare const tokenizeRegexpShorthand: Tokenizer<RegexpShorthandToken>;
-export declare function tokenizeSimpleToken<T extends SimpleToken>(type: T[0], value: string, input: string, position: number): TokenDescriptor<T>;
-export declare const commonTokenizers: readonly [Tokenizer<LParenToken>, Tokenizer<RParenToken>, Tokenizer<LBracketToken>, Tokenizer<RBracketToken>, Tokenizer<LBraceToken>, Tokenizer<RBraceToken>, Tokenizer<StringToken>, Tokenizer<RegexpShorthandToken>];