@mojir/lits 1.3.0 → 2.0.2

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

@@ -0,0 +1,13 @@
+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';
+export declare const tokenizeP_Comment: Tokenizer<P_CommentToken>;
+export declare const tokenizeP_Whitespace: Tokenizer<P_WhitespaceToken>;
+export declare const tokenizeP_Number: Tokenizer<P_NumberToken>;
+export declare const P_symbolRegExp: RegExp;
+export declare const tokenizeP_Symbol: Tokenizer<P_SymbolToken>;
+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_SymbolToken>, Tokenizer<P_ModifierToken>, Tokenizer<P_RegexpShorthandToken>, Tokenizer<P_FnShorthandToken>, Tokenizer<P_CollectionAccessorToken>];

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

@@ -0,0 +1,59 @@
+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 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 type PolishSimpleTokenType = typeof polishSimpleTokenTypes[number];
+export type PolishValueTokenType = typeof polishValueTokenTypes[number];
+export type PolishTokenType = typeof polishTokenTypes[number];
+type GenericPolishSimpleToken<T extends Exclude<PolishSimpleTokenType, CommonSimpleTokenType>> = [T] | [T, TokenDebugData];
+type GenericPolishValueToken<T extends Exclude<PolishValueTokenType, CommonValueTokenType>, V extends string = string> = [T, V] | [T, V, TokenDebugData];
+export type P_FnShorthandToken = GenericPolishSimpleToken<'P_FnShorthand'>;
+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 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;
+export declare function asP_StringShorthandToken(token?: Token): P_StringShorthandToken;
+export declare function isP_SymbolToken(token?: Token): token is P_SymbolToken;
+export declare function assertP_SymbolToken(token?: Token): asserts token is P_SymbolToken;
+export declare function asP_SymbolToken(token?: Token): P_SymbolToken;
+export declare function isP_ReservedSymbolToken(token?: Token): token is P_ReservedSymbolToken;
+export declare function assertP_ReservedSymbolToken(token?: Token): asserts token is P_ReservedSymbolToken;
+export declare function asP_ReservedSymbolToken(token?: Token): P_ReservedSymbolToken;
+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;
+export declare function isP_CollectionAccessorToken(token?: Token): token is P_CollectionAccessorToken;
+export declare function assertP_CollectionAccessorToken(token?: Token): asserts token is P_CollectionAccessorToken;
+export declare function asP_CollectionAccessorToken(token?: Token): P_CollectionAccessorToken;
+export declare function isP_CommentToken(token?: Token): token is P_CommentToken;
+export declare function assertP_CommentToken(token?: Token): asserts token is P_CommentToken;
+export declare function asP_CommentToken(token?: Token): P_CommentToken;
+export declare function isP_WhitespaceToken(token?: Token): token is P_WhitespaceToken;
+export declare function assertP_WhitespaceToken(token?: Token): asserts token is P_WhitespaceToken;
+export declare function asP_WhitespaceToken(token?: Token): P_WhitespaceToken;
+export declare function isP_NumberToken(token?: Token): token is P_NumberToken;
+export declare function assertP_NumberToken(token?: Token): asserts token is P_NumberToken;
+export declare function asP_NumberToken(token?: Token): P_NumberToken;
+export {};

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

@@ -0,0 +1,20 @@
+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", "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", "P_Modifier", "P_StringShorthand", "P_Symbol", "P_ReservedSymbol", "P_RegexpShorthand", "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;
+export type Token = SimpleToken | ValueToken;
+export declare function isTokenType(type: string): type is TokenType;
+export declare function isToken(token?: Token): token is Token;
+export declare function assertToken(token?: Token): asserts token is Token;
+export declare function asToken(token?: Token): Token;
+export declare function isSimpleToken(token?: Token): token is SimpleToken;
+export declare function assertSimpleToken(token?: Token): asserts token is SimpleToken;
+export declare function asSimpleToken(token?: Token): SimpleToken;
+export declare function isValueToken(token?: Token): token is ValueToken;
+export declare function assertValueToken(token?: Token): asserts token is ValueToken;
+export declare function asValueToken(token?: Token): ValueToken;

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

@@ -0,0 +1,9 @@
+import type { SourceCodeInfo } from './interface';
+import type { Token, TokenType } from './tokens';
+export type TokenDebugData = {
+    sourceCodeInfo: SourceCodeInfo;
+};
+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;

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

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

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

@@ -1,11 +1,11 @@
-import type { AstNode, ExpressionNode, NameNode, NormalExpressionNode, NormalExpressionNodeWithName } from '../parser/interface';
+import type { AstNode, ExpressionNode, NormalExpressionNode, NormalExpressionNodeWithName, SymbolNode } from '../parser/interface';
 import type { SourceCodeInfo } from '../tokenizer/interface';
 export declare function isAstNode(value: unknown): value is AstNode;
 export declare function asAstNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): AstNode;
 export declare function assertAstNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is AstNode;
-export declare function isNameNode(value: unknown): value is NameNode;
-export declare function asNameNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): NameNode;
-export declare function assertNameNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is NameNode;
+export declare function isSymbolNode(value: unknown): value is SymbolNode;
+export declare function asSymbolNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): SymbolNode;
+export declare function assertSymbolNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is SymbolNode;
 export declare function isNormalExpressionNode(value: unknown): value is NormalExpressionNode;
 export declare function asNormalExpressionNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): NormalExpressionNode;
 export declare function assertNormalExpressionNode(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is NormalExpressionNode;

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

@@ -10,7 +10,6 @@ export declare function assertNumberOfParams(count: Count, node: GenericNode): v
 export declare function isNonUndefined<T>(value: T | undefined): value is T;
 export declare function asNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): T;
 export declare function assertNonUndefined<T>(value: T | undefined, sourceCodeInfo?: SourceCodeInfo): asserts value is T;
-export declare function assertUnreachable(_: never): never;
 export declare function isUnknownRecord(value: unknown): value is Record<string, unknown>;
 export declare function assertUnknownRecord(value: unknown, sourceCodeInfo?: SourceCodeInfo): asserts value is UnknownRecord;
 export declare function asUnknownRecord(value: unknown, sourceCodeInfo?: SourceCodeInfo): UnknownRecord;

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

@@ -0,0 +1,2 @@
+import type { TokenStream } from '../tokenizer/interface';
+export declare function untokenize(tokenStream: TokenStream): string;

package/dist/src/utils/debug/debugTools.d.ts

@@ -1,3 +1 @@
-import type { SourceCodeInfo } from '../../tokenizer/interface';
 export declare function valueToString(value: unknown): string;
-export declare function getCodeMarker(sourceCodeInfo: SourceCodeInfo): string;

package/dist/src/utils/debug/getCodeMarker.d.ts

@@ -0,0 +1,2 @@
+import type { SourceCodeInfo } from '../../tokenizer/interface';
+export declare function getCodeMarker(sourceCodeInfo: SourceCodeInfo): string;