@artel/artc 0.6.26017 → 0.6.26019

package/build/types/tree/{Nodes.d.ts → a/Nodes.d.ts}

@@ -1,9 +1,11 @@
-import { PackageDialect, PackageLocale, Query, Range } from '../common/index.js';
-import { ParserDiagnostic } from '../parser/ParserDiagnostic.js';
-import { BaseNode, Keyword, Token } from './BaseNode.js';
+import { PackageDialect, PackageLocale, Query, Range } from '../../common/index.js';
+import { ParserDiagnostic } from '../../parser/ParserDiagnostic.js';
+import { BaseNode } from './BaseNode.js';
+import { KeywordFlags } from './KeywordFlags.js';
 import { KeywordKind } from './KeywordKind.js';
 import { NodeKind } from './NodeKind.js';
 import { NodesWithChild } from './NodesDebug.js';
+import { Token } from './Token.js';
 import { TokenKind } from './TokenKind.js';
 export type Comma = Token<TokenKind.Comma>;
 export type Semicolon = Token<TokenKind.Semicolon>;
@@ -27,10 +29,20 @@ export declare class SourceFile extends BaseNode {
     get packageImportDirectiveList(): PackageImportDirectiveList;
     get declarationList(): PackageMemberDeclarationList;
     get endOfFileToken(): Token<TokenKind.EndOfFile>;
-    getSourceCode(): string;
     protected get thisAsNode(): Node;
     constructor(packageImportDirectiveList: PackageImportDirectiveList, declarationList: PackageMemberDeclarationList, endOfFileToken: Token<TokenKind.EndOfFile>, locale: PackageLocale, dialect: PackageDialect, diagnostics: readonly ParserDiagnostic[], rangeWithTrivia: Range | undefined);
 }
+export declare class Keyword<TKind extends KeywordKind = KeywordKind> extends BaseNode {
+    readonly kind = NodeKind.Keyword;
+    readonly children: readonly Identifier[];
+    readonly keywordKind: TKind;
+    readonly flags: KeywordFlags;
+    get parent(): Node;
+    get tokens(): readonly Identifier[];
+    get isMissing(): boolean;
+    protected get thisAsNode(): Node;
+    constructor(tokens: readonly Identifier[], keywordKind: TKind, flags: KeywordFlags | undefined, rangeWithTrivia: Range | undefined);
+}
 export type PackageMemberDeclarationListElement = PackageMemberDeclaration | Semicolon;
 export type PackageMemberDeclarationListParent = SourceFile | PackageMemberGroupDeclaration;
 export declare class PackageMemberDeclarationList extends BaseNode {
@@ -41,6 +53,7 @@ export declare class PackageMemberDeclarationList extends BaseNode {
     get declarations(): Query<PackageMemberDeclaration>;
     protected get thisAsNode(): Node;
     constructor(elements: readonly PackageMemberDeclarationListElement[], rangeWithTrivia: Range | undefined);
+    flatten(): Iterable<Exclude<PackageMemberDeclaration, PackageMemberGroupDeclaration>>;
 }
 export type PackageImportDirectiveListElement = PackageImportDirective | Semicolon;
 export declare class PackageImportDirectiveList extends BaseNode {
@@ -51,6 +64,7 @@ export declare class PackageImportDirectiveList extends BaseNode {
     get packageImportDirectives(): Query<PackageImportDirective>;
     protected get thisAsNode(): Node;
     constructor(elements: readonly PackageImportDirectiveListElement[], rangeWithTrivia: Range | undefined);
+    flatten(): Iterable<PackageImport>;
 }
 export type PackageImportDirective = SinglePackageImportDirective | PackageGroupImportDirective;
 export declare class SinglePackageImportDirective extends BaseNode {
@@ -344,6 +358,7 @@ export declare class TypeMemberDeclarationList extends BaseNode {
     get members(): Query<TypeMemberDeclaration>;
     protected get thisAsNode(): Node;
     constructor(elements: readonly TypeMemberDeclarationListElement[], rangeWithTrivia: Range | undefined);
+    flatten(): Iterable<Exclude<TypeMemberDeclaration, TypeMemberGroupDeclaration>>;
 }
 export type TypeMemberDeclarationBlockParent = PackageClassDeclaration | PackageStructureDeclaration | PackageAspectDeclaration | PackageReducedTypeDeclaration | PackageVariantDeclaration | AnonymousClassDeclaration | PackageAliasTypeDeclaration | TypeExtensionDeclaration | TypeMemberGroupDeclaration;
 export declare class TypeMemberDeclarationBlock extends BaseNode {
@@ -897,7 +912,12 @@ export declare class ForStatementVariableDeclaration extends BaseNode {
 export type Expression = ArrayLiteral | AsExpression | AssertionExpression | AssumptionExpression | BinaryExpression | FunctionLiteral | FunctionBlockLiteral | CallExpression | IdentifierExpression | AutotypeCallExpression | IndexedAccessExpression | MissingExpression | IsExpression | ParenthesizedExpression | ConditionalExpression | PrefixUnaryExpression | MemberAccessExpression | ReferenceExpression | DereferenceExpression | TextLiteral | LocalizableTextLiteral | TextTemplateLiteral | LocalizableTextTemplateLiteral | GenericSpecializationExpression | DefaultMatchExpression | TokenExpression | KeywordExpression | ObjectExpression | BaseExpression | OwnConstructorCallExpression;
 export type ExpressionParent = ArrayLiteralElementList | AsExpression | AssertionExpression | AssumptionExpression | AssignmentStatement | BinaryExpression | Argument | CallExpression | DisposeStatement | ErrorStatement | ImportantStatement | ExpressionStatement | ForStatement | PackageVariableDeclaration | IfStatement | IndexedAccessExpression | IsExpression | LocalVariableDeclaration | MatchExpressionList | ParameterDeclaration | ParenthesizedExpression | ConditionalExpression | PrefixUnaryExpression | MemberAccessExpression | ReferenceExpression | DereferenceExpression | LoopStatement | ReturnStatement | TextTemplateSpan | FieldDeclaration | SwitchStatement | VariantValueDeclaration | WhileStatement | YieldStatement | GenericSpecializationExpression | ElseIfClause | TextTranslationDeclaration;
 export type ExpressionListElement = Expression | Comma;
-export declare class ArrayLiteral extends BaseNode {
+declare abstract class BaseExpressionNode extends BaseNode {
+    protected abstract get thisAsNode(): Expression;
+    unwrapParenthesizedExpressions(): Expression;
+    getParentSkippingParenthesizedExpressions(): ExpressionParent;
+}
+export declare class ArrayLiteral extends BaseExpressionNode {
     readonly kind = NodeKind.ArrayLiteral;
     readonly children: readonly [
         Token<TokenKind.OpenSquareBracket>,
@@ -908,7 +928,7 @@ export declare class ArrayLiteral extends BaseNode {
     get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
     get elementList(): ArrayLiteralElementList;
     get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, elementList: ArrayLiteralElementList, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>, rangeWithTrivia: Range | undefined);
 }
 export declare class ArrayLiteralElementList extends BaseNode {
@@ -920,7 +940,7 @@ export declare class ArrayLiteralElementList extends BaseNode {
     protected get thisAsNode(): Node;
     constructor(elements: readonly ExpressionListElement[], rangeWithTrivia: Range | undefined);
 }
-export declare class AssertionExpression extends BaseNode {
+export declare class AssertionExpression extends BaseExpressionNode {
     readonly kind = NodeKind.AssertionExpression;
     readonly children: readonly [
         Expression,
@@ -929,10 +949,10 @@ export declare class AssertionExpression extends BaseNode {
     get parent(): ExpressionParent;
     get expression(): Expression;
     get exclamationToken(): Token<TokenKind.Exclamation>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, exclamationToken: Token<TokenKind.Exclamation>, rangeWithTrivia: Range | undefined);
 }
-export declare class AssumptionExpression extends BaseNode {
+export declare class AssumptionExpression extends BaseExpressionNode {
     readonly kind = NodeKind.AssumptionExpression;
     readonly children: readonly [
         Expression,
@@ -941,10 +961,10 @@ export declare class AssumptionExpression extends BaseNode {
     get parent(): ExpressionParent;
     get expression(): Expression;
     get questionToken(): Token<TokenKind.Question>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, questionToken: Token<TokenKind.Question>, rangeWithTrivia: Range | undefined);
 }
-export declare class AsExpression extends BaseNode {
+export declare class AsExpression extends BaseExpressionNode {
     readonly kind = NodeKind.AsExpression;
     readonly children: readonly [
         Expression,
@@ -955,10 +975,10 @@ export declare class AsExpression extends BaseNode {
     get expression(): Expression;
     get asKeyword(): Keyword<KeywordKind.As>;
     get typeSpecifier(): TypeSpecifier;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, asKeyword: Keyword<KeywordKind.As>, typeSpecifier: TypeSpecifier, rangeWithTrivia: Range | undefined);
 }
-export declare class BinaryExpression extends BaseNode {
+export declare class BinaryExpression extends BaseExpressionNode {
     readonly kind = NodeKind.BinaryExpression;
     readonly children: readonly [
         Expression,
@@ -969,11 +989,11 @@ export declare class BinaryExpression extends BaseNode {
     get left(): Expression;
     get operator(): BinaryExpressionOperator;
     get right(): Expression;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(left: Expression, operator: BinaryExpressionOperator, right: Expression, rangeWithTrivia: Range | undefined);
 }
-export type BinaryExpressionOperator = Token<TokenKind.Plus> | Token<TokenKind.Minus> | Token<TokenKind.Asterisk> | Token<TokenKind.Slash> | Token<TokenKind.Percent> | Token<TokenKind.EqualsEquals> | Token<TokenKind.ExclamationEquals> | Token<TokenKind.LessThan> | Token<TokenKind.GreaterThan> | Token<TokenKind.LessThanOrEqual> | Token<TokenKind.GreaterThanOrEqual> | Token<TokenKind.QuestionQuestion> | Keyword<KeywordKind.Or> | Keyword<KeywordKind.And> | Keyword<KeywordKind.Xor> | Token<TokenKind.Ampersand> | Token<TokenKind.Bar> | Token<TokenKind.BarBar> | Token<TokenKind.LessThanLessThan> | Token<TokenKind.GreaterThanGreaterThan> | Token<TokenKind.GreaterThanGreaterThanGreaterThan>;
-export declare class FunctionLiteral extends BaseNode {
+export type BinaryExpressionOperator = Token<TokenKind.Plus> | Token<TokenKind.Minus> | Token<TokenKind.Asterisk> | Token<TokenKind.Slash> | Token<TokenKind.Percent> | Token<TokenKind.EqualsEquals> | Token<TokenKind.ExclamationEquals> | Token<TokenKind.LessThan> | Token<TokenKind.GreaterThan> | Token<TokenKind.LessThanOrEqual> | Token<TokenKind.GreaterThanOrEqual> | Token<TokenKind.QuestionQuestion> | Keyword<KeywordKind.Or> | Keyword<KeywordKind.And> | Keyword<KeywordKind.Xor> | Token<TokenKind.Ampersand> | Token<TokenKind.Bar> | Token<TokenKind.BarBar> | Token<TokenKind.BarLessThan> | Token<TokenKind.BarGreaterThan> | Token<TokenKind.BarGreaterThanGreaterThan>;
+export declare class FunctionLiteral extends BaseExpressionNode {
     readonly kind = NodeKind.FunctionLiteral;
     readonly children: readonly [
         Keyword<KeywordKind.Async> | undefined,
@@ -988,17 +1008,17 @@ export declare class FunctionLiteral extends BaseNode {
     get parameterClause(): ParameterClause;
     get returnTypeAnnotation(): TypeAnnotation | undefined;
     get block(): FunctionBlock;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(asyncKeyword: Keyword<KeywordKind.Async> | undefined, functionKeyword: Keyword<KeywordKind.Function>, parameterClause: ParameterClause, returnTypeAnnotation: TypeAnnotation | undefined, block: FunctionBlock, rangeWithTrivia: Range | undefined);
 }
-export declare class FunctionBlockLiteral extends BaseNode {
+export declare class FunctionBlockLiteral extends BaseExpressionNode {
     readonly kind = NodeKind.FunctionBlockLiteral;
     readonly children: readonly [
         FunctionBlock
     ];
     get parent(): ExpressionParent;
     get block(): FunctionBlock;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(block: FunctionBlock, rangeWithTrivia: Range | undefined);
 }
 export type ArgumentListElement = Argument | Comma;
@@ -1012,7 +1032,7 @@ export declare class ArgumentList extends BaseNode {
     protected get thisAsNode(): Node;
     constructor(elements: readonly ArgumentListElement[], rangeWithTrivia: Range | undefined);
 }
-export declare class CallExpression extends BaseNode {
+export declare class CallExpression extends BaseExpressionNode {
     readonly kind = NodeKind.CallExpression;
     readonly children: readonly [
         Expression,
@@ -1025,10 +1045,10 @@ export declare class CallExpression extends BaseNode {
     get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
     get argumentList(): ArgumentList;
     get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, openParenthesisToken: Token<TokenKind.OpenParenthesis>, argumentList: ArgumentList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
 }
-export declare class AutotypeCallExpression extends BaseNode {
+export declare class AutotypeCallExpression extends BaseExpressionNode {
     readonly kind = NodeKind.AutotypeCallExpression;
     readonly children: readonly [
         Keyword<KeywordKind.Autotype>,
@@ -1041,10 +1061,10 @@ export declare class AutotypeCallExpression extends BaseNode {
     get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
     get argumentList(): ArgumentList;
     get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(autotypeKeyword: Keyword<KeywordKind.Autotype>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, argumentList: ArgumentList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
 }
-export declare class IndexedAccessExpression extends BaseNode {
+export declare class IndexedAccessExpression extends BaseExpressionNode {
     readonly kind = NodeKind.IndexedAccessExpression;
     readonly children: readonly [
         Expression,
@@ -1057,17 +1077,17 @@ export declare class IndexedAccessExpression extends BaseNode {
     get openSquareBracketToken(): Token<TokenKind.OpenSquareBracket>;
     get argumentList(): ArgumentList;
     get closeSquareBracketToken(): Token<TokenKind.CloseSquareBracket>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, openSquareBracketToken: Token<TokenKind.OpenSquareBracket>, argumentList: ArgumentList, closeSquareBracketToken: Token<TokenKind.CloseSquareBracket>, rangeWithTrivia: Range | undefined);
 }
-export declare class MissingExpression extends BaseNode {
+export declare class MissingExpression extends BaseExpressionNode {
     readonly kind = NodeKind.MissingExpression;
     get children(): readonly [];
     get parent(): ExpressionParent;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(rangeWithTrivia: Range | undefined);
 }
-export declare class IsExpression extends BaseNode {
+export declare class IsExpression extends BaseExpressionNode {
     readonly kind = NodeKind.IsExpression;
     readonly children: readonly [
         Expression,
@@ -1078,10 +1098,10 @@ export declare class IsExpression extends BaseNode {
     get expression(): Expression;
     get isKeyword(): Keyword<KeywordKind.Is>;
     get typeSpecifier(): TypeSpecifier;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, isKeyword: Keyword<KeywordKind.Is>, typeSpecifier: TypeSpecifier, rangeWithTrivia: Range | undefined);
 }
-export declare class ParenthesizedExpression extends BaseNode {
+export declare class ParenthesizedExpression extends BaseExpressionNode {
     readonly kind = NodeKind.ParenthesizedExpression;
     readonly children: readonly [
         Token<TokenKind.OpenParenthesis>,
@@ -1092,10 +1112,10 @@ export declare class ParenthesizedExpression extends BaseNode {
     get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
     get expression(): Expression;
     get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
 }
-export declare class ConditionalExpression extends BaseNode {
+export declare class ConditionalExpression extends BaseExpressionNode {
     readonly kind = NodeKind.ConditionalExpression;
     readonly children: readonly [
         Keyword<KeywordKind.Cond>,
@@ -1116,10 +1136,10 @@ export declare class ConditionalExpression extends BaseNode {
     get secondCommaToken(): Comma | undefined;
     get secondExpression(): Expression | undefined;
     get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(condKeyword: Keyword<KeywordKind.Cond>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, condition: Expression, firstCommaToken: Comma, firstExpression: Expression, secondCommaToken: Comma | undefined, secondExpression: Expression | undefined, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
 }
-export declare class PrefixUnaryExpression extends BaseNode {
+export declare class PrefixUnaryExpression extends BaseExpressionNode {
     readonly kind = NodeKind.PrefixUnaryExpression;
     readonly children: readonly [
         PrefixUnaryExpressionOperator,
@@ -1128,11 +1148,11 @@ export declare class PrefixUnaryExpression extends BaseNode {
     get parent(): ExpressionParent;
     get operator(): PrefixUnaryExpressionOperator;
     get operand(): Expression;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(operator: PrefixUnaryExpressionOperator, operand: Expression, rangeWithTrivia: Range | undefined);
 }
 export type PrefixUnaryExpressionOperator = Token<TokenKind.Plus> | Token<TokenKind.Minus> | Keyword<KeywordKind.Not>;
-export declare class MemberAccessExpression extends BaseNode {
+export declare class MemberAccessExpression extends BaseExpressionNode {
     readonly kind = NodeKind.MemberAccessExpression;
     readonly children: readonly [
         Expression,
@@ -1143,10 +1163,10 @@ export declare class MemberAccessExpression extends BaseNode {
     get expression(): Expression;
     get dotToken(): Token<TokenKind.Dot>;
     get memberName(): Identifier;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, dotToken: Token<TokenKind.Dot>, memberName: Identifier, rangeWithTrivia: Range | undefined);
 }
-export declare class ReferenceExpression extends BaseNode {
+export declare class ReferenceExpression extends BaseExpressionNode {
     readonly kind = NodeKind.ReferenceExpression;
     readonly children: readonly [
         Keyword<KeywordKind.Reference>,
@@ -1159,10 +1179,10 @@ export declare class ReferenceExpression extends BaseNode {
     get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
     get expression(): Expression;
     get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(referenceKeyword: Keyword<KeywordKind.Reference>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, expression: Expression, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
 }
-export declare class DereferenceExpression extends BaseNode {
+export declare class DereferenceExpression extends BaseExpressionNode {
     readonly kind = NodeKind.DereferenceExpression;
     readonly children: readonly [
         Expression,
@@ -1171,10 +1191,10 @@ export declare class DereferenceExpression extends BaseNode {
     get parent(): ExpressionParent;
     get expression(): Expression;
     get caretToken(): Token<TokenKind.Caret>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, caretToken: Token<TokenKind.Caret>, rangeWithTrivia: Range | undefined);
 }
-export declare class TextTemplateLiteral extends BaseNode {
+export declare class TextTemplateLiteral extends BaseExpressionNode {
     readonly kind = NodeKind.TextTemplateLiteral;
     readonly children: readonly [
         TextTemplateHead,
@@ -1183,10 +1203,10 @@ export declare class TextTemplateLiteral extends BaseNode {
     get parent(): ExpressionParent;
     get head(): TextTemplateHead;
     get spanList(): TextTemplateSpanList;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(head: TextTemplateHead, spanList: TextTemplateSpanList, rangeWithTrivia: Range | undefined);
 }
-export declare class LocalizableTextTemplateLiteral extends BaseNode {
+export declare class LocalizableTextTemplateLiteral extends BaseExpressionNode {
     readonly kind = NodeKind.LocalizableTextTemplateLiteral;
     readonly children: readonly [
         TextTemplateHead,
@@ -1197,7 +1217,7 @@ export declare class LocalizableTextTemplateLiteral extends BaseNode {
     get head(): TextTemplateHead;
     get spanList(): TextTemplateSpanList;
     get code(): Token<TokenKind.IntegerLiteral> | undefined;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(head: TextTemplateHead, spanList: TextTemplateSpanList, code: Token<TokenKind.IntegerLiteral> | undefined, rangeWithTrivia: Range | undefined);
 }
 export type TextTemplateSpanListParent = TextTemplateLiteral | LocalizableTextTemplateLiteral;
@@ -1224,28 +1244,28 @@ export declare class TextTemplateSpan extends BaseNode {
     protected get thisAsNode(): Node;
     constructor(expression: Expression, text: TextTemplatePart | TextTemplateTail, rangeWithTrivia: Range | undefined);
 }
-export declare class TokenExpression extends BaseNode {
+export declare class TokenExpression extends BaseExpressionNode {
     readonly kind = NodeKind.TokenExpression;
     readonly children: readonly [
         TokenExpressionToken
     ];
     get parent(): ExpressionParent;
     get token(): TokenExpressionToken;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(token: TokenExpressionToken, rangeWithTrivia: Range | undefined);
 }
 export type TokenExpressionToken = Token<TokenKind.IntegerLiteral> | Token<TokenKind.RealLiteral> | Token<TokenKind.MeasureLiteral>;
-export declare class TextLiteral extends BaseNode {
+export declare class TextLiteral extends BaseExpressionNode {
     readonly kind = NodeKind.TextLiteral;
     readonly children: readonly [
         Token<TokenKind.TextLiteral>
     ];
     get parent(): ExpressionParent;
     get text(): Token<TokenKind.TextLiteral>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(text: Token<TokenKind.TextLiteral>, rangeWithTrivia: Range | undefined);
 }
-export declare class LocalizableTextLiteral extends BaseNode {
+export declare class LocalizableTextLiteral extends BaseExpressionNode {
     readonly kind = NodeKind.LocalizableTextLiteral;
     readonly children: readonly [
         Token<TokenKind.TextLiteral>,
@@ -1254,51 +1274,51 @@ export declare class LocalizableTextLiteral extends BaseNode {
     get parent(): ExpressionParent;
     get text(): Token<TokenKind.TextLiteral>;
     get code(): Token<TokenKind.IntegerLiteral> | undefined;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(text: Token<TokenKind.TextLiteral>, code: Token<TokenKind.IntegerLiteral> | undefined, rangeWithTrivia: Range | undefined);
 }
-export declare class KeywordExpression extends BaseNode {
+export declare class KeywordExpression extends BaseExpressionNode {
     readonly kind = NodeKind.KeywordExpression;
     readonly children: readonly [
         KeywordExpressionKeyword
     ];
     get parent(): ExpressionParent;
     get keyword(): KeywordExpressionKeyword;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(keyword: KeywordExpressionKeyword, rangeWithTrivia: Range | undefined);
 }
 export type KeywordExpressionKeyword = Keyword<KeywordKind.Yes> | Keyword<KeywordKind.No> | Keyword<KeywordKind.Null>;
-export declare class ObjectExpression extends BaseNode {
+export declare class ObjectExpression extends BaseExpressionNode {
     readonly kind = NodeKind.ObjectExpression;
     readonly children: readonly [
         ObjectKeyword
     ];
     get parent(): ExpressionParent;
     get keyword(): ObjectKeyword;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(keyword: ObjectKeyword, rangeWithTrivia: Range | undefined);
 }
-export declare class BaseExpression extends BaseNode {
+export declare class BaseExpression extends BaseExpressionNode {
     readonly kind = NodeKind.BaseExpression;
     readonly children: readonly [
         Keyword<KeywordKind.Base>
     ];
     get parent(): ExpressionParent;
     get keyword(): Keyword<KeywordKind.Base>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(keyword: Keyword<KeywordKind.Base>, rangeWithTrivia: Range | undefined);
 }
-export declare class IdentifierExpression extends BaseNode {
+export declare class IdentifierExpression extends BaseExpressionNode {
     readonly kind = NodeKind.IdentifierExpression;
     readonly children: readonly [
         Identifier
     ];
     get parent(): ExpressionParent;
     get identifier(): Identifier;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(identifier: Identifier, rangeWithTrivia: Range | undefined);
 }
-export declare class GenericSpecializationExpression extends BaseNode {
+export declare class GenericSpecializationExpression extends BaseExpressionNode {
     readonly kind = NodeKind.GenericSpecializationExpression;
     readonly children: readonly [
         Expression,
@@ -1307,20 +1327,20 @@ export declare class GenericSpecializationExpression extends BaseNode {
     get parent(): ExpressionParent;
     get expression(): Expression;
     get typeArgumentClause(): TypeArgumentClause;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(expression: Expression, typeArgumentClause: TypeArgumentClause, rangeWithTrivia: Range | undefined);
 }
-export declare class DefaultMatchExpression extends BaseNode {
+export declare class DefaultMatchExpression extends BaseExpressionNode {
     readonly kind = NodeKind.DefaultMatchExpression;
     readonly children: readonly [
         Token<TokenKind.Asterisk>
     ];
     get parent(): ExpressionParent;
     get asteriskToken(): Token<TokenKind.Asterisk>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(asteriskToken: Token<TokenKind.Asterisk>, rangeWithTrivia: Range | undefined);
 }
-export declare class OwnConstructorCallExpression extends BaseNode {
+export declare class OwnConstructorCallExpression extends BaseExpressionNode {
     readonly kind = NodeKind.OwnConstructorCallExpression;
     readonly children: readonly [
         Keyword<KeywordKind.Creation>,
@@ -1333,7 +1353,7 @@ export declare class OwnConstructorCallExpression extends BaseNode {
     get openParenthesisToken(): Token<TokenKind.OpenParenthesis>;
     get argumentList(): ArgumentList;
     get closeParenthesisToken(): Token<TokenKind.CloseParenthesis>;
-    protected get thisAsNode(): Node;
+    protected get thisAsNode(): Expression;
     constructor(creationKeyword: Keyword<KeywordKind.Creation>, openParenthesisToken: Token<TokenKind.OpenParenthesis>, argumentList: ArgumentList, closeParenthesisToken: Token<TokenKind.CloseParenthesis>, rangeWithTrivia: Range | undefined);
 }
 export type Statement = AssignmentStatement | RunStatement | TryStatement | IfStatement | ForStatement | WhileStatement | LoopStatement | ReturnStatement | ErrorStatement | LocalVariableDeclarationStatement | YieldStatement | MissingStatement | ImportantStatement | ExpressionStatement | SwitchStatement | BreakLoopStatement | ContinueLoopStatement | DisposeStatement | NestedFunctionDeclarationStatement;
@@ -1351,7 +1371,7 @@ export declare class AssignmentStatement extends BaseNode {
     protected get thisAsNode(): Node;
     constructor(left: Expression, operator: AssignmentStatementOperator, right: Expression, rangeWithTrivia: Range | undefined);
 }
-export type AssignmentStatementOperator = Token<TokenKind.Equals> | Token<TokenKind.PlusEquals> | Token<TokenKind.MinusEquals> | Token<TokenKind.AsteriskEquals> | Token<TokenKind.SlashEquals> | Token<TokenKind.PercentEquals> | Token<TokenKind.AmpersandEquals> | Token<TokenKind.BarEquals> | Token<TokenKind.BarBarEquals> | Token<TokenKind.LessThanLessThanEquals> | Token<TokenKind.GreaterThanGreaterThanEquals> | Token<TokenKind.GreaterThanGreaterThanGreaterThanEquals>;
+export type AssignmentStatementOperator = Token<TokenKind.Equals> | Token<TokenKind.PlusEquals> | Token<TokenKind.MinusEquals> | Token<TokenKind.AsteriskEquals> | Token<TokenKind.SlashEquals> | Token<TokenKind.PercentEquals> | Token<TokenKind.AmpersandEquals> | Token<TokenKind.BarEquals> | Token<TokenKind.BarBarEquals> | Token<TokenKind.BarLessThanEquals> | Token<TokenKind.BarGreaterThanEquals> | Token<TokenKind.BarGreaterThanGreaterThanEquals>;
 export type StatementListParent = FunctionBlock | StatementBlock;
 export type StatementListElement = Statement | Semicolon;
 export declare class StatementList extends BaseNode {
@@ -2302,3 +2322,4 @@ export declare class TypeAnnotation extends BaseNode {
     constructor(colonToken: Token<TokenKind.Colon>, typeSpecifier: TypeSpecifier, rangeWithTrivia: Range | undefined);
 }
 export type Node = Token | Keyword | SourceFile | PackageMemberDeclarationList | PackageImportDirectiveList | SinglePackageImportDirective | PackageGroupImportDirective | PackageImportList | PackageImport | PackageName | NamedTypeSpecifier | UnionTypeSpecifier | IntersectionTypeSpecifier | ParenthesizedTypeSpecifier | NullableTypeSpecifier | AnonymousTypeSpecifier | MissingTypeSpecifier | AnonymousFunctionTypeDeclaration | PackageAliasTypeDeclaration | PackageMemberGroupDeclaration | PackageConstructorDeclaration | PackageEntryPointDeclaration | PackageFunctionDeclaration | BaseTypeList | TypeMemberDeclarationList | TypeMemberDeclarationBlock | PackageVariableDeclaration | PackageVariableGetterDeclaration | PackageVariableSetterDeclaration | TypeExtensionDeclaration | ExtendedTypeClauseCommaList | ExtendedTypeClause | MissingPackageMemberDeclaration | TypeMemberGroupDeclaration | ConstructorDeclaration | DestructorDeclaration | IndexedElementGetterDeclaration | IndexedElementSetterDeclaration | IndexParameterClause | DereferencedVariableGetterDeclaration | DereferencedVariableSetterDeclaration | MethodDeclaration | FieldDeclaration | FieldGetterDeclaration | FieldSetterDeclaration | MissingTypeMemberDeclaration | NestedFunctionDeclaration | LocalVariableDeclaration | ForStatementVariableDeclaration | ArrayLiteral | ArrayLiteralElementList | AssertionExpression | AssumptionExpression | AsExpression | BinaryExpression | FunctionLiteral | FunctionBlockLiteral | ArgumentList | CallExpression | AutotypeCallExpression | IndexedAccessExpression | MissingExpression | IsExpression | ParenthesizedExpression | ConditionalExpression | PrefixUnaryExpression | MemberAccessExpression | ReferenceExpression | DereferenceExpression | TextTemplateLiteral | LocalizableTextTemplateLiteral | TextTemplateSpanList | TextTemplateSpan | TokenExpression | TextLiteral | LocalizableTextLiteral | KeywordExpression | ObjectExpression | BaseExpression | IdentifierExpression | GenericSpecializationExpression | DefaultMatchExpression | OwnConstructorCallExpression | AssignmentStatement | StatementList | StatementBlock | FunctionBlock | BreakLoopStatement | ContinueLoopStatement | DisposeStatement | RunStatement | TryStatement | CatchClause | ErrorVariableDeclaration | FinallyClause | ErrorStatement | ImportantStatement | ExpressionStatement | ForStatement | IfStatement | ElseIfClauseList | ElseIfClause | ElseClause | MissingStatement | NestedFunctionDeclarationStatement | LocalVariableDeclarationStatement | LoopStatement | ReturnStatement | CaseClauseList | SwitchStatement | MatchExpressionList | CaseClause | WhileStatement | YieldStatement | TranslationsDeclaration | TopLevelTranslationList | TranslationParameterList | TranslationParameterClause | ConstructorTranslation | IndexParameterTranslationClause | IndexerTranslation | TranslationTypeParameterList | TranslationTypeParameterClause | PackageFunctionTranslationDeclaration | MethodTranslation | FunctionTypeTranslationDeclaration | QualifiedName | PackageVariableTranslationDeclaration | FieldOrVariantTranslation | TypeMemberTranslationList | TypeTranslationDeclaration | TextTranslationDeclaration | TextTranslationFunctionDeclaration | TranslationTextLiteral | TranslationTextTemplate | TranslationTextTemplateSpanList | TranslationTextTemplateSpan | TranslationTextTemplateParameter | VariantValueDeclaration | TypeParameterDeclaration | ParameterDeclaration | Argument | TagList | Tag | ModifierList | Modifier | ParameterClause | ParameterList | TypeArgumentClause | TypeArgumentList | TypeParameterClause | TypeParameterList | TypeAnnotation | PackageClassDeclaration | PackageStructureDeclaration | PackageAspectDeclaration | PackageReducedTypeDeclaration | PackageVariantDeclaration | ExtendsClause | ReducesClause | AnonymousClassDeclaration;
+export {};

package/build/types/tree/{SyntaxFactory.d.ts → a/SyntaxFactory.d.ts}

@@ -1,4 +1,8 @@
-import * as tree from './index.js';
+import { KeywordKind } from './KeywordKind.js';
+import * as tree from './Nodes.js';
+import { Token } from './Token.js';
+import { TokenFlags } from './TokenFlags.js';
+import { TokenKind } from './TokenKind.js';
 export declare class SyntaxFactory {
     static sourceFile(packageImportDirectives: readonly tree.PackageImportDirective[], declarations: readonly tree.PackageMemberDeclaration[]): tree.SourceFile;
     static singlePackageImportDirective(alias: tree.Identifier | string | undefined, pathSegments: readonly string[]): tree.SinglePackageImportDirective;
@@ -60,9 +64,9 @@ export declare class SyntaxFactory {
     static translationParameterClause(parameters: readonly (tree.Identifier | string)[]): tree.TranslationParameterClause;
     static indexParameterTranslationClause(parameters: readonly (tree.Identifier | string)[]): tree.IndexParameterTranslationClause;
     static typeMemberDeclarationWithModifiers(node: tree.TypeMemberDeclaration, modifiers: readonly tree.Modifier[] | tree.ModifierList): tree.TypeMemberDeclaration;
-    static identifier(value: tree.Identifier | string, flags?: tree.TokenFlags): tree.Identifier;
-    static token<T extends tree.TokenKind>(kind: T, value?: string): tree.Token<T>;
-    static keyword<T extends tree.KeywordKind>(kind: T): tree.Keyword<T>;
+    static identifier(value: tree.Identifier | string, flags?: TokenFlags): tree.Identifier;
+    static token<T extends TokenKind>(kind: T, value?: string): Token<T>;
+    static keyword<T extends KeywordKind>(kind: T): tree.Keyword<T>;
     private static createToken;
     private static createKeyword;
     private static createTypeParameterClause;

package/build/types/tree/{SyntaxToCode.d.ts → a/SyntaxToCode.d.ts}

@@ -1,5 +1,5 @@
-import { PackageDialect, PackageLocale } from '../common/index.js';
-import * as tree from './index.js';
+import { PackageDialect, PackageLocale } from '../../common/index.js';
+import type * as tree from './Nodes.js';
 export declare class SyntaxToCode {
     private static writeFunctions_;
     private readonly node;

package/build/types/tree/a/Token.d.ts

@@ -0,0 +1,46 @@
+import { Range } from '../../common/index.js';
+import { BaseNode } from './BaseNode.js';
+import { NodeKind } from './NodeKind.js';
+import { Node } from './Nodes.js';
+import { OperatorKind } from './OperatorKind.js';
+import { TokenFlags } from './TokenFlags.js';
+import { TokenKind } from './TokenKind.js';
+import { TriviaKind } from './TriviaKind.js';
+export declare class Token<TKind extends TokenKind = TokenKind> extends BaseNode {
+    readonly kind = NodeKind.Token;
+    readonly tokenKind: TKind;
+    readonly value: string;
+    readonly leadingTrivia: readonly Trivia[];
+    readonly trailingTrivia: readonly Trivia[];
+    readonly flags: TokenFlags;
+    readonly operatorKind: OperatorKind | undefined;
+    get children(): readonly [];
+    get parent(): Node;
+    get isMissing(): boolean;
+    protected get thisAsNode(): Node;
+    constructor(tokenKind: TKind, value: string, leadingTrivia: readonly Trivia[], trailingTrivia: readonly Trivia[], flags: TokenFlags, operatorKind: OperatorKind | undefined, rangeWithTrivia: Range | undefined);
+    get rangeWithoutTrivia(): Range;
+    getTextWithTrivia(): string;
+    hasLeadingLineBreak(): boolean;
+    hasTrailingLineBreak(): boolean;
+    getTriviaAt(position: number): TokenTrivia | undefined;
+    selectLeadingTrivia(condition: (trivia: Trivia, rangeStart: number, rangeEnd: number) => boolean): TokenTrivia[];
+    selectTrailingTrivia(condition: (trivia: Trivia, rangeStart: number, rangeEnd: number) => boolean): TokenTrivia[];
+    protected getLengthWithTrivia(): number;
+}
+export declare class Trivia {
+    readonly kind: TriviaKind;
+    readonly value: string;
+    get rangeLength(): number;
+    constructor(kind: TriviaKind, value: string);
+}
+export declare class TokenTrivia {
+    readonly trivia: Trivia;
+    readonly token: Token<TokenKind>;
+    readonly isTrailing: boolean;
+    readonly index: number;
+    readonly range: Range;
+    get kind(): TriviaKind;
+    get value(): string;
+    constructor(token: Token<TokenKind>, trivia: Trivia, isTrailing: boolean, index: number, range: Range);
+}

package/build/types/tree/a/TokenKind.d.ts

@@ -0,0 +1,74 @@
+export declare enum TokenKind {
+    Unknown = 0,
+    EndOfFile = 1,
+    IntegerLiteral = 2,
+    RealLiteral = 3,
+    MeasureLiteral = 4,
+    TextLiteral = 5,
+    TextTemplateHead = 6,
+    TextTemplatePart = 7,
+    TextTemplateTail = 8,
+    Identifier = 9,
+    Ampersand = 10,
+    AmpersandAmpersand = 11,
+    AmpersandEquals = 12,
+    Asterisk = 13,
+    AsteriskAsterisk = 14,
+    AsteriskEquals = 15,
+    BackQuote = 16,
+    Bar = 17,
+    BarBar = 18,
+    BarEquals = 19,
+    BarBarEquals = 20,
+    BarLessThan = 21,
+    BarLessThanEquals = 22,
+    BarGreaterThan = 23,
+    BarGreaterThanEquals = 24,
+    BarGreaterThanGreaterThan = 25,
+    BarGreaterThanGreaterThanEquals = 26,
+    Caret = 27,
+    CloseBrace = 28,
+    CloseParenthesis = 29,
+    CloseSquareBracket = 30,
+    Colon = 31,
+    Comma = 32,
+    CommercialAt = 33,
+    Dot = 34,
+    DoublePeriod = 35,
+    Ellipsis = 36,
+    EqualsEquals = 37,
+    Exclamation = 38,
+    ExclamationEquals = 39,
+    GreaterThan = 40,
+    GreaterThanOrEqual = 41,
+    HashSign = 42,
+    LessThan = 43,
+    LessThanOrEqual = 44,
+    LessThanMinus = 45,
+    Minus = 46,
+    MinusMinus = 47,
+    MinusEquals = 48,
+    MinusGreaterThan = 49,
+    OpenBrace = 50,
+    OpenParenthesis = 51,
+    OpenSquareBracket = 52,
+    Plus = 53,
+    PlusPlus = 54,
+    PlusEquals = 55,
+    Question = 56,
+    QuestionQuestion = 57,
+    Semicolon = 58,
+    Slash = 59,
+    SlashEquals = 60,
+    Tilde = 61,
+    TildeTilde = 62,
+    Underscore = 63,
+    Equals = 64,
+    Percent = 65,
+    PercentEquals = 66,
+    PercentPercent = 67,
+    Backslash = 68
+}
+export declare const tokenKindValues: {
+    [T in TokenKind]: string;
+};