@mojir/lits 2.0.13 → 2.0.15

package/dist/cli/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", "if_let", "when_let", "when_first", "fn", "defn", "defns", "try", "throw", "if", "if_not", "cond", "switch", "when", "when_not", "comment", "do", "recur", "loop", "doseq", "for", "declared?", "??"];
+    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", "if_let", "when_let", "when_first", "fn", "defn", "defns", "try", "throw", "if", "if_not", "cond", "switch", "when", "when_not", "comment", "do", "recur", "loop", "doseq", "for", "declared?", "??", "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/cli/src/analyze/calculateOutcomes/calculateIfLetOutcomes.d.ts

@@ -1,3 +1,3 @@
-import type { IfLetNode } from '../../builtin/specialExpressions/if-let';
+import type { IfLetNode } from '../../builtin/specialExpressions/if_let';
 import type { CalculatePossibleAstNodesHelper } from '.';
 export declare const calculateIfLetOutcomes: CalculatePossibleAstNodesHelper<IfLetNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateIfNotOutcomes.d.ts

@@ -1,3 +1,3 @@
-import type { IfNotNode } from '../../builtin/specialExpressions/if-not';
+import type { IfNotNode } from '../../builtin/specialExpressions/if_not';
 import type { CalculatePossibleAstNodesHelper } from '.';
 export declare const calculateIfNotOutcomes: CalculatePossibleAstNodesHelper<IfNotNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateSwitchOutcomes.d.ts

@@ -0,0 +1,3 @@
+import type { SwitchNode } from '../../builtin/specialExpressions/switch';
+import type { CalculatePossibleAstNodesHelper } from '.';
+export declare const calculateSwitchOutcomes: CalculatePossibleAstNodesHelper<SwitchNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateWhenFirstOutcomes.d.ts

@@ -1,3 +1,3 @@
-import type { WhenFirstNode } from '../../builtin/specialExpressions/when-first';
+import type { WhenFirstNode } from '../../builtin/specialExpressions/when_first';
 import type { CalculatePossibleAstNodesHelper } from '.';
 export declare const calculateWhenFirstOutcomes: CalculatePossibleAstNodesHelper<WhenFirstNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateWhenLetOutcomes.d.ts

@@ -1,3 +1,3 @@
-import type { WhenLetNode } from '../../builtin/specialExpressions/when-let';
+import type { WhenLetNode } from '../../builtin/specialExpressions/when_let';
 import type { CalculatePossibleAstNodesHelper } from '.';
 export declare const calculateWhenLetOutcomes: CalculatePossibleAstNodesHelper<WhenLetNode>;

package/dist/cli/src/analyze/calculateOutcomes/calculateWhenNotOutcomes.d.ts

@@ -1,3 +1,3 @@
-import type { WhenNotNode } from '../../builtin/specialExpressions/when-not';
+import type { WhenNotNode } from '../../builtin/specialExpressions/when_not';
 import type { CalculatePossibleAstNodesHelper } from '.';
 export declare const calculateWhenNotOutcomes: CalculatePossibleAstNodesHelper<WhenNotNode>;

package/dist/cli/src/analyze/calculateOutcomes/specialExpressionCalculators.d.ts

@@ -7,8 +7,8 @@ import type { DefsNode } from '../../builtin/specialExpressions/defs';
 import type { DoNode } from '../../builtin/specialExpressions/do';
 import type { DefnNode, DefnsNode, FnNode } from '../../builtin/specialExpressions/functions';
 import type { IfNode } from '../../builtin/specialExpressions/if';
-import type { IfLetNode } from '../../builtin/specialExpressions/if-let';
-import type { IfNotNode } from '../../builtin/specialExpressions/if-not';
+import type { IfLetNode } from '../../builtin/specialExpressions/if_let';
+import type { IfNotNode } from '../../builtin/specialExpressions/if_not';
 import type { LetNode } from '../../builtin/specialExpressions/let';
 import type { LoopNode } from '../../builtin/specialExpressions/loop';
 import type { DoSeqNode, ForNode } from '../../builtin/specialExpressions/loops';
@@ -16,18 +16,19 @@ import type { OrNode } from '../../builtin/specialExpressions/or';
 import type { QqNode } from '../../builtin/specialExpressions/qq';
 import type { RecurNode } from '../../builtin/specialExpressions/recur';
 import type { ThrowNode } from '../../builtin/specialExpressions/throw';
