@mojir/lits 2.0.14 → 2.0.16

package/dist/reference/api.d.ts

@@ -2,15 +2,15 @@ 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", "take", "take_last", "take_while", "drop", "drop_last", "drop_while", "sort", "sort_by", "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", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh"];
+    readonly math: readonly ["+", "-", "*", "/", "mod", "%", "quot", "inc", "dec", "sqrt", "cbrt", "**", "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", "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", "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 misc: readonly ["!=", "==", "<", ">", "<=", ">=", "!", "write!", "iso_date>epoch", "epoch>iso_date", "boolean", "compare", "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", "unsigned-bit-shift-right", "bit-not", "bit-and", "bit-and-not", "bit-or", "bit-xor", "bit-flip", "bit-clear", "bit-set", "bit-test"];
+    readonly specialExpressions: readonly ["&&", "||", "def", "defs", "let", "fn", "defn", "defns", "try", "throw", "if", "unless", "cond", "switch", "comment", "do", "recur", "loop", "doseq", "for", "defined?", "??"];
+    readonly string: readonly ["subs", "string_repeat", "str", "number", "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_flip", "bit_clear", "bit_set", "bit_test"];
     readonly assert: readonly ["assert", "assert=", "assert!=", "assert_equal", "assert_not_equal", "assert_gt", "assert_lt", "assert_gte", "assert_lte", "assert_true", "assert_false", "assert_truthy", "assert_falsy", "assert_null", "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"];
@@ -31,7 +31,7 @@ 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", "take", "take_last", "take_while", "drop", "drop_last", "drop_while", "sort", "sort_by", "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", "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", "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", "unsigned-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!=", "assert_equal", "assert_not_equal", "assert_gt", "assert_lt", "assert_gte", "assert_lte", "assert_true", "assert_false", "assert_truthy", "assert_falsy", "assert_null", "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"];
+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", "take", "take_last", "take_while", "drop", "drop_last", "drop_while", "sort", "sort_by", "distinct", "remove", "remove_at", "split_at", "split_with", "frequencies", "group_by", "partition", "partition_all", "partition_by", "+", "-", "*", "/", "mod", "%", "quot", "inc", "dec", "sqrt", "cbrt", "**", "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", "sin", "cos", "tan", "asin", "acos", "atan", "sinh", "cosh", "tanh", "asinh", "acosh", "atanh", "apply", "identity", "partial", "comp", "constantly", "juxt", "complement", "every_pred", "some_pred", "fnil", "!=", "==", "<", ">", "<=", ">=", "!", "write!", "iso_date>epoch", "epoch>iso_date", "boolean", "compare", "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", "&&", "||", "def", "defs", "let", "fn", "defn", "defns", "try", "throw", "if", "unless", "cond", "switch", "comment", "do", "recur", "loop", "doseq", "for", "defined?", "??", "subs", "string_repeat", "str", "number", "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_flip", "bit_clear", "bit_set", "bit_test", "assert", "assert=", "assert!=", "assert_equal", "assert_not_equal", "assert_gt", "assert_lt", "assert_gte", "assert_lte", "assert_true", "assert_false", "assert_truthy", "assert_falsy", "assert_null", "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: {
@@ -53,7 +53,7 @@ export declare const categoryRecord: {
 };
 export type Category = keyof typeof categoryRecord;
 export declare const categories: Category[];
-declare const dataTypes: readonly ["number", "string", "object", "array", "boolean", "function", "integer", "any", "nil", "collection", "sequence", "regexp", "never"];
+declare const dataTypes: readonly ["number", "string", "object", "array", "boolean", "function", "integer", "any", "null", "collection", "sequence", "regexp", "never"];
 export type DataType = typeof dataTypes[number];
 export declare function isDataType(arg: string): arg is DataType;
 export {};

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

@@ -8,10 +8,8 @@ export interface UnresolvedIdentifier {
     token: Token | undefined;
 }
 export type UnresolvedIdentifiers = Set<UnresolvedIdentifier>;
-export type Outcomes = unknown[];
 export interface Analysis {
     unresolvedIdentifiers: UnresolvedIdentifiers;
-    outcomes: Outcomes | null;
 }
 export type FindUnresolvedIdentifiers = (ast: Ast | AstNode[], contextStack: ContextStack, builtin: Builtin) => UnresolvedIdentifiers;
 export declare function analyze(ast: Ast, params: LitsParams): Analysis;

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

@@ -1,8 +1,9 @@
 import type { Builtin } from './interface';
 declare const specialExpressions: {
-    readonly and: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/and").AndNode>;
+    readonly '&&': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/and").AndNode>;
     readonly comment: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/comment").CommentExpressionNode>;
     readonly cond: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/cond").CondNode>;
+    readonly switch: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/switch").SwitchNode>;
     readonly def: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/def").DefNode>;
     readonly defn: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/functions").DefnNode>;
     readonly defns: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/functions").DefnsNode>;
@@ -12,24 +13,18 @@ declare const specialExpressions: {
     readonly for: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loops").ForNode>;
     readonly fn: import("./interface").BuiltinSpecialExpression<import("..").LitsFunction, import("./specialExpressions/functions").FnNode>;
     readonly if: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if").IfNode>;
-    readonly 'if-let': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if-let").IfLetNode>;
-    readonly 'if-not': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/if-not").IfNotNode>;
+    readonly unless: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/unless").UnlessNode>;
     readonly let: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/let").LetNode>;
     readonly loop: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/loop").LoopNode>;
-    readonly or: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/or").OrNode>;
+    readonly '||': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/or").OrNode>;
     readonly recur: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/recur").RecurNode>;
     readonly throw: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/throw").ThrowNode>;
-    readonly 'time!': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/time").TimeNode>;
     readonly try: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/try").TryNode>;
-    readonly when: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/when").WhenNode>;
-    readonly 'when-first': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/when-first").WhenFirstNode>;
-    readonly 'when-let': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/when-let").WhenLetNode>;
-    readonly 'when-not': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/when-not").WhenNotNode>;
-    readonly 'declared?': import("./interface").BuiltinSpecialExpression<boolean, import("./specialExpressions/declared").DeclaredNode>;
+    readonly 'defined?': import("./interface").BuiltinSpecialExpression<boolean, import("./specialExpressions/declared").DeclaredNode>;
     readonly '??': import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/qq").QqNode>;
 };
 export type SpecialExpressionName = keyof typeof specialExpressions;
-export type CommonSpecialExpressionName = keyof Pick<typeof specialExpressions, '??' | '??' | 'and' | 'comment' | 'cond' | 'declared?' | 'do' | 'if' | 'if-not' | 'or' | 'time!' | 'when' | 'when-not' | 'throw'>;
+export type CommonSpecialExpressionName = keyof Pick<typeof specialExpressions, '??' | '&&' | 'comment' | 'cond' | 'switch' | 'defined?' | 'do' | 'if' | 'unless' | '||' | 'throw'>;
 export type BuiltinSpecialExpressions = typeof specialExpressions;
 export type BuiltinSpecialExpression = typeof specialExpressions[SpecialExpressionName];
 export type BuiltinCommonSpecialExpression = typeof specialExpressions[CommonSpecialExpressionName];

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
 import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface AndNode extends CommonSpecialExpressionNode<'and'> {
+export interface AndNode extends CommonSpecialExpressionNode<'&&'> {
 }
 export declare const andSpecialExpression: BuiltinSpecialExpression<Any, AndNode>;

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

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

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

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
 import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface OrNode extends CommonSpecialExpressionNode<'or'> {
+export interface OrNode extends CommonSpecialExpressionNode<'||'> {
 }
 export declare const orSpecialExpression: BuiltinSpecialExpression<Any, OrNode>;

package/dist/{cli/src/builtin/specialExpressions/time.d.ts → src/builtin/specialExpressions/switch.d.ts}

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
 import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface TimeNode extends CommonSpecialExpressionNode<'time!'> {
+export interface SwitchNode extends CommonSpecialExpressionNode<'switch'> {
 }
-export declare const timeSpecialExpression: BuiltinSpecialExpression<Any, TimeNode>;
+export declare const switchSpecialExpression: BuiltinSpecialExpression<Any, SwitchNode>;

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

@@ -2,7 +2,7 @@ import type { Any } from '../../interface';
 import type { AstNode, CommonSpecialExpressionNode, SymbolNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
 export interface TryNode extends CommonSpecialExpressionNode<'try'> {
-    e: SymbolNode;
+    e: SymbolNode | undefined;
     ce: AstNode;
 }
 export declare const trySpecialExpression: BuiltinSpecialExpression<Any, TryNode>;

package/dist/src/builtin/specialExpressions/{if-not.d.ts → unless.d.ts}

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
 import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface IfNotNode extends CommonSpecialExpressionNode<'if-not'> {
+export interface UnlessNode extends CommonSpecialExpressionNode<'unless'> {
 }
-export declare const ifNotSpecialExpression: BuiltinSpecialExpression<Any, IfNotNode>;
+export declare const unlessSpecialExpression: BuiltinSpecialExpression<Any, UnlessNode>;

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

@@ -16,6 +16,8 @@ export declare class ContextStackImpl {
         nativeJsFunctions?: Record<string, NativeJsFunction>;
     });
     create(context: Context, extraData?: ExtraData): ContextStack;
+    exportValue(name: string, value: Any): void;
+    addValue(name: string, value: Any): void;
     clone(): ContextStack;
     getValue(name: string): unknown;
     lookUp(node: SymbolNode): LookUpResult;

package/dist/src/identifier.d.ts

@@ -1,4 +1,4 @@
-export declare const polishIdentifierCharacterClass = "[\\w@%^?=!$<>+*/:-]";
-export declare const polishIdentifierFirstCharacterClass = "[a-zA-Z_@%^?=!$<>+*/-]";
+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,5 +1,9 @@
+import type { CondNode } from '../builtin/specialExpressions/cond';
 import type { DefNode } from '../builtin/specialExpressions/def';
 import type { DefnNode } from '../builtin/specialExpressions/functions';
+import type { IfNode } from '../builtin/specialExpressions/if';
+import type { SwitchNode } from '../builtin/specialExpressions/switch';
+import type { UnlessNode } from '../builtin/specialExpressions/unless';
 import type { Arity, FunctionArguments } from '../builtin/utils';
 import type { A_SymbolToken } from '../tokenizer/algebraic/algebraicTokens';
 import type { TokenStream } from '../tokenizer/interface';
@@ -23,12 +27,18 @@ export declare class AlgebraicParser {
     };
     private parseShorthandLamdaFunction;
     private parseLet;
-    private parseFor;
+    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;
     parseDef(token: A_SymbolToken): DefNode;
     parseDefn(token: A_SymbolToken): DefnNode;
     private isAtEnd;
+    private isAtExpressionEnd;
     private peek;
-    private peekAhead;
 }

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

@@ -1,8 +1,95 @@
-import type { Any } from '../../interface';
-export declare const algebraicReservedNamesRecord: Record<string, {
-    value: Any;
-    forbidden?: true;
-}>;
-type AlgebraicReservedName = keyof typeof algebraicReservedNamesRecord;
-export declare const algebraicReservedNames: AlgebraicReservedName[];
+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;
+    };
+};
+export declare const algebraicReservedNamesRecord: {
+    readonly fn: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly defns: {
+        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;
+    };
+};
+export type ValidAlgebraicReservedName = keyof typeof validAlgebraicReservedNamesRecord;
+export type AlgebraicReservedName = keyof typeof algebraicReservedNamesRecord;
 export {};

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

@@ -3,8 +3,8 @@ import type { A_BasePrefixedNumberToken, A_MultiLineCommentToken, A_NumberToken,
 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_ReservedSymbolToken: Tokenizer<A_ReservedSymbolToken>;
 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>;

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

@@ -1,6 +1,7 @@
 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", "AlgNotation", "PolNotation", "EndNotation"];
 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", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
@@ -30,20 +31,20 @@ 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 = GenericAlgebraicValueToken<'A_ReservedSymbol'>;
+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(token: Token | undefined): token is A_SymbolToken;
-export declare function assertA_SymbolToken(token: Token | undefined): asserts token is A_SymbolToken;
-export declare function asA_SymbolToken(token: Token | undefined): A_SymbolToken;
+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(token: Token | undefined): token is A_ReservedSymbolToken;
-export declare function assertA_ReservedSymbolToken(token: Token | undefined): asserts token is A_ReservedSymbolToken;
-export declare function asA_ReservedSymbolToken(token: Token | undefined): A_ReservedSymbolToken;
+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;

package/dist/src/tokenizer/polish/polishTokenizers.d.ts

@@ -11,4 +11,4 @@ export declare const tokenizeP_ReservedSymbol: Tokenizer<P_ReservedSymbolToken>;
 export declare const tokenizeP_Modifier: Tokenizer<P_ModifierToken>;
 export declare const tokenizeP_CollectionAccessor: Tokenizer<P_CollectionAccessorToken>;
 export declare const tokenizeP_RegexpShorthand: Tokenizer<P_RegexpShorthandToken>;
-export declare const polishTokenizers: [Tokenizer<P_WhitespaceToken>, Tokenizer<P_CommentToken>, Tokenizer<import("../common/commonTokens").PolishNotationToken>, Tokenizer<import("../common/commonTokens").AlgebraicNotationToken>, Tokenizer<import("../common/commonTokens").EndNotationToken>, 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<P_StringShorthandToken>, Tokenizer<P_NumberToken>, Tokenizer<P_ReservedSymbolToken>, Tokenizer<P_SymbolToken>, Tokenizer<P_ModifierToken>, Tokenizer<P_RegexpShorthandToken>, Tokenizer<P_FnShorthandToken>, Tokenizer<P_CollectionAccessorToken>];
+export declare const polishTokenizers: [Tokenizer<P_WhitespaceToken>, Tokenizer<P_CommentToken>, Tokenizer<import("../common/commonTokens").PolishNotationToken>, Tokenizer<import("../common/commonTokens").AlgebraicNotationToken>, Tokenizer<import("../common/commonTokens").EndNotationToken>, 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<P_StringShorthandToken>, Tokenizer<P_NumberToken>, Tokenizer<P_ReservedSymbolToken>, Tokenizer<P_ModifierToken>, Tokenizer<P_SymbolToken>, Tokenizer<P_RegexpShorthandToken>, Tokenizer<P_FnShorthandToken>, Tokenizer<P_CollectionAccessorToken>];

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

@@ -1,7 +1,7 @@
 import type { CommonSimpleToken, CommonSimpleTokenType, CommonValueToken, CommonValueTokenType } from '../common/commonTokens';
 import type { Token } from '../tokens';
 import { type TokenDebugData } from '../utils';
-export declare const modifierNames: readonly ["&", "&let", "&when", "&while"];
+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", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand"];

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

@@ -6,4 +6,4 @@ export type TokenDebugData = {
 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, actual?: Token): never;
+export declare function throwUnexpectedToken(expected: TokenType, expectedValue: string | undefined, actual?: Token): never;

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

@@ -6,6 +6,7 @@ type Count = number | {
     max?: number;
 };
 export declare function assertEvenNumberOfParams(node: GenericNode): void;
+export declare function assertOddNumberOfParams(node: GenericNode): void;
 export declare function assertNumberOfParams(count: Count, node: GenericNode): void;
 export declare function isNonUndefined<T>(value: T | undefined): value is T;
 export declare function asNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): T;