@mojir/lits 1.1.0

package/dist/reference/api.d.ts

@@ -0,0 +1,59 @@
+export declare const api: {
+    readonly collection: readonly ["count", "get", "get-in", "contains?", "has?", "has-some?", "has-every?", "assoc", "assoc-in", "concat", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in"];
+    readonly array: readonly ["array", "range", "repeat", "flatten", "mapcat"];
+    readonly sequence: readonly ["nth", "push", "pop", "unshift", "shift", "slice", "reductions", "reduce", "reduce-right", "map", "filter", "position", "index-of", "some", "reverse", "first", "second", "last", "rest", "nthrest", "next", "nthnext", "cons", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "random-sample!", "rand-nth!", "shuffle!", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by"];
+    readonly math: readonly ["+", "-", "*", "/", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "pow", "exp", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "positive-infinity", "negative-infinity", "max-safe-integer", "min-safe-integer", "max-value", "min-value", "epsilon", "nan", "e", "pi", "log", "log2", "log10", "rand!", "rand-int!", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh"];
+    readonly functional: readonly ["apply", "identity", "partial", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnil"];
+    readonly misc: readonly ["not=", "=", "<", ">", "<=", ">=", "not", "write!", "inst-ms!", "iso-date-time->inst-ms", "inst-ms->iso-date-time", "boolean", "compare", "lits-version!", "uuid!", "equal?", "json-parse", "json-stringify"];
+    readonly object: readonly ["dissoc", "object", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys"];
+    readonly predicate: readonly ["boolean?", "nil?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?"];
+    readonly regularExpression: readonly ["regexp", "match", "replace"];
+    readonly specialExpressions: readonly ["and", "or", "def", "defs", "let", "if-let", "when-let", "when-first", "fn", "defn", "defns", "try", "throw", "if", "if-not", "cond", "when", "when-not", "comment", "do", "recur", "loop", "time!", "doseq", "for", "declared?", "??"];
+    readonly string: readonly ["subs", "string-repeat", "str", "number", "number-to-string", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join"];
+    readonly bitwise: readonly ["bit-shift-left", "bit-shift-right", "bit-not", "bit-and", "bit-and-not", "bit-or", "bit-xor", "bit-flip", "bit-clear", "bit-set", "bit-test"];
+    readonly assert: readonly ["assert", "assert=", "assert-not=", "assert-equal", "assert-not-equal", "assert>", "assert<", "assert>=", "assert<=", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-nil", "assert-throws", "assert-throws-error", "assert-not-throws"];
+    readonly shorthand: ["_short_regexp", "_short_fn", "_short_string", "_short_dot", "_short_hash"];
+    readonly datatype: ["_type_number", "_type_string", "_type_object", "_type_array", "_type_boolean", "_type_function", "_type_integer", "_type_any", "_type_nil", "_type_collection", "_type_sequence", "_type_regexp", "_type_never"];
+};
+export type CollectionApiName = typeof api.collection[number];
+export type ArrayApiName = typeof api.array[number];
+export type SequenceApiName = typeof api.sequence[number];
+export type MathApiName = typeof api.math[number];
+export type FunctionalApiName = typeof api.functional[number];
+export type MiscApiName = typeof api.misc[number];
+export type ObjectApiName = typeof api.object[number];
+export type PredicateApiName = typeof api.predicate[number];
+export type RegularExpressionApiName = typeof api.regularExpression[number];
+export type SpecialExpressionsApiName = typeof api.specialExpressions[number];
+export type StringApiName = typeof api.string[number];
+export type BitwiseApiName = typeof api.bitwise[number];
+export type AssertApiName = typeof api.assert[number];
+export type FunctionName = CollectionApiName | ArrayApiName | SequenceApiName | MathApiName | FunctionalApiName | MiscApiName | ObjectApiName | PredicateApiName | RegularExpressionApiName | SpecialExpressionsApiName | StringApiName | BitwiseApiName | AssertApiName;
+export type ShorthandName = typeof api.shorthand[number];
+export type DatatypeName = typeof api.datatype[number];
+declare const apiNames: readonly ["count", "get", "get-in", "contains?", "has?", "has-some?", "has-every?", "assoc", "assoc-in", "concat", "not-empty", "every?", "not-every?", "any?", "not-any?", "update", "update-in", "array", "range", "repeat", "flatten", "mapcat", "nth", "push", "pop", "unshift", "shift", "slice", "reductions", "reduce", "reduce-right", "map", "filter", "position", "index-of", "some", "reverse", "first", "second", "last", "rest", "nthrest", "next", "nthnext", "cons", "take", "take-last", "take-while", "drop", "drop-last", "drop-while", "sort", "sort-by", "random-sample!", "rand-nth!", "shuffle!", "distinct", "remove", "remove-at", "split-at", "split-with", "frequencies", "group-by", "partition", "partition-all", "partition-by", "+", "-", "*", "/", "mod", "rem", "quot", "inc", "dec", "sqrt", "cbrt", "pow", "exp", "round", "trunc", "floor", "ceil", "min", "max", "abs", "sign", "positive-infinity", "negative-infinity", "max-safe-integer", "min-safe-integer", "max-value", "min-value", "epsilon", "nan", "e", "pi", "log", "log2", "log10", "rand!", "rand-int!", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "apply", "identity", "partial", "comp", "constantly", "juxt", "complement", "every-pred", "some-pred", "fnil", "not=", "=", "<", ">", "<=", ">=", "not", "write!", "inst-ms!", "iso-date-time->inst-ms", "inst-ms->iso-date-time", "boolean", "compare", "lits-version!", "uuid!", "equal?", "json-parse", "json-stringify", "dissoc", "object", "keys", "vals", "entries", "find", "merge", "merge-with", "zipmap", "select-keys", "boolean?", "nil?", "number?", "string?", "function?", "integer?", "array?", "object?", "coll?", "seq?", "regexp?", "zero?", "pos?", "neg?", "even?", "odd?", "finite?", "nan?", "negative-infinity?", "positive-infinity?", "false?", "true?", "empty?", "not-empty?", "regexp", "match", "replace", "and", "or", "def", "defs", "let", "if-let", "when-let", "when-first", "fn", "defn", "defns", "try", "throw", "if", "if-not", "cond", "when", "when-not", "comment", "do", "recur", "loop", "time!", "doseq", "for", "declared?", "??", "subs", "string-repeat", "str", "number", "number-to-string", "lower-case", "upper-case", "trim", "trim-left", "trim-right", "pad-left", "pad-right", "split", "template", "to-char-code", "from-char-code", "encode-base64", "decode-base64", "encode-uri-component", "decode-uri-component", "join", "bit-shift-left", "bit-shift-right", "bit-not", "bit-and", "bit-and-not", "bit-or", "bit-xor", "bit-flip", "bit-clear", "bit-set", "bit-test", "assert", "assert=", "assert-not=", "assert-equal", "assert-not-equal", "assert>", "assert<", "assert>=", "assert<=", "assert-true", "assert-false", "assert-truthy", "assert-falsy", "assert-nil", "assert-throws", "assert-throws-error", "assert-not-throws", "_short_regexp", "_short_fn", "_short_string", "_short_dot", "_short_hash", "_type_number", "_type_string", "_type_object", "_type_array", "_type_boolean", "_type_function", "_type_integer", "_type_any", "_type_nil", "_type_collection", "_type_sequence", "_type_regexp", "_type_never"];
+export type ApiName = typeof apiNames[number];
+export declare function isApiName(arg: string): arg is ApiName;
+export declare const categoryRecord: {
+    readonly 'Special expression': true;
+    readonly Predicate: true;
+    readonly Sequence: true;
+    readonly Collection: true;
+    readonly Array: true;
+    readonly Object: true;
+    readonly String: true;
+    readonly Math: true;
+    readonly Functional: true;
+    readonly 'Regular expression': true;
+    readonly Bitwise: true;
+    readonly Misc: true;
+    readonly Assert: true;
+    readonly Shorthand: true;
+    readonly Datatype: true;
+};
+export type Category = keyof typeof categoryRecord;
+export declare const categories: ("String" | "Functional" | "Special expression" | "Predicate" | "Sequence" | "Collection" | "Array" | "Object" | "Math" | "Regular expression" | "Bitwise" | "Misc" | "Assert" | "Shorthand" | "Datatype")[];
+declare const dataTypes: readonly ["number", "string", "object", "array", "boolean", "function", "integer", "any", "nil", "collection", "sequence", "regexp", "never"];
+export type DataType = typeof dataTypes[number];
+export declare function isDataType(arg: string): arg is DataType;
+export {};

package/dist/reference/categories/array.d.ts

@@ -0,0 +1,3 @@
+import type { ArrayApiName } from '../api.ts';
+import type { FunctionReference } from '../index.ts';
+export declare const arrayReference: Record<ArrayApiName, FunctionReference<'Array'>>;

package/dist/reference/categories/assert.d.ts

@@ -0,0 +1,3 @@
+import type { AssertApiName } from '../api.ts';
+import type { FunctionReference } from '../index.ts';
+export declare const assertReference: Record<AssertApiName, FunctionReference<'Assert'>>;

package/dist/reference/categories/bitwise.d.ts

@@ -0,0 +1,3 @@
+import type { BitwiseApiName } from '../api.ts';
+import type { FunctionReference } from '../index.ts';
+export declare const bitwiseReference: Record<BitwiseApiName, FunctionReference<'Bitwise'>>;

package/dist/reference/categories/collection.d.ts

@@ -0,0 +1,3 @@
+import type { CollectionApiName } from '../api.ts';
+import type { FunctionReference } from '../index.ts';
+export declare const collectionReference: Record<CollectionApiName, FunctionReference<'Collection'>>;

package/dist/reference/categories/functional.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionalApiName } from '../api.ts';
+import type { FunctionReference } from '../index.ts';
+export declare const functionalReference: Record<FunctionalApiName, FunctionReference<'Functional'>>;

package/dist/reference/categories/math.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '..';
+import type { MathApiName } from '../api';
+export declare const mathReference: Record<MathApiName, FunctionReference<'Math'>>;

package/dist/reference/categories/misc.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '..';
+import type { MiscApiName } from '../api';
+export declare const miscReference: Record<MiscApiName, FunctionReference<'Misc'>>;

package/dist/reference/categories/object.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '..';
+import type { ObjectApiName } from '../api';
+export declare const objectReference: Record<ObjectApiName, FunctionReference<'Object'>>;

package/dist/reference/categories/predicate.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '..';
+import type { PredicateApiName } from '../api';
+export declare const predicateReference: Record<PredicateApiName, FunctionReference<'Predicate'>>;

package/dist/reference/categories/regularExpression.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '..';
+import type { RegularExpressionApiName } from '../api';
+export declare const regularExpressionReference: Record<RegularExpressionApiName, FunctionReference<'Regular expression'>>;

package/dist/reference/categories/sequence.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '..';
+import type { SequenceApiName } from '../api';
+export declare const sequenceReference: Record<SequenceApiName, FunctionReference<'Sequence'>>;

package/dist/reference/categories/specialExpressions.d.ts

@@ -0,0 +1,3 @@
+import type { SpecialExpressionsApiName } from '../api.ts';
+import type { FunctionReference } from '../index.ts';
+export declare const specialExpressionsReference: Record<SpecialExpressionsApiName, FunctionReference<'Special expression'>>;

package/dist/reference/categories/string.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionReference } from '..';
+import type { StringApiName } from '../api';
+export declare const stringReference: Record<StringApiName, FunctionReference<'String'>>;

package/dist/reference/datatype.d.ts

@@ -0,0 +1,3 @@
+import type { DatatypeName } from './api';
+import type { DatatypeReference } from '.';
+export declare const datatype: Record<DatatypeName, DatatypeReference>;

package/dist/reference/index.d.ts

@@ -0,0 +1,50 @@
+import type { ApiName, Category, DataType } from './api';
+export interface TypedValue {
+    type: DataType[] | DataType;
+    rest?: true;
+    array?: true;
+}
+type NormalExpressionArgument = TypedValue & {
+    description?: string;
+};
+interface SpecialExpressionArgument {
+    type: '*expression' | '*name' | '*binding' | '*arguments' | '*catch-expression' | '*conditions' | '*for-binding';
+    rest?: true;
+    array?: true;
+    description?: string;
+}
+export type Argument = NormalExpressionArgument | SpecialExpressionArgument;
+export declare function isSpecialExpressionArgument(arg?: Argument): arg is SpecialExpressionArgument;
+export declare function isNormalExpressionArgument(arg?: Argument): arg is NormalExpressionArgument;
+export declare function isTypedValue(arg?: Argument): arg is TypedValue;
+interface Variant {
+    argumentNames: string[];
+}
+export interface CommonReference<T extends Category> {
+    title: string;
+    category: T;
+    linkName: string;
+    examples: string[];
+    description: string;
+    clojureDocs?: string | null;
+    seeAlso?: ApiName[];
+}
+export interface FunctionReference<T extends Category = Category> extends CommonReference<T> {
+    returns: TypedValue;
+    args: Record<string, Argument>;
+    variants: Variant[];
+}
+export interface ShorthandReference extends CommonReference<'Shorthand'> {
+    shorthand: true;
+    linkName: `_short_${string}`;
+}
+export interface DatatypeReference extends CommonReference<'Datatype'> {
+    datatype: true;
+    linkName: `_type_${string}`;
+}
+export type Reference<T extends Category = Category> = FunctionReference<T> | ShorthandReference | DatatypeReference;
+export declare function isFunctionReference<T extends Category>(ref: Reference<T>): ref is FunctionReference<T>;
+export declare function isShorthandReference<T extends Category>(ref: Reference<T>): ref is ShorthandReference;
+export declare function isDatatypeReference<T extends Category>(ref: Reference<T>): ref is DatatypeReference;
+export declare const apiReference: Record<ApiName, Reference>;
+export {};

package/dist/reference/shorthand.d.ts

@@ -0,0 +1,3 @@
+import type { ShorthandName } from './api';
+import type { ShorthandReference } from '.';
+export declare const shorthand: Record<ShorthandName, ShorthandReference>;

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

@@ -0,0 +1,16 @@
+import type { Ast } from '../parser/interface';
+export declare class Cache {
+    private cache;
+    private firstEntry;
+    private lastEntry;
+    private _size;
+    private maxSize;
+    constructor(maxSize: number | null);
+    getContent(): Record<string, Ast>;
+    get size(): number;
+    get(key: string): Ast | undefined;
+    clear(): void;
+    has(key: string): boolean;
+    set(key: string, value: Ast): void;
+    private dropFirstEntry;
+}

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

@@ -0,0 +1,50 @@
+import type { AnalyzeResult } from '../analyze/interface';
+import { ContextStack } from '../evaluator/ContextStack';
+import type { Context } from '../evaluator/interface';
+import type { Any } from '../interface';
+import type { Ast, LitsFunction } from '../parser/interface';
+import type { TokenStream } from '../tokenizer/interface';
+import { Cache } from './Cache';
+export interface LitsRuntimeInfo {
+    astCache: Cache | null;
+    astCacheSize: number | null;
+    debug: boolean;
+}
+export interface LazyValue {
+    read: () => unknown;
+    [key: string]: unknown;
+}
+export interface JsFunction {
+    fn: (...args: any[]) => unknown;
+    [key: string]: unknown;
+}
+export interface LitsParams {
+    globalContext?: Context;
+    contexts?: Context[];
+    values?: Record<string, unknown>;
+    lazyValues?: Record<string, LazyValue>;
+    jsFunctions?: Record<string, JsFunction>;
+    filePath?: string;
+}
+interface LitsConfig {
+    initialCache?: Record<string, Ast>;
+    astCacheSize?: number | null;
+    debug?: boolean;
+}
+export declare class Lits {
+    private astCache;
+    private astCacheSize;
+    private debug;
+    constructor(config?: LitsConfig);
+    getRuntimeInfo(): LitsRuntimeInfo;
+    run(program: string, params?: LitsParams): unknown;
+    context(program: string, params?: LitsParams): Context;
+    analyze(program: string): AnalyzeResult;
+    tokenize(program: string, filePath?: string): TokenStream;
+    parse(tokenStream: TokenStream): Ast;
+    private evaluate;
+    apply(fn: LitsFunction, fnParams: unknown[], params?: LitsParams): Any;
+    private generateAst;
+}
+export declare function createContextStack(params?: LitsParams): ContextStack;
+export {};

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

@@ -0,0 +1,2 @@
+import type { AnalyzeAst } from './interface';
+export declare const analyzeAst: AnalyzeAst;

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

@@ -0,0 +1,12 @@
+import type { Builtin } from '../builtin/interface';
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { AstNode } from '../parser/interface';
+import type { Token } from '../tokenizer/interface';
+export interface UndefinedSymbolEntry {
+    symbol: string;
+    token: Token | undefined;
+}
+export interface AnalyzeResult {
+    undefinedSymbols: Set<UndefinedSymbolEntry>;
+}
+export type AnalyzeAst = (astNode: AstNode | AstNode[], contextStack: ContextStack, builtin: Builtin) => AnalyzeResult;

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

@@ -0,0 +1,3 @@
+import type { AnalyzeResult } from './interface';
+export declare function joinAnalyzeResults(...results: AnalyzeResult[]): AnalyzeResult;
+export declare function addAnalyzeResults(target: AnalyzeResult, source: AnalyzeResult): void;

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

@@ -0,0 +1,5 @@
+import type { Builtin, BuiltinSpecialExpressions } from './interface';
+export declare const specialExpressions: BuiltinSpecialExpressions;
+export declare const builtin: Builtin;
+export declare const normalExpressionKeys: string[];
+export declare const specialExpressionKeys: string[];

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

@@ -0,0 +1,43 @@
+import type { EvaluateAstNode, ExecuteFunction } from '../evaluator/interface';
+import type { NormalExpressionNode, ParseArgument, ParseBinding, ParseBindings, ParseExpression, ParseToken, ParseTokens, SpecialExpressionNode } from '../parser/interface';
+import type { SourceCodeInfo, TokenStream } from '../tokenizer/interface';
+import type { Any, Arr } from '../interface';
+import type { AnalyzeAst, AnalyzeResult } from '../analyze/interface';
+import type { ContextStack } from '../evaluator/ContextStack';
+export type NormalExpressionEvaluator<T> = (params: Arr, sourceCodeInfo: SourceCodeInfo | undefined, contextStack: ContextStack, { executeFunction }: {
+    executeFunction: ExecuteFunction;
+}) => T;
+type ValidateNode = (node: NormalExpressionNode) => void;
+interface BuiltinNormalExpression<T> {
+    evaluate: NormalExpressionEvaluator<T>;
+    validate?: ValidateNode;
+}
+export interface ParserHelpers {
+    parseExpression: ParseExpression;
+    parseTokens: ParseTokens;
+    parseToken: ParseToken;
+    parseBinding: ParseBinding;
+    parseBindings: ParseBindings;
+    parseArgument: ParseArgument;
+}
+export type BuiltinNormalExpressions = Record<string, BuiltinNormalExpression<Any>>;
+export type BuiltinSpecialExpressions = Record<string, BuiltinSpecialExpression<Any>>;
+interface EvaluateHelpers {
+    evaluateAstNode: EvaluateAstNode;
+    builtin: Builtin;
+}
+export interface BuiltinSpecialExpression<T> {
+    parse: (tokenStream: TokenStream, position: number, parsers: ParserHelpers) => [number, SpecialExpressionNode];
+    evaluate: (node: SpecialExpressionNode, contextStack: ContextStack, helpers: EvaluateHelpers) => T;
+    validate?: (node: SpecialExpressionNode) => void;
+    analyze: (node: SpecialExpressionNode, contextStack: ContextStack, params: {
+        analyzeAst: AnalyzeAst;
+        builtin: Builtin;
+    }) => AnalyzeResult;
+}
+export type SpecialExpressionName = 'and' | 'block' | 'comment' | 'cond' | 'def' | 'defn' | 'defns' | 'defs' | 'do' | 'doseq' | 'fn' | 'for' | 'function' | 'if-let' | 'if-not' | 'if' | 'let' | 'loop' | 'or' | 'partial' | 'recur' | 'return-from' | 'return' | 'throw' | 'time!' | 'try' | 'when-first' | 'when-let' | 'when-not' | 'when' | 'declared?' | '??';
+export interface Builtin {
+    normalExpressions: BuiltinNormalExpressions;
+    specialExpressions: BuiltinSpecialExpressions;
+}
+export {};

package/dist/src/builtin/normalExpressions/categories/array.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const arrayNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/assert.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const assertNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/bitwise.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const bitwiseNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/collection.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const collectionNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/functional.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const functionalNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/math.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const mathNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/misc.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const miscNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/object.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const objectNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/predicates.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const predicatesNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/regexp.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const regexpNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/sequence.d.ts

@@ -0,0 +1,4 @@
+import type { Arr } from '../../../interface';
+import type { BuiltinNormalExpressions, NormalExpressionEvaluator } from '../../interface';
+export declare const evaluateMap: NormalExpressionEvaluator<Arr | string>;
+export declare const sequenceNormalExpression: BuiltinNormalExpressions;

package/dist/src/builtin/normalExpressions/categories/string.d.ts

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../../interface';
+export declare const stringNormalExpression: BuiltinNormalExpressions;

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

@@ -0,0 +1,2 @@
+import type { BuiltinNormalExpressions } from '../interface';
+export declare const normalExpressions: BuiltinNormalExpressions;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const andSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,2 @@
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const commentSpecialExpression: BuiltinSpecialExpression<null>;

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

@@ -0,0 +1,8 @@
+import type { Any } from '../../interface';
+import type { AstNode } from '../../parser/interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export interface Condition {
+    t: AstNode;
+    f: AstNode;
+}
+export declare const condSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,2 @@
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const declaredSpecialExpression: BuiltinSpecialExpression<boolean>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const defSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const defsSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const doSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,9 @@
+import type { LitsFunction, SpecialExpressionNode } from '../../parser/interface';
+import type { BuiltinSpecialExpression } from '../interface';
+import type { FunctionOverload } from '../utils';
+export type FnNode = SpecialExpressionNode & {
+    o: FunctionOverload[];
+};
+export declare const defnSpecialExpression: BuiltinSpecialExpression<null>;
+export declare const defnsSpecialExpression: BuiltinSpecialExpression<null>;
+export declare const fnSpecialExpression: BuiltinSpecialExpression<LitsFunction>;

package/dist/src/builtin/specialExpressions/if-let.d.ts

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const ifLetSpecialExpression: BuiltinSpecialExpression<Any>;

package/dist/src/builtin/specialExpressions/if-not.d.ts

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const ifNotSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const ifSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const letSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const loopSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,12 @@
+import type { Any } from '../../interface';
+import type { AstNode, BindingNode } from '../../parser/interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export interface LoopBindingNode {
+    b: BindingNode;
+    m: Array<'&let' | '&when' | '&while'>;
+    l?: BindingNode[];
+    wn?: AstNode;
+    we?: AstNode;
+}
+export declare const forSpecialExpression: BuiltinSpecialExpression<Any>;
+export declare const doseqSpecialExpression: BuiltinSpecialExpression<null>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const orSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const qqSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,2 @@
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const recurSpecialExpression: BuiltinSpecialExpression<null>;

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

@@ -0,0 +1,2 @@
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const throwSpecialExpression: BuiltinSpecialExpression<null>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const timeSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const trySpecialExpression: BuiltinSpecialExpression<Any>;

package/dist/src/builtin/specialExpressions/when-first.d.ts

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const whenFirstSpecialExpression: BuiltinSpecialExpression<Any>;

package/dist/src/builtin/specialExpressions/when-let.d.ts

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const whenLetSpecialExpression: BuiltinSpecialExpression<Any>;

package/dist/src/builtin/specialExpressions/when-not.d.ts

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const whenNotSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,3 @@
+import type { Any } from '../../interface';
+import type { BuiltinSpecialExpression } from '../interface';
+export declare const whenSpecialExpression: BuiltinSpecialExpression<Any>;

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

@@ -0,0 +1,18 @@
+import type { ContextStack } from '../evaluator/ContextStack';
+import type { AstNode, BindingNode } from '../parser/interface';
+import type { SourceCodeInfo } from '../tokenizer/interface';
+import type { Builtin } from './interface';
+export type Arity = number | {
+    min: number;
+};
+export interface FunctionOverload {
+    as: FunctionArguments;
+    a: Arity;
+    b: AstNode[];
+}
+export interface FunctionArguments {
+    m: string[];
+    r?: string;
+    b: BindingNode[];
+}
+export declare function assertNameNotDefined<T>(name: T, contextStack: ContextStack, builtin: Builtin, sourceCodeInfo?: SourceCodeInfo): asserts name is T;

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

@@ -0,0 +1,42 @@
+export declare enum AstNodeType {
+    Number = 201,
+    String = 202,
+    NormalExpression = 203,
+    SpecialExpression = 204,
+    Name = 205,
+    Modifier = 206,
+    ReservedName = 207,
+    Binding = 208,
+    Argument = 209,
+    Partial = 210
+}
+export declare const astNodeTypeName: Map<AstNodeType, string>;
+export declare function isAstNodeType(type: unknown): type is AstNodeType;
+export declare enum TokenType {
+    Bracket = 101,
+    Number = 102,
+    Name = 103,
+    String = 104,
+    ReservedName = 105,
+    Modifier = 106,
+    RegexpShorthand = 107,
+    FnShorthand = 108,
+    CollectionAccessor = 109
+}
+export declare const tokenTypeName: Map<TokenType, string>;
+export declare function isTokenType(type: unknown): type is TokenType;
+export declare enum FunctionType {
+    UserDefined = 301,
+    Partial = 302,
+    Comp = 303,
+    Constantly = 304,
+    Juxt = 305,
+    Complement = 306,
+    EveryPred = 307,
+    SomePred = 308,
+    Fnil = 309,
+    Builtin = 310,
+    NativeJsFunction = 399
+}
+export declare const functionTypeName: Map<FunctionType, string>;
+export declare function isFunctionType(type: unknown): type is FunctionType;