@mojir/lits 2.0.15 → 2.0.17

package/dist/reference/api.d.ts

@@ -1,15 +1,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 sequence: readonly ["nth", "push", "pop", "unshift", "shift", "slice", "reductions", "reduce", "reduce_right", "map", "filter", "position", "index_of", "last_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", "starts_with?", "ends_with?", "interleave", "interpose"];
     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 ["!=", "==", "<", ">", "<=", ">=", "!", "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 ["&&", "||", "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 regularExpression: readonly ["regexp", "match", "replace", "replace_all"];
+    readonly specialExpressions: readonly ["&&", "||", "def", "let", "fn", "defn", "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", "split_lines", "template", "to_char_code", "from_char_code", "encode_base64", "decode_base64", "encode_uri_component", "decode_uri_component", "join", "++", "capitalize", "blank?"];
     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"];
@@ -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", "%", "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"];
+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", "last_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", "starts_with?", "ends_with?", "interleave", "interpose", "+", "-", "*", "/", "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", "replace_all", "&&", "||", "def", "let", "fn", "defn", "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", "split_lines", "template", "to_char_code", "from_char_code", "encode_base64", "decode_base64", "encode_uri_component", "decode_uri_component", "join", "++", "capitalize", "blank?", "<<", ">>", ">>>", "~", "&", "&!", "|", "^", "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: {

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

@@ -6,30 +6,23 @@ declare const specialExpressions: {
     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>;
-    readonly defs: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/defs").DefsNode>;
     readonly do: import("./interface").BuiltinSpecialExpression<import("../interface").Any, import("./specialExpressions/do").DoNode>;
     readonly doseq: import("./interface").BuiltinSpecialExpression<null, import("./specialExpressions/loops").DoSeqNode>;
     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 '||': 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 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, '??' | '&&' | 'comment' | 'cond' | 'switch' | 'declared?' | 'do' | 'if' | 'if_not' | '||' | '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/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/functions.d.ts

@@ -5,14 +5,9 @@ export interface DefnNode extends CommonSpecialExpressionNode<'defn'> {
     f: SymbolNode;
     o: FunctionOverload[];
 }
-export interface DefnsNode extends CommonSpecialExpressionNode<'defns'> {
-    f: AstNode;
-    o: FunctionOverload[];
-}
 export interface FnNode extends CommonSpecialExpressionNode<'fn'> {
     p: AstNode[];
     o: FunctionOverload[];
 }
 export declare const defnSpecialExpression: BuiltinSpecialExpression<null, DefnNode>;
-export declare const defnsSpecialExpression: BuiltinSpecialExpression<null, DefnsNode>;
 export declare const fnSpecialExpression: BuiltinSpecialExpression<LitsFunction, FnNode>;

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/{when.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 WhenNode extends CommonSpecialExpressionNode<'when'> {
+export interface UnlessNode extends CommonSpecialExpressionNode<'unless'> {
 }
-export declare const whenSpecialExpression: BuiltinSpecialExpression<Any, WhenNode>;
+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/parser/AlgebraicParser.d.ts

@@ -1,16 +1,18 @@
 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 { LetNode } from '../builtin/specialExpressions/let';
 import type { SwitchNode } from '../builtin/specialExpressions/switch';
+import type { UnlessNode } from '../builtin/specialExpressions/unless';
 import type { Arity, FunctionArguments } from '../builtin/utils';
-import type { A_SymbolToken } from '../tokenizer/algebraic/algebraicTokens';
+import type { A_ReservedSymbolToken, A_SymbolToken } from '../tokenizer/algebraic/algebraicTokens';
 import type { TokenStream } from '../tokenizer/interface';
 import type { AstNode, ParseState } from './interface';
 export declare class AlgebraicParser {
     private readonly tokenStream;
     private parseState;
     constructor(tokenStream: TokenStream, parseState: ParseState);
+    private peek;
+    private peekAhead;
     private advance;
     parse(): AstNode[];
     private parseExpression;
@@ -26,14 +28,17 @@ export declare class AlgebraicParser {
     };
     private parseShorthandLamdaFunction;
     private parseLet;
-    private parseFor;
+    private parseDo;
+    private parseLoop;
+    private parseTry;
+    private parseForOrDoseq;
     private parseForLoopBinding;
     private parseBinding;
-    parseIf(token: A_SymbolToken): IfNode;
+    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;
+    parseFunction(token: A_ReservedSymbolToken<'function'>): LetNode;
     private isAtEnd;
-    private peek;
+    private isAtExpressionEnd;
+    private parseExport;
 }

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

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

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

@@ -31,41 +31,25 @@ declare const validAlgebraicReservedNamesRecord: {
         readonly value: null;
         readonly forbidden: false;
     };
-};
-export declare const algebraicReservedNamesRecord: {
-    readonly if_let: {
-        readonly value: null;
-        readonly forbidden: true;
-    };
-    readonly when_let: {
+    readonly when: {
         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 forbidden: false;
     };
-    readonly try: {
+    readonly while: {
         readonly value: null;
-        readonly forbidden: true;
+        readonly forbidden: false;
     };
-    readonly recur: {
+    readonly function: {
         readonly value: null;
-        readonly forbidden: true;
+        readonly forbidden: false;
     };
-    readonly loop: {
+    readonly export: {
         readonly value: null;
-        readonly forbidden: true;
+        readonly forbidden: false;
     };
-    readonly doseq: {
+};
+export declare const algebraicReservedNamesRecord: {
+    readonly fn: {
         readonly value: null;
         readonly forbidden: true;
     };
@@ -101,6 +85,22 @@ export declare const algebraicReservedNamesRecord: {
         readonly value: null;
         readonly forbidden: false;
     };
+    readonly when: {
+        readonly value: null;
+        readonly forbidden: false;
+    };
+    readonly while: {
+        readonly value: null;
+        readonly forbidden: false;
+    };
+    readonly function: {
+        readonly value: null;
+        readonly forbidden: false;
+    };
+    readonly export: {
+        readonly value: null;
+        readonly forbidden: false;
+    };
 };
 export type ValidAlgebraicReservedName = keyof typeof validAlgebraicReservedNamesRecord;
 export type AlgebraicReservedName = keyof typeof algebraicReservedNamesRecord;

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

@@ -8,4 +8,4 @@ export declare const tokenizeA_ReservedSymbolToken: Tokenizer<A_ReservedSymbolTo
 export declare const tokenizeA_Operator: Tokenizer<A_OperatorToken>;
 export declare const tokenizeA_MultiLineComment: Tokenizer<A_MultiLineCommentToken>;
 export declare const tokenizeA_SingleLineComment: Tokenizer<A_SingleLineCommentToken>;
-export declare const algebraicTokenizers: [Tokenizer<A_WhitespaceToken>, Tokenizer<A_MultiLineCommentToken>, Tokenizer<A_SingleLineCommentToken>, Tokenizer<import("../common/commonTokens").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<A_BasePrefixedNumberToken>, Tokenizer<A_NumberToken>, Tokenizer<A_OperatorToken>, Tokenizer<A_ReservedSymbolToken>, Tokenizer<A_SymbolToken>];
+export declare const algebraicTokenizers: [Tokenizer<A_WhitespaceToken>, Tokenizer<A_MultiLineCommentToken>, Tokenizer<A_SingleLineCommentToken>, 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<import("../common/commonTokens").RegexpShorthandToken>, Tokenizer<A_BasePrefixedNumberToken>, Tokenizer<A_NumberToken>, Tokenizer<A_OperatorToken>, Tokenizer<A_ReservedSymbolToken>, Tokenizer<A_SymbolToken>];

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

@@ -4,8 +4,8 @@ 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"];
+export declare const algebraicValueTokenTypes: readonly ["String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
+export declare const algebraicTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber"];
 declare const symbolicUnaryOperators: readonly ["!", "~", "+", "-"];
 declare const symbolicBinaryOperators: readonly ["**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??"];
 declare const symbolicOperators: readonly ["!", "~", "+", "-", "**", "*", "/", "%", "+", "-", "<<", ">>", ">>>", "++", "<", "<=", ">", ">=", "==", "!=", "&", "^", "|", "&&", "||", "??", "=>", "...", ".", ",", "=", ";"];
@@ -36,9 +36,9 @@ export type A_SingleLineCommentToken = GenericAlgebraicValueToken<'A_SingleLineC
 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>;

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

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

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

@@ -1,7 +1,7 @@
 import { type TokenDebugData } from '../utils';
 import type { Token } from '../tokens';
 export declare const commonSimpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation"];
-export declare const commomValueTokenTypes: readonly ["String"];
+export declare const commomValueTokenTypes: readonly ["String", "RegexpShorthand"];
 export type CommonSimpleTokenType = typeof commonSimpleTokenTypes[number];
 export type CommonValueTokenType = typeof commomValueTokenTypes[number];
 type GenericCommonSimpleToken<T extends CommonSimpleTokenType> = [T] | [T, TokenDebugData];
@@ -16,8 +16,9 @@ export type AlgebraicNotationToken = GenericCommonSimpleToken<'AlgNotation'>;
 export type PolishNotationToken = GenericCommonSimpleToken<'PolNotation'>;
 export type EndNotationToken = GenericCommonSimpleToken<'EndNotation'>;
 export type StringToken = GenericCommonValueToken<'String'>;
+export type RegexpShorthandToken = GenericCommonValueToken<'RegexpShorthand'>;
 export type CommonSimpleToken = LParenToken | RParenToken | LBracketToken | RBracketToken | LBraceToken | RBraceToken | AlgebraicNotationToken | PolishNotationToken | EndNotationToken;
-export type CommonValueToken = StringToken;
+export type CommonValueToken = StringToken | RegexpShorthandToken;
 export declare function isLParenToken(token?: Token): token is LParenToken;
 export declare function assertLParenToken(token?: Token): asserts token is LParenToken;
 export declare function asLParenToken(token?: Token): LParenToken;
@@ -39,6 +40,9 @@ export declare function asRBraceToken(token?: Token): RBraceToken;
 export declare function isStringToken(token?: Token): token is StringToken;
 export declare function assertStringToken(token?: Token): asserts token is StringToken;
 export declare function asStringToken(token?: Token): StringToken;
+export declare function isRegexpShorthandToken(token?: Token): token is RegexpShorthandToken;
+export declare function assertRegexpShorthandToken(token?: Token): asserts token is RegexpShorthandToken;
+export declare function asRegexpShorthandToken(token?: Token): RegexpShorthandToken;
 export declare function isAlgebraicNotationToken(token?: Token): token is AlgebraicNotationToken;
 export declare function assertAlgebraicNotationToken(token?: Token): asserts token is AlgebraicNotationToken;
 export declare function asAlgebraicNotationToken(token?: Token): AlgebraicNotationToken;

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

@@ -1,5 +1,5 @@
 import type { Tokenizer } from '../interface';
-import type { P_CollectionAccessorToken, P_CommentToken, P_FnShorthandToken, P_ModifierToken, P_NumberToken, P_RegexpShorthandToken, P_ReservedSymbolToken, P_StringShorthandToken, P_SymbolToken, P_WhitespaceToken } from './polishTokens';
+import type { P_CollectionAccessorToken, P_CommentToken, P_FnShorthandToken, P_ModifierToken, P_NumberToken, P_ReservedSymbolToken, P_StringShorthandToken, P_SymbolToken, P_WhitespaceToken } from './polishTokens';
 export declare const tokenizeP_Comment: Tokenizer<P_CommentToken>;
 export declare const tokenizeP_Whitespace: Tokenizer<P_WhitespaceToken>;
 export declare const tokenizeP_Number: Tokenizer<P_NumberToken>;
@@ -10,5 +10,4 @@ export declare const tokenizeP_FnShorthand: Tokenizer<P_FnShorthandToken>;
 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_ModifierToken>, Tokenizer<P_SymbolToken>, 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<import("../common/commonTokens").RegexpShorthandToken>, Tokenizer<P_StringShorthandToken>, Tokenizer<P_NumberToken>, Tokenizer<P_ReservedSymbolToken>, Tokenizer<P_ModifierToken>, Tokenizer<P_SymbolToken>, Tokenizer<P_FnShorthandToken>, Tokenizer<P_CollectionAccessorToken>];

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

@@ -5,9 +5,9 @@ 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"];
-export declare const polishOnlyValueTokenTypes: ["P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_RegexpShorthand", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export declare const polishValueTokenTypes: readonly ["String", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_RegexpShorthand", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export declare const polishTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand", "String", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_RegexpShorthand", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
+export declare const polishOnlyValueTokenTypes: ["P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
+export declare const polishValueTokenTypes: readonly ["String", "RegexpShorthand", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
+export declare const polishTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand", "String", "RegexpShorthand", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
 export type PolishSimpleTokenType = typeof polishSimpleTokenTypes[number];
 export type PolishValueTokenType = typeof polishValueTokenTypes[number];
 export type PolishTokenType = typeof polishTokenTypes[number];
@@ -18,13 +18,12 @@ export type P_ModifierToken = GenericPolishValueToken<'P_Modifier', ModifierName
 export type P_StringShorthandToken = GenericPolishValueToken<'P_StringShorthand'>;
 export type P_SymbolToken = GenericPolishValueToken<'P_Symbol'>;
 export type P_ReservedSymbolToken = GenericPolishValueToken<'P_ReservedSymbol'>;
-export type P_RegexpShorthandToken = GenericPolishValueToken<'P_RegexpShorthand'>;
 export type P_CollectionAccessorToken = GenericPolishValueToken<'P_CollectionAccessor', '.' | '#'>;
 export type P_CommentToken = GenericPolishValueToken<'P_Comment'>;
 export type P_WhitespaceToken = GenericPolishValueToken<'P_Whitespace'>;
 export type P_NumberToken = GenericPolishValueToken<'P_Number'>;
 export type PolishOnlySimpleToken = P_FnShorthandToken;
-export type PolishOnlyValueToken = P_ModifierToken | P_StringShorthandToken | P_SymbolToken | P_ReservedSymbolToken | P_RegexpShorthandToken | P_CollectionAccessorToken | P_CommentToken | P_WhitespaceToken | P_NumberToken;
+export type PolishOnlyValueToken = P_ModifierToken | P_StringShorthandToken | P_SymbolToken | P_ReservedSymbolToken | P_CollectionAccessorToken | P_CommentToken | P_WhitespaceToken | P_NumberToken;
 export type PolishToken = PolishOnlySimpleToken | PolishOnlyValueToken | CommonSimpleToken | CommonValueToken;
 export declare function isP_StringShorthandToken(token?: Token): token is P_StringShorthandToken;
 export declare function assertP_StringShorthandToken(token?: Token): asserts token is P_StringShorthandToken;
@@ -38,9 +37,6 @@ export declare function asP_ReservedSymbolToken(token?: Token): P_ReservedSymbol
 export declare function isP_ModifierToken(token?: Token): token is P_ModifierToken;
 export declare function assertP_ModifierToken(token?: Token): asserts token is P_ModifierToken;
 export declare function asP_ModifierToken(token?: Token): P_ModifierToken;
-export declare function isP_RegexpShorthandToken(token?: Token): token is P_RegexpShorthandToken;
-export declare function assertP_RegexpShorthandToken(token?: Token): asserts token is P_RegexpShorthandToken;
-export declare function asP_RegexpShorthandToken(token?: Token): P_RegexpShorthandToken;
 export declare function isP_FnShorthandToken(token?: Token): token is P_FnShorthandToken;
 export declare function assertP_FnShorthandToken(token?: Token): asserts token is P_FnShorthandToken;
 export declare function asP_FnShorthandToken(token?: Token): P_FnShorthandToken;

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

@@ -2,8 +2,8 @@ import type { CommonSimpleToken, CommonValueToken } from './common/commonTokens'
 import type { AlgebraicOnlyValueToken } from './algebraic/algebraicTokens';
 import type { PolishOnlySimpleToken, PolishOnlyValueToken } from './polish/polishTokens';
 export declare const simpleTokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand"];
-export declare const valueTokenTypes: readonly ["String", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_RegexpShorthand", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
-export declare const tokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand", "String", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_RegexpShorthand", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
+export declare const valueTokenTypes: readonly ["String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
+export declare const tokenTypes: readonly ["LBrace", "LBracket", "LParen", "RBrace", "RBracket", "RParen", "AlgNotation", "PolNotation", "EndNotation", "P_FnShorthand", "String", "RegexpShorthand", "A_Whitespace", "A_Operator", "A_Symbol", "A_ReservedSymbol", "A_SingleLineComment", "A_MultiLineComment", "A_Number", "A_BasePrefixedNumber", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_CollectionAccessor", "P_Comment", "P_Whitespace", "P_Number"];
 export type TokenType = typeof tokenTypes[number];
 export type SimpleToken = CommonSimpleToken | PolishOnlySimpleToken;
 export type ValueToken = CommonValueToken | AlgebraicOnlyValueToken | PolishOnlyValueToken;