-import type { TimeNode } from '../../builtin/specialExpressions/time';
 import type { TryNode } from '../../builtin/specialExpressions/try';
 import type { WhenNode } from '../../builtin/specialExpressions/when';
-import type { WhenFirstNode } from '../../builtin/specialExpressions/when-first';
-import type { WhenLetNode } from '../../builtin/specialExpressions/when-let';
-import type { WhenNotNode } from '../../builtin/specialExpressions/when-not';
+import type { WhenFirstNode } from '../../builtin/specialExpressions/when_first';
+import type { WhenLetNode } from '../../builtin/specialExpressions/when_let';
+import type { WhenNotNode } from '../../builtin/specialExpressions/when_not';
 import type { AstNode } from '../../parser/interface';
+import type { SwitchNode } from '../../builtin/specialExpressions/switch';
 import type { CalculatePossibleAstNodesHelperOptions } from '.';
 export declare const specialExpressionCalculator: {
-    and: (astNode: AndNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    '&&': (astNode: AndNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     comment: (astNode: CommentExpressionNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     cond: (astNode: CondNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    switch: (astNode: SwitchNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     'declared?': (astNode: DeclaredNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     defn: (astNode: DefnNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     def: (astNode: DefNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
@@ -37,19 +38,18 @@ export declare const specialExpressionCalculator: {
     doseq: (astNode: DoSeqNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     fn: (astNode: FnNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     for: (astNode: ForNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
-    'if-let': (astNode: IfLetNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    if_let: (astNode: IfLetNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     if: (astNode: IfNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
-    'if-not': (astNode: IfNotNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    if_not: (astNode: IfNotNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     let: (astNode: LetNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     loop: (astNode: LoopNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
-    or: (astNode: OrNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    '||': (astNode: OrNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     '??': (astNode: QqNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     recur: (astNode: RecurNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
-    'time!': (astNode: TimeNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     throw: (astNode: ThrowNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     try: (astNode: TryNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
-    'when-first': (astNode: WhenFirstNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
-    'when-let': (astNode: WhenLetNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    when_first: (astNode: WhenFirstNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    when_let: (astNode: WhenLetNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
     when: (astNode: WhenNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
-    'when-not': (astNode: WhenNotNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
+    when_not: (astNode: WhenNotNode, helperOptions: Omit<CalculatePossibleAstNodesHelperOptions<AstNode>, "astNode">) => AstNode[];
 };

package/dist/cli/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,23 @@ 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 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 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 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 '??': 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' | 'declared?' | 'do' | 'if' | 'if_not' | '||' | 'when' | 'when_not' | 'throw'>;
 export type BuiltinSpecialExpressions = typeof specialExpressions;
 export type BuiltinSpecialExpression = typeof specialExpressions[SpecialExpressionName];
 export type BuiltinCommonSpecialExpression = typeof specialExpressions[CommonSpecialExpressionName];

package/dist/cli/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/cli/src/builtin/specialExpressions/{if-let.d.ts → if_let.d.ts}

@@ -1,7 +1,7 @@
 import type { Any } from '../../interface';
 import type { BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface IfLetNode extends CommonSpecialExpressionNode<'if-let'> {
+export interface IfLetNode extends CommonSpecialExpressionNode<'if_let'> {
     b: BindingNode;
 }
 export declare const ifLetSpecialExpression: BuiltinSpecialExpression<Any, IfLetNode>;

package/dist/{src/builtin/specialExpressions/if-not.d.ts → cli/src/builtin/specialExpressions/if_not.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 IfNotNode extends CommonSpecialExpressionNode<'if_not'> {
 }
 export declare const ifNotSpecialExpression: BuiltinSpecialExpression<Any, IfNotNode>;

package/dist/cli/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/{src/builtin/specialExpressions/time.d.ts → cli/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/cli/src/builtin/specialExpressions/{when-first.d.ts → when_first.d.ts}

@@ -1,7 +1,7 @@
 import type { Any } from '../../interface';
 import type { BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface WhenFirstNode extends CommonSpecialExpressionNode<'when-first'> {
+export interface WhenFirstNode extends CommonSpecialExpressionNode<'when_first'> {
     b: BindingNode;
 }
 export declare const whenFirstSpecialExpression: BuiltinSpecialExpression<Any, WhenFirstNode>;

package/dist/{src/builtin/specialExpressions/when-let.d.ts → cli/src/builtin/specialExpressions/when_let.d.ts}

@@ -1,7 +1,7 @@
 import type { Any } from '../../interface';
 import type { BindingNode, CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface WhenLetNode extends CommonSpecialExpressionNode<'when-let'> {
+export interface WhenLetNode extends CommonSpecialExpressionNode<'when_let'> {
     b: BindingNode;
 }
 export declare const whenLetSpecialExpression: BuiltinSpecialExpression<Any, WhenLetNode>;

package/dist/cli/src/builtin/specialExpressions/{when-not.d.ts → when_not.d.ts}

@@ -1,6 +1,6 @@
 import type { Any } from '../../interface';
 import type { CommonSpecialExpressionNode } from '../../parser/interface';
 import type { BuiltinSpecialExpression } from '../interface';
-export interface WhenNotNode extends CommonSpecialExpressionNode<'when-not'> {
+export interface WhenNotNode extends CommonSpecialExpressionNode<'when_not'> {
 }
 export declare const whenNotSpecialExpression: BuiltinSpecialExpression<Any, WhenNotNode>;

package/dist/cli/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/cli/src/parser/AlgebraicParser.d.ts

@@ -1,3 +1,10 @@
+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 { Arity, FunctionArguments } from '../builtin/utils';
+import type { A_SymbolToken } from '../tokenizer/algebraic/algebraicTokens';
 import type { TokenStream } from '../tokenizer/interface';
 import type { AstNode, ParseState } from './interface';
 export declare class AlgebraicParser {
@@ -5,7 +12,7 @@ export declare class AlgebraicParser {
     private parseState;
     constructor(tokenStream: TokenStream, parseState: ParseState);
     private advance;
-    parse(): AstNode;
+    parse(): AstNode[];
     private parseExpression;
     private parseOperand;
     private parseOperandPart;
@@ -13,12 +20,20 @@ export declare class AlgebraicParser {
     private parseArray;
     private parseFunctionCall;
     parseLambdaFunction(): AstNode | null;
+    parseFunctionArguments(): {
+        functionArguments: FunctionArguments;
+        arity: Arity;
+    };
     private parseShorthandLamdaFunction;
     private parseLet;
     private parseFor;
     private parseForLoopBinding;
     private parseBinding;
+    parseIf(token: A_SymbolToken): IfNode;
+    parseCond(token: A_SymbolToken): CondNode;
+    parseSwitch(token: A_SymbolToken): SwitchNode;
+    parseDef(token: A_SymbolToken): DefNode;
+    parseDefn(token: A_SymbolToken): DefnNode;
     private isAtEnd;
     private peek;
-    private peekAhead;
 }

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

@@ -1,8 +1,107 @@
-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;
+    };
+};
+export declare const algebraicReservedNamesRecord: {
+    readonly if_let: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly when_let: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly when_first: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly fn: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly defns: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly try: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly recur: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly loop: {
+        readonly value: null;
+        readonly forbidden: true;
+    };
+    readonly doseq: {
+        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;
+    };
+};
+export type ValidAlgebraicReservedName = keyof typeof validAlgebraicReservedNamesRecord;
+export type AlgebraicReservedName = keyof typeof algebraicReservedNamesRecord;
 export {};

package/dist/cli/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/cli/src/tokenizer/algebraic/algebraicTokens.d.ts

@@ -1,13 +1,14 @@
 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"];
 export declare const algebraicTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "String", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
 declare const symbolicUnaryOperators: readonly ["!", "~", "+", "-"];
 declare const symbolicBinaryOperators: readonly ["**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??"];
-declare const symbolicOperators: readonly ["!", "~", "+", "-", "**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??", "=>", "...", ".", ",", "="];
+declare const symbolicOperators: readonly ["!", "~", "+", "-", "**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??", "=>", "...", ".", ",", "=", ";"];
 export declare function isFunctionOperator(operator: string): boolean;
 export type SymbolicUnaryOperator = typeof symbolicUnaryOperators[number];
 export type SymbolicBinaryOperator = typeof symbolicBinaryOperators[number];
@@ -30,7 +31,7 @@ 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;
@@ -41,9 +42,9 @@ export declare function asA_SymbolToken(token: Token | undefined): A_SymbolToken
 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/cli/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/cli/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/cli/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/cli/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;