@mojir/dvala 0.0.1 → 0.0.2

package/dist/modules/src/parser/subParsers/parseFunction.d.ts

@@ -0,0 +1,4 @@
+import type { LambdaNode } from '../../builtin/specialExpressions/functions';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLambdaFunction(ctx: ParserContext): LambdaNode | null;
+export declare function parseShorthandLambdaFunction(ctx: ParserContext): LambdaNode;

package/dist/modules/src/parser/subParsers/parseFunctionCall.d.ts

@@ -0,0 +1,3 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseFunctionCall(ctx: ParserContext, symbol: AstNode): AstNode;

package/dist/modules/src/parser/subParsers/parseIfOrUnless.d.ts

@@ -0,0 +1,5 @@
+import type { IfNode } from '../../builtin/specialExpressions/if';
+import type { UnlessNode } from '../../builtin/specialExpressions/unless';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseIfOrUnless(ctx: ParserContext, token: SymbolToken): IfNode | UnlessNode;

package/dist/modules/src/parser/subParsers/parseImplicitBlock.d.ts

@@ -0,0 +1,5 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+type ImplicitBlockEnd = 'end' | 'else' | 'catch' | 'case' | 'with';
+export declare function parseImplicitBlock(ctx: ParserContext, ends: ImplicitBlockEnd[]): AstNode;
+export {};

package/dist/modules/src/parser/subParsers/parseLet.d.ts

@@ -0,0 +1,4 @@
+import type { LetNode } from '../../builtin/specialExpressions/let';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLet(ctx: ParserContext, token: SymbolToken): LetNode;

package/dist/modules/src/parser/subParsers/parseLoop.d.ts

@@ -0,0 +1,4 @@
+import type { LoopNode } from '../../builtin/specialExpressions/loop';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseLoop(ctx: ParserContext, firstToken: SymbolToken): LoopNode;

package/dist/modules/src/parser/subParsers/parseMatch.d.ts

@@ -0,0 +1,4 @@
+import type { MatchNode } from '../../builtin/specialExpressions/match';
+import { type SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseMatch(ctx: ParserContext, token: SymbolToken): MatchNode;

package/dist/modules/src/parser/subParsers/parseNumber.d.ts

@@ -0,0 +1,3 @@
+import type { NumberNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseNumber(ctx: ParserContext): NumberNode;

package/dist/modules/src/parser/subParsers/parseObject.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectNode } from '../../builtin/specialExpressions/object';
+import type { ParserContext } from '../ParserContext';
+export declare function parseObject(ctx: ParserContext): ObjectNode;

package/dist/modules/src/parser/subParsers/parseOperand.d.ts

@@ -0,0 +1,3 @@
+import type { AstNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseOperand(ctx: ParserContext): AstNode;

package/dist/modules/src/parser/subParsers/parseRegexpShorthand.d.ts

@@ -0,0 +1,3 @@
+import type { NormalExpressionNodeWithName } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseRegexpShorthand(ctx: ParserContext): NormalExpressionNodeWithName;

package/dist/modules/src/parser/subParsers/parseReservedSymbol.d.ts

@@ -0,0 +1,3 @@
+import type { NumberNode, ReservedSymbolNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseReservedSymbol(ctx: ParserContext): ReservedSymbolNode | NumberNode;

package/dist/modules/src/parser/subParsers/parseString.d.ts

@@ -0,0 +1,4 @@
+import type { StringNode } from '../types';
+import type { StringToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseString(ctx: ParserContext, token: StringToken): StringNode;

package/dist/modules/src/parser/subParsers/parseSymbol.d.ts

@@ -0,0 +1,3 @@
+import type { NormalBuiltinSymbolNode, SpecialBuiltinSymbolNode, SymbolNode } from '../types';
+import type { ParserContext } from '../ParserContext';
+export declare function parseSymbol(ctx: ParserContext): SymbolNode | NormalBuiltinSymbolNode | SpecialBuiltinSymbolNode;

package/dist/modules/src/parser/subParsers/parseTry.d.ts

@@ -0,0 +1,4 @@
+import type { TryNode } from '../../builtin/specialExpressions/try';
+import type { SymbolToken } from '../../tokenizer/token';
+import type { ParserContext } from '../ParserContext';
+export declare function parseTry(ctx: ParserContext, token: SymbolToken): TryNode;

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

@@ -0,0 +1,129 @@
+import type { JsFunction } from '../Dvala/Dvala';
+import type { SpecialExpressionType } from '../builtin';
+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';
+import type { Any, Arr, Coll } from '../interface';
+import type { ReservedSymbol } from '../tokenizer/reservedNames';
+import type { SourceCodeInfo } from '../tokenizer/token';
+import type { EFFECT_SYMBOL, FUNCTION_SYMBOL, REGEXP_SYMBOL } from '../utils/symbols';
+export type EvaluatedFunction = [BindingTarget[], AstNode[], Context];
+interface GenericDvalaFunction {
+    [FUNCTION_SYMBOL]: true;
+    sourceCodeInfo?: SourceCodeInfo;
+    functionType: FunctionType;
+    arity: Arity;
+}
+export interface RegularExpression {
+    [REGEXP_SYMBOL]: true;
+    sourceCodeInfo?: SourceCodeInfo;
+    s: string;
+    f: string;
+}
+export interface EffectRef {
+    [EFFECT_SYMBOL]: true;
+    name: string;
+}
+export interface NativeJsFunction extends GenericDvalaFunction {
+    functionType: 'NativeJsFunction';
+    name: string | undefined;
+    nativeFn: JsFunction;
+    docString: string;
+}
+export interface UserDefinedFunction extends GenericDvalaFunction {
+    functionType: 'UserDefined';
+    name: string | undefined;
+    evaluatedfunction: EvaluatedFunction;
+    docString: string;
+}
+export interface PartialFunction extends GenericDvalaFunction {
+    functionType: 'Partial';
+    function: FunctionLike;
+    params: Arr;
+    placeholders: number[];
+}
+export interface CompFunction extends GenericDvalaFunction {
+    functionType: 'Comp';
+    params: Arr;
+}
+export interface ConstantlyFunction extends GenericDvalaFunction {
+    functionType: 'Constantly';
+    value: Any;
+}
+export interface JuxtFunction extends GenericDvalaFunction {
+    functionType: 'Juxt';
+    params: Arr;
+}
+export interface ComplementFunction extends GenericDvalaFunction {
+    functionType: 'Complement';
+    function: FunctionLike;
+}
+export interface EveryPredFunction extends GenericDvalaFunction {
+    functionType: 'EveryPred';
+    params: Arr;
+}
+export interface SomePredFunction extends GenericDvalaFunction {
+    functionType: 'SomePred';
+    params: Arr;
+}
+export interface FNullFunction extends GenericDvalaFunction {
+    functionType: 'Fnull';
+    function: FunctionLike;
+    params: Arr;
+}
+export interface NormalBuiltinFunction extends GenericDvalaFunction {
+    functionType: 'Builtin';
+    normalBuiltinSymbolType: number;
+    name: string;
+}
+export interface SpecialBuiltinFunction extends GenericDvalaFunction {
+    functionType: 'SpecialBuiltin';
+    specialBuiltinSymbolType: typeof specialExpressionTypes['&&'] | typeof specialExpressionTypes['||'] | typeof specialExpressionTypes['array'] | typeof specialExpressionTypes['object'] | typeof specialExpressionTypes['defined?'] | typeof specialExpressionTypes['recur'] | typeof specialExpressionTypes['throw'] | typeof specialExpressionTypes['??'];
+}
+export interface ModuleFunction extends GenericDvalaFunction {
+    functionType: 'Module';
+    moduleName: string;
+    functionName: string;
+}
+export type DvalaFunction = NativeJsFunction | UserDefinedFunction | NormalBuiltinFunction | SpecialBuiltinFunction | ModuleFunction | PartialFunction | CompFunction | ConstantlyFunction | JuxtFunction | ComplementFunction | EveryPredFunction | SomePredFunction | FNullFunction;
+export type DvalaFunctionType = DvalaFunction['functionType'];
+export type FunctionLike = DvalaFunction | Coll | number;
+export type AstNode<T extends NodeType = NodeType, Payload = unknown> = [T, Payload] | [T, Payload, SourceCodeInfo];
+export type ExpressionNode = NormalExpressionNode | SpecialExpressionNode | NumberNode | StringNode;
+export type SpreadNode = AstNode<typeof NodeTypes.Spread, AstNode>;
+export type NumberNode = AstNode<typeof NodeTypes.Number, number>;
+export type StringNode = AstNode<typeof NodeTypes.String, string>;
+export type UserDefinedSymbolNode = AstNode<typeof NodeTypes.UserDefinedSymbol, string>;
+export type NormalBuiltinSymbolNode = AstNode<typeof NodeTypes.NormalBuiltinSymbol, number>;
+export type SpecialBuiltinSymbolNode = AstNode<typeof NodeTypes.SpecialBuiltinSymbol, SpecialExpressionType>;
+export type SymbolNode = UserDefinedSymbolNode | NormalBuiltinSymbolNode | SpecialBuiltinSymbolNode;
+export type ReservedSymbolNode = AstNode<typeof NodeTypes.ReservedSymbol, ReservedSymbol>;
+export type SpecialExpressionNode<T extends [SpecialExpressionType, ...unknown[]] = [SpecialExpressionType, ...unknown[]]> = AstNode<typeof NodeTypes.SpecialExpression, T>;
+export type NormalExpressionNodeWithName = AstNode<typeof NodeTypes.NormalExpression, [NormalBuiltinSymbolNode | UserDefinedSymbolNode, AstNode[]]>;
+export type NormalExpressionNodeExpression = AstNode<typeof NodeTypes.NormalExpression, [AstNode, AstNode[]]>;
+export type NormalExpressionNode = NormalExpressionNodeWithName | NormalExpressionNodeExpression;
+export declare const bindingTargetTypes: {
+    readonly symbol: 11;
+    readonly rest: 12;
+    readonly object: 13;
+    readonly array: 14;
+    readonly literal: 15;
+    readonly wildcard: 16;
+};
+export type BindingTargetType = typeof bindingTargetTypes[keyof typeof bindingTargetTypes];
+type GenericTarget<T extends BindingTargetType, Payload extends unknown[]> = [T, Payload] | [T, Payload, SourceCodeInfo];
+export type SymbolBindingTarget = GenericTarget<typeof bindingTargetTypes.symbol, [SymbolNode, AstNode | undefined]>;
+export type RestBindingTarget = GenericTarget<typeof bindingTargetTypes.rest, [string, AstNode | undefined]>;
+export type ObjectBindingTarget = GenericTarget<typeof bindingTargetTypes.object, [Record<string, BindingTarget>, AstNode | undefined]>;
+export type ArrayBindingTarget = GenericTarget<typeof bindingTargetTypes.array, [(BindingTarget | null)[], AstNode | undefined]>;
+export type LiteralBindingTarget = GenericTarget<typeof bindingTargetTypes.literal, [AstNode]>;
+export type WildcardBindingTarget = GenericTarget<typeof bindingTargetTypes.wildcard, []>;
+export type BindingTarget = SymbolBindingTarget | RestBindingTarget | ObjectBindingTarget | ArrayBindingTarget | LiteralBindingTarget | WildcardBindingTarget;
+export type BindingNode = AstNode<typeof NodeTypes.Binding, [BindingTarget, AstNode]>;
+type AstBody = AstNode[];
+export interface Ast {
+    body: AstBody;
+    hasDebugData: boolean;
+}
+export {};

package/dist/modules/src/symbolPatterns.d.ts

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

package/dist/modules/src/testFramework/index.d.ts

@@ -0,0 +1,15 @@
+interface RunTestParams {
+    testPath: string;
+    testNamePattern?: RegExp;
+}
+interface TestResult {
+    /**
+     * Test report
+     * http://testanything.org/
+     */
+    tap: string;
+    success: boolean;
+}
+export declare function runTest({ testPath: filePath, testNamePattern }: RunTestParams): TestResult;
+export declare function getErrorYaml(error: unknown): string;
+export {};

package/dist/modules/src/tokenizer/minifyTokenStream.d.ts

@@ -0,0 +1,4 @@
+import type { TokenStream } from './tokenize';
+export declare function minifyTokenStream(tokenStream: TokenStream, { removeWhiteSpace }: {
+    removeWhiteSpace: boolean;
+}): TokenStream;

package/dist/modules/src/tokenizer/operators.d.ts

@@ -0,0 +1,12 @@
+declare const binaryOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "==", "!=", "!=", "&", "xor", "|", "&&", "||", "??", "|>"];
+declare const symbolicOperators: readonly ["^", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", "≤", ">", ">=", "≥", "==", "!=", "!=", "&", "xor", "|", "&&", "||", "??", "|>", "?", ":", "->", "...", ".", ",", "=", ":", ";"];
+export declare function isFunctionOperator(operator: string): boolean;
+export type SymbolicBinaryOperator = typeof binaryOperators[number];
+export type SymbolicOperator = typeof symbolicOperators[number];
+export declare function isBinaryOperator(operator: string): operator is SymbolicBinaryOperator;
+export declare function assertBinaryOperator(operator: string): asserts operator is SymbolicBinaryOperator;
+export declare function asBinaryOperator(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 {};

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

@@ -0,0 +1,66 @@
+export declare const numberReservedSymbolRecord: {
+    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;
+};
+export declare const reservedSymbolRecord: {
+    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 do: 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 as: null;
+    readonly then: null;
+    readonly end: null;
+    readonly with: null;
+    readonly _: null;
+};
+export type ReservedSymbol = keyof typeof reservedSymbolRecord;
+export declare function isReservedSymbol(symbol: string): symbol is keyof typeof reservedSymbolRecord;
+export declare function isNumberReservedSymbol(symbol: string): symbol is keyof typeof numberReservedSymbolRecord;

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

@@ -0,0 +1,84 @@
+import type { ReservedSymbol } from './reservedNames';
+import { type SymbolicBinaryOperator, type SymbolicOperator } from './operators';
+export declare const tokenTypes: readonly ["LBrace", "LBracket", "RBrace", "RBracket", "LParen", "RParen", "BasePrefixedNumber", "DocString", "Error", "MultiLineComment", "Number", "Operator", "RegexpShorthand", "ReservedSymbol", "SingleLineComment", "Shebang", "string", "Symbol", "Whitespace"];
+export type TokenType = typeof tokenTypes[number];
+type GenericToken<T extends TokenType, V extends string = string> = [T, V] | [T, V, SourceCodeInfo];
+export type ErrorToken = ['Error', string, SourceCodeInfo | undefined, string];
+export type LBraceToken = GenericToken<'LBrace', '{'>;
+export type LBracketToken = GenericToken<'LBracket', '['>;
+export type LParenToken = GenericToken<'LParen', '('>;
+export type RBraceToken = GenericToken<'RBrace', '}'>;
+export type RBracketToken = GenericToken<'RBracket', ']'>;
+export type RParenToken = GenericToken<'RParen', ')'>;
+export type BasePrefixedNumberToken = GenericToken<'BasePrefixedNumber'>;
+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 ReservedSymbol = ReservedSymbol> = GenericToken<'ReservedSymbol', T>;
+export type SingleLineCommentToken = GenericToken<'SingleLineComment'>;
+export type ShebangToken = GenericToken<'Shebang'>;
+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 | DocStringToken | ErrorToken | MultiLineCommentToken | NumberToken | OperatorToken | RegexpShorthandToken | ReservedSymbolToken | SingleLineCommentToken | ShebangToken | StringToken | SymbolToken | WhitespaceToken;
+export type TokenDescriptor<T extends Token> = [length: number, token?: T];
+export interface SourceCodeInfo {
+    position: {
+        line: number;
+        column: number;
+    };
+    code: string;
+    filePath?: string;
+}
+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 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 isShebangToken(token: Token | undefined): token is SingleLineCommentToken;
+export declare function isSingleLineCommentToken(token: Token | undefined): token is SingleLineCommentToken;
+export declare function isMultiLineCommentToken(token: Token | undefined): token is MultiLineCommentToken;
+export declare function isOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): token is OperatorToken<T>;
+export declare function assertOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): asserts token is OperatorToken<T>;
+export declare function asOperatorToken<T extends SymbolicOperator>(token: Token | undefined | undefined, operatorName?: T): OperatorToken<T>;
+export declare function isWhitespaceToken(token: Token | undefined): token is WhitespaceToken;
+export declare function assertWhitespaceToken(token: Token | undefined): asserts token is WhitespaceToken;
+export declare function asWhitespaceToken(token: Token | undefined): WhitespaceToken;
+export declare function isNumberToken(token: Token | undefined): token is NumberToken;
+export declare function assertNumberToken(token: Token | undefined): asserts token is NumberToken;
+export declare function asNumberToken(token: Token | undefined): NumberToken;
+export declare function isBasePrefixedNumberToken(token: Token | undefined): token is BasePrefixedNumberToken;
+export declare function assertBasePrefixedNumberToken(token: Token | undefined): asserts token is BasePrefixedNumberToken;
+export declare function asBasePrefixedNumberToken(token: Token | undefined): BasePrefixedNumberToken;
+export declare function isLParenToken(token: Token | undefined): token is LParenToken;
+export declare function assertLParenToken(token: Token | undefined): asserts token is LParenToken;
+export declare function asLParenToken(token: Token | undefined): LParenToken;
+export declare function isRParenToken(token: Token | undefined): token is RParenToken;
+export declare function assertRParenToken(token: Token | undefined): asserts token is RParenToken;
+export declare function asRParenToken(token: Token | undefined): RParenToken;
+export declare function isLBracketToken(token: Token | undefined): token is LBracketToken;
+export declare function assertLBracketToken(token: Token | undefined): asserts token is LBracketToken;
+export declare function asLBracketToken(token: Token | undefined): LBracketToken;
+export declare function isRBracketToken(token: Token | undefined): token is RBracketToken;
+export declare function assertRBracketToken(token: Token | undefined): asserts token is RBracketToken;
+export declare function asRBracketToken(token: Token | undefined): RBracketToken;
+export declare function isLBraceToken(token: Token | undefined): token is LBraceToken;
+export declare function assertLBraceToken(token: Token | undefined): asserts token is LBraceToken;
+export declare function asLBraceToken(token: Token | undefined): LBraceToken;
+export declare function isRBraceToken(token: Token | undefined): token is RBraceToken;
+export declare function assertRBraceToken(token: Token | undefined): asserts token is RBraceToken;
+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;
+export declare function isA_BinaryOperatorToken(token: Token | undefined): token is OperatorToken<SymbolicBinaryOperator>;
+export declare function assertA_BinaryOperatorToken(token: Token | undefined): asserts token is OperatorToken<SymbolicBinaryOperator>;
+export declare function asA_BinaryOperatorToken(token: Token | undefined): OperatorToken<SymbolicBinaryOperator>;
+export {};

package/dist/modules/src/tokenizer/tokenize.d.ts

@@ -0,0 +1,8 @@
+import type { FilePathParams } from '../Dvala/Dvala';
+import type { Token } from './token';
+export interface TokenStream {
+    tokens: Token[];
+    hasDebugData: boolean;
+    filePath?: string;
+}
+export declare function tokenize(input: string, debug: boolean, filePath: FilePathParams['filePath']): TokenStream;

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

@@ -0,0 +1,14 @@
+import type { BasePrefixedNumberToken, DocStringToken, ErrorToken, LBraceToken, LBracketToken, LParenToken, MultiLineCommentToken, NumberToken, OperatorToken, RBraceToken, RBracketToken, RParenToken, RegexpShorthandToken, ReservedSymbolToken, SingleLineCommentToken, StringToken, SymbolToken, Token, TokenDescriptor, WhitespaceToken } from './token';
+type Tokenizer<T extends Token> = (input: string, position: number) => TokenDescriptor<T | ErrorToken>;
+export declare const NO_MATCH: TokenDescriptor<never>;
+export declare const tokenizeDocString: Tokenizer<DocStringToken>;
+export declare const tokenizeNumber: Tokenizer<NumberToken>;
+export declare const tokenizeBasePrefixedNumber: Tokenizer<BasePrefixedNumberToken>;
+export declare const tokenizeSymbol: Tokenizer<SymbolToken>;
+export declare const tokenizeReservedSymbolToken: Tokenizer<ReservedSymbolToken>;
+export declare const tokenizeOperator: Tokenizer<OperatorToken>;
+export declare const tokenizeMultiLineComment: Tokenizer<MultiLineCommentToken>;
+export declare const tokenizeShebang: Tokenizer<SingleLineCommentToken>;
+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<DocStringToken>, Tokenizer<StringToken>, Tokenizer<RegexpShorthandToken>, Tokenizer<BasePrefixedNumberToken>, Tokenizer<NumberToken>, Tokenizer<OperatorToken>, Tokenizer<SymbolToken>];
+export {};

package/dist/modules/src/transformer/index.d.ts

@@ -0,0 +1,2 @@
+import type { TokenStream } from '../tokenizer/tokenize';
+export declare function transformSymbolTokens(tokenStram: TokenStream, transformer: (symbol: string) => string): TokenStream;

package/dist/modules/src/typeGuards/annotatedArrays.d.ts

@@ -0,0 +1,16 @@
+import type { Any } from '../interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function annotate<T>(value: T): T;
+export declare function isVector(vector: unknown): vector is number[];
+export declare function assertVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is number[];
+export declare function is2dVector(vector: unknown): vector is [number, number];
+export declare function assert2dVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is [number, number];
+export declare function is3dVector(vector: unknown): vector is [number, number, number];
+export declare function assert3dVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is [number, number, number];
+export declare function assertNonEmptyVector(vector: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts vector is number[];
+export declare function isGrid(grid: unknown): grid is unknown[][];
+export declare function assertGrid(grid: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts grid is Any[][];
+export declare function isMatrix(matrix: unknown): matrix is number[][];
+export declare function assertMatrix(matrix: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts matrix is number[][];
+export declare function assertSquareMatrix(matrix: unknown, sourceCodeInfo: SourceCodeInfo | undefined): asserts matrix is number[][];
+export declare function isSquareMatrix(matrix: unknown): matrix is number[][];

package/dist/modules/src/typeGuards/array.d.ts

@@ -0,0 +1,9 @@
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function asArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): unknown[];
+export declare function assertArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is unknown[];
+export declare function isStringArray(value: unknown): value is string[];
+export declare function asStringArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): string[];
+export declare function assertStringArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string[];
+export declare function isCharArray(value: unknown): value is string[];
+export declare function asCharArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): string[];
+export declare function assertCharArray(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string[];

package/dist/modules/src/typeGuards/astNode.d.ts

@@ -0,0 +1,19 @@
+import type { AstNode, ExpressionNode, NormalBuiltinSymbolNode, NormalExpressionNode, NormalExpressionNodeWithName, SpecialBuiltinSymbolNode, SpreadNode, SymbolNode, UserDefinedSymbolNode } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function isSymbolNode(node: AstNode): node is SymbolNode;
+export declare function asSymbolNode(node: AstNode, sourceCodeInfo?: SourceCodeInfo): SymbolNode;
+export declare function assertSymbolNode(node: AstNode, sourceCodeInfo?: SourceCodeInfo): asserts node is SymbolNode;
+export declare function isUserDefinedSymbolNode(node: AstNode): node is UserDefinedSymbolNode;
+export declare function asUserDefinedSymbolNode(node: AstNode, sourceCodeInfo?: SourceCodeInfo): UserDefinedSymbolNode;
+export declare function isNormalBuiltinSymbolNode(node: AstNode): node is NormalBuiltinSymbolNode;
+export declare function isSpecialBuiltinSymbolNode(node: AstNode): node is SpecialBuiltinSymbolNode;
+export declare function isNormalExpressionNode(node: AstNode): node is NormalExpressionNode;
+export declare function asNormalExpressionNode(node: AstNode, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNode;
+export declare function assertNormalExpressionNode(node: AstNode, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalExpressionNode;
+export declare function isNormalExpressionNodeWithName(node: AstNode): node is NormalExpressionNodeWithName;
+export declare function asNormalExpressionNodeWithName(node: AstNode, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNodeWithName;
+export declare function assertNormalExpressionNodeWithName(node: AstNode, sourceCodeInfo?: SourceCodeInfo): asserts node is NormalExpressionNodeWithName;
+export declare function isExpressionNode(node: AstNode): node is ExpressionNode;
+export declare function asExpressionNode(node: AstNode, sourceCodeInfo?: SourceCodeInfo): ExpressionNode;
+export declare function assertExpressionNode(node: AstNode, sourceCodeInfo?: SourceCodeInfo): asserts node is ExpressionNode;
+export declare function isSpreadNode(node: AstNode): node is SpreadNode;

package/dist/modules/src/typeGuards/dvala.d.ts

@@ -0,0 +1,26 @@
+import type { Any, Coll, Obj, Seq } from '../interface';
+import type { EffectRef, FunctionLike, RegularExpression } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function isAny(value: unknown): value is Any;
+export declare function asAny(value: unknown, sourceCodeInfo?: SourceCodeInfo): Any;
+export declare function assertAny(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is Any;
+export declare function isSeq(value: unknown): value is Seq;
+export declare function asSeq(value: unknown, sourceCodeInfo?: SourceCodeInfo): Seq;
+export declare function assertSeq(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is Seq;
+export declare function isObj(value: unknown): value is Obj;
+export declare function asObj(value: unknown, sourceCodeInfo?: SourceCodeInfo): Obj;
+export declare function assertObj(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is Obj;
+export declare function isColl(value: unknown): value is Coll;
+export declare function asColl(value: unknown, sourceCodeInfo?: SourceCodeInfo): Coll;
+export declare function assertColl(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is Coll;
+export declare function isRegularExpression(regexp: unknown): regexp is RegularExpression;
+export declare function asRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): RegularExpression;
+export declare function assertRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is RegularExpression;
+export declare function isStringOrRegularExpression(value: unknown): value is string | RegularExpression;
+export declare function asStringOrRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): string | RegularExpression;
+export declare function assertStringOrRegularExpression(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string | RegularExpression;
+export declare function isEffectRef(value: unknown): value is EffectRef;
+export declare function asEffectRef(value: unknown, sourceCodeInfo?: SourceCodeInfo): EffectRef;
+export declare function assertEffectRef(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is EffectRef;
+export declare function asFunctionLike(value: unknown, sourceCodeInfo?: SourceCodeInfo): FunctionLike;
+export declare function assertFunctionLike(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is FunctionLike;

package/dist/modules/src/typeGuards/dvalaFunction.d.ts

@@ -0,0 +1,12 @@
+import type { DvalaFunction, NativeJsFunction, NormalBuiltinFunction, UserDefinedFunction } from '../parser/types';
+import type { SourceCodeInfo } from '../tokenizer/token';
+export declare function isDvalaFunction(value: unknown): value is DvalaFunction;
+export declare function asDvalaFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): DvalaFunction;
+export declare function assertDvalaFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is DvalaFunction;
+export declare function isUserDefinedFunction(value: unknown): value is UserDefinedFunction;
+export declare function asUserDefinedFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): UserDefinedFunction;
+export declare function assertUserDefinedFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is UserDefinedFunction;
+export declare function isNativeJsFunction(value: unknown): value is NativeJsFunction;
+export declare function asNativeJsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): NativeJsFunction;
+export declare function assertNativeJsFunction(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is NativeJsFunction;
+export declare function isBuiltinFunction(value: unknown): value is NormalBuiltinFunction;

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

@@ -0,0 +1,7 @@
+import type { UnknownRecord } from '../interface';
+import type { SourceCodeInfo } from '../tokenizer/token';
+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;

package/dist/modules/src/typeGuards/number.d.ts

@@ -0,0 +1,66 @@
+import type { SourceCodeInfo } from '../tokenizer/token';
+type SignOptions = {
+    positive?: true;
+    negative?: never;
+    nonPositive?: never;
+    nonNegative?: never;
+    zero?: never;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: true;
+    nonPositive?: never;
+    nonNegative?: never;
+    zero?: never;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: never;
+    nonPositive?: true;
+    nonNegative?: never;
+    zero?: never;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: never;
+    nonPositive?: never;
+    nonNegative?: true;
+    zero?: never;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: never;
+    nonPositive?: never;
+    nonNegative?: never;
+    zero?: true;
+    nonZero?: never;
+} | {
+    positive?: never;
+    negative?: never;
+    nonPositive?: never;
+    nonNegative?: never;
+    zero?: never;
+    nonZero?: true;
+};
+type GtOptions = {
+    gt?: number;
+    gte?: never;
+} | {
+    gt?: never;
+    gte?: number;
+};
+type LtOptions = {
+    lt?: number;
+    lte?: never;
+} | {
+    lt?: never;
+    lte?: number;
+};
+type NumberOptions = {
+    integer?: true;
+    finite?: true;
+} & SignOptions & GtOptions & LtOptions;
+export declare function isNumber(value: unknown, options?: NumberOptions): value is number;
+export declare function assertNumber(value: unknown, sourceCodeInfo?: SourceCodeInfo, options?: NumberOptions): asserts value is number;
+export declare function asNumber(value: unknown, sourceCodeInfo: SourceCodeInfo | undefined, options?: NumberOptions): number;
+export {};

package/dist/modules/src/typeGuards/string.d.ts

@@ -0,0 +1,15 @@
+import type { SourceCodeInfo } from '../tokenizer/token';
+type StringAssertionOptions = {
+    nonEmpty?: true;
+    char?: never;
+} | {
+    nonEmpty?: never;
+    char?: true;
+};
+export declare function isString(value: unknown, options?: StringAssertionOptions): value is string;
+export declare function assertString(value: unknown, sourceCodeInfo: SourceCodeInfo | undefined, options?: StringAssertionOptions): asserts value is string;
+export declare function asString(value: unknown, sourceCodeInfo: SourceCodeInfo | undefined, options?: StringAssertionOptions): string;
+export declare function isStringOrNumber(value: unknown): value is string | number;
+export declare function asStringOrNumber(value: unknown, sourceCodeInfo?: SourceCodeInfo): string | number;
+export declare function assertStringOrNumber(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is string | number;
+export {};