xbintsc 0.1.6 → 0.1.8

package/README.md

@@ -56,10 +56,13 @@ delegated to `@xt_*` runtime calls.
 
 ### Runtime
 
-`runtime/xt_runtime.c` implements strings, objects, arrays, closures, arithmetic,
-comparison, exceptions and Node-like `console.log` inspection. It uses a bump
-arena and never frees — garbage collection is deliberately deferred and isolated
-behind `xt_alloc`, so it can be replaced without touching the compiler.
+`runtime/` implements strings, objects, arrays, closures, arithmetic,
+comparison, exceptions and Node-like `console.log` inspection. The C code is
+split by function across translation units (`xt_alloc.c`, `xt_values.c`,
+`xt_containers.c`, `xt_stdlib.c`, `xt_builtins.c`, `xt_io.c`) sharing the
+private `runtime/rt_internal.h`. It uses a bump arena and never frees — garbage
+collection is deliberately deferred and isolated behind `xt_alloc`, so it can
+be replaced without touching the compiler.
 
 ## Usage
 

package/dist/src/ast/common.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Core AST shapes shared by every node category: source ranges, the base
+ * `Node` interface, the `Modifier` node and the `Expression`/`Statement`/
+ * `TypeNode` discriminated unions.
+ */
+import { SyntaxKind, type ModifierKind } from "./kinds.js";
+import type { ArrayLiteralExpression, ArrowFunction, AsExpression, AwaitExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, ClassExpression, ConditionalExpression, DeleteExpression, ElementAccessExpression, FunctionExpression, Identifier, NewExpression, NoSubstitutionTemplateLiteral, NonNullExpression, NullLiteral, NumericLiteral, ObjectLiteralExpression, ParenthesizedExpression, PostfixUnaryExpression, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, RegularExpressionLiteral, SatisfiesExpression, SpreadElement, StringLiteral, TaggedTemplateExpression, TemplateLiteral, ThisExpression, TypeOfExpression, UndefinedLiteral, VoidExpression, YieldExpression } from "./expressions.js";
+import type { Block, BreakStatement, ContinueStatement, DebuggerStatement, DoStatement, EmptyStatement, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, IfStatement, LabeledStatement, ReturnStatement, SwitchStatement, ThrowStatement, TryStatement, VariableStatement, WhileStatement } from "./statements.js";
+import type { ClassDeclaration, EnumDeclaration, FunctionDeclaration, InterfaceDeclaration, ModuleDeclaration, TypeAliasDeclaration } from "./declarations.js";
+import type { ExportAssignment, ExportDeclaration, ImportDeclaration } from "./modules.js";
+import type { ArrayTypeNode, ConditionalTypeNode, FunctionTypeNode, IndexedAccessTypeNode, InferTypeNode, IntersectionTypeNode, KeywordTypeNode, LiteralTypeNode, MappedTypeNode, OptionalTypeNode, ParenthesizedTypeNode, RestTypeNode, TupleTypeNode, TypeLiteralNode, TypeOperatorNode, TypePredicate, TypeQueryNode, TypeReference, UnionTypeNode } from "./types.js";
+export interface Range {
+    /** Inclusive start offset (UTF-16 code units). */
+    readonly start: number;
+    /** Exclusive end offset. */
+    readonly end: number;
+}
+export interface Node extends Range {
+    readonly kind: SyntaxKind;
+}
+export interface Modifier extends Node {
+    readonly kind: SyntaxKind.Unknown;
+    readonly modifierKind: ModifierKind;
+}
+export type Expression = Identifier | PrivateIdentifier | NumericLiteral | BigIntLiteral | StringLiteral | NoSubstitutionTemplateLiteral | TemplateLiteral | RegularExpressionLiteral | BooleanLiteral | NullLiteral | UndefinedLiteral | ThisExpression | ArrayLiteralExpression | ObjectLiteralExpression | FunctionExpression | ArrowFunction | ClassExpression | CallExpression | NewExpression | PropertyAccessExpression | ElementAccessExpression | ParenthesizedExpression | PrefixUnaryExpression | PostfixUnaryExpression | BinaryExpression | ConditionalExpression | AsExpression | SatisfiesExpression | NonNullExpression | TypeOfExpression | VoidExpression | DeleteExpression | AwaitExpression | YieldExpression | TaggedTemplateExpression | SpreadElement;
+export type Statement = ExpressionStatement | Block | EmptyStatement | DebuggerStatement | VariableStatement | IfStatement | WhileStatement | DoStatement | ForStatement | ForOfStatement | ForInStatement | ReturnStatement | BreakStatement | ContinueStatement | ThrowStatement | TryStatement | SwitchStatement | LabeledStatement | FunctionDeclaration | ClassDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumDeclaration | ModuleDeclaration | ImportDeclaration | ExportDeclaration | ExportAssignment;
+export type TypeNode = TypeReference | TypePredicate | KeywordTypeNode | LiteralTypeNode | ArrayTypeNode | TupleTypeNode | UnionTypeNode | IntersectionTypeNode | FunctionTypeNode | TypeLiteralNode | ParenthesizedTypeNode | TypeQueryNode | IndexedAccessTypeNode | TypeOperatorNode | MappedTypeNode | ConditionalTypeNode | InferTypeNode | OptionalTypeNode | RestTypeNode;
+export interface SourceFileNode extends Node {
+    readonly kind: SyntaxKind.SourceFile;
+    readonly statements: Statement[];
+    readonly fileName: string;
+    readonly text: string;
+}

package/dist/src/ast/common.js

@@ -0,0 +1,7 @@
+/**
+ * Core AST shapes shared by every node category: source ranges, the base
+ * `Node` interface, the `Modifier` node and the `Expression`/`Statement`/
+ * `TypeNode` discriminated unions.
+ */
+export {};
+//# sourceMappingURL=common.js.map

package/dist/src/ast/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../src/ast/common.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/src/ast/declarations.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Declaration nodes of the xbintsc AST (functions, classes, interfaces, ...).
+ */
+import { NodeFlags, SyntaxKind } from "./kinds.js";
+import type { Expression, Modifier, Node, TypeNode } from "./common.js";
+import type { Identifier, PropertyName, StringLiteral } from "./expressions.js";
+import type { Block } from "./statements.js";
+import type { TypeElement } from "./types.js";
+export interface Parameter extends Node {
+    readonly kind: SyntaxKind.Parameter;
+    readonly name: Identifier;
+    readonly modifiers: Modifier[];
+    readonly dotDotDotToken: boolean;
+    readonly questionToken: boolean;
+    readonly type?: TypeNode;
+    readonly initializer?: Expression;
+}
+export interface TypeParameterDeclaration extends Node {
+    readonly kind: SyntaxKind.TypeParameterDeclaration;
+    readonly name: Identifier;
+    readonly constraint?: TypeNode;
+    readonly default?: TypeNode;
+}
+export interface FunctionDeclaration extends Node {
+    readonly kind: SyntaxKind.FunctionDeclaration;
+    readonly name?: Identifier;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+    readonly body?: Block;
+    readonly flags: NodeFlags;
+}
+export interface HeritageClause extends Node {
+    readonly kind: SyntaxKind.HeritageClause;
+    readonly token: "extends" | "implements";
+    readonly types: ExpressionWithTypeArguments[];
+}
+export interface ExpressionWithTypeArguments extends Node {
+    readonly kind: SyntaxKind.ExpressionWithTypeArguments;
+    readonly expression: Expression;
+    readonly typeArguments: TypeNode[];
+}
+export type ClassElement = PropertyDeclaration | MethodDeclaration | ConstructorDeclaration;
+export interface PropertyDeclaration extends Node {
+    readonly kind: SyntaxKind.PropertyDeclaration;
+    readonly name: PropertyName;
+    readonly modifiers: Modifier[];
+    readonly questionToken: boolean;
+    readonly exclamationToken: boolean;
+    readonly type?: TypeNode;
+    readonly initializer?: Expression;
+}
+export interface MethodDeclaration extends Node {
+    readonly kind: SyntaxKind.MethodDeclaration;
+    readonly name: PropertyName;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+    readonly body?: Block;
+    readonly flags: NodeFlags;
+    readonly optional: boolean;
+}
+export interface ConstructorDeclaration extends Node {
+    readonly kind: SyntaxKind.ConstructorDeclaration;
+    readonly modifiers: Modifier[];
+    readonly parameters: Parameter[];
+    readonly body?: Block;
+}
+export interface ClassDeclaration extends Node {
+    readonly kind: SyntaxKind.ClassDeclaration;
+    readonly name?: Identifier;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly heritage: HeritageClause[];
+    readonly members: ClassElement[];
+}
+export interface InterfaceDeclaration extends Node {
+    readonly kind: SyntaxKind.InterfaceDeclaration;
+    readonly name: Identifier;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly heritage: HeritageClause[];
+    readonly members: TypeElement[];
+}
+export interface TypeAliasDeclaration extends Node {
+    readonly kind: SyntaxKind.TypeAliasDeclaration;
+    readonly name: Identifier;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly type: TypeNode;
+}
+export interface EnumMember extends Node {
+    readonly kind: SyntaxKind.EnumMember;
+    readonly name: PropertyName;
+    readonly initializer?: Expression;
+}
+export interface EnumDeclaration extends Node {
+    readonly kind: SyntaxKind.EnumDeclaration;
+    readonly name: Identifier;
+    readonly modifiers: Modifier[];
+    readonly members: EnumMember[];
+}
+export interface ModuleDeclaration extends Node {
+    readonly kind: SyntaxKind.ModuleDeclaration;
+    readonly name: Identifier | StringLiteral;
+    readonly modifiers: Modifier[];
+    readonly body?: Block;
+}

package/dist/src/ast/declarations.js

@@ -0,0 +1,5 @@
+/**
+ * Declaration nodes of the xbintsc AST (functions, classes, interfaces, ...).
+ */
+export {};
+//# sourceMappingURL=declarations.js.map

package/dist/src/ast/declarations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.js","sourceRoot":"","sources":["../../../src/ast/declarations.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/src/ast/expressions.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Expression nodes of the xbintsc AST, plus the literal and identifier nodes
+ * they are built from.
+ */
+import type { Token } from "../lexer/token.js";
+import { NodeFlags, SyntaxKind } from "./kinds.js";
+import { AssignmentOperator, BinaryOperator, PostfixUnaryOperator, PrefixUnaryOperator } from "./operators.js";
+import type { Expression, Node, TypeNode } from "./common.js";
+import type { Block } from "./statements.js";
+import type { ClassElement, HeritageClause, Parameter, TypeParameterDeclaration } from "./declarations.js";
+export interface Identifier extends Node {
+    readonly kind: SyntaxKind.Identifier;
+    readonly text: string;
+    /** True when the identifier was written with a `#` prefix. */
+    readonly escaped?: boolean;
+}
+export interface PrivateIdentifier extends Node {
+    readonly kind: SyntaxKind.PrivateIdentifier;
+    readonly text: string;
+}
+export interface NumericLiteral extends Node {
+    readonly kind: SyntaxKind.NumericLiteral;
+    readonly text: string;
+    readonly value: number;
+}
+export interface BigIntLiteral extends Node {
+    readonly kind: SyntaxKind.BigIntLiteral;
+    readonly text: string;
+    readonly value: bigint;
+}
+export interface StringLiteral extends Node {
+    readonly kind: SyntaxKind.StringLiteral;
+    readonly text: string;
+    readonly value: string;
+    /** Raw source text, including quotes. */
+    readonly raw: string;
+}
+export interface NoSubstitutionTemplateLiteral extends Node {
+    readonly kind: SyntaxKind.NoSubstitutionTemplateLiteral;
+    readonly text: string;
+    readonly value: string;
+}
+export interface TemplateLiteral extends Node {
+    readonly kind: SyntaxKind.TemplateLiteral;
+    readonly head: string;
+    readonly spans: TemplateSpan[];
+}
+export interface TemplateSpan extends Node {
+    readonly kind: SyntaxKind.TemplateSpan;
+    readonly expression: Expression;
+    readonly literal: string;
+    /** True when this span terminates the template (tail) rather than continues it. */
+    readonly isTail: boolean;
+}
+export interface RegularExpressionLiteral extends Node {
+    readonly kind: SyntaxKind.RegularExpressionLiteral;
+    readonly text: string;
+    readonly pattern: string;
+    readonly flags: string;
+}
+export interface BooleanLiteral extends Node {
+    readonly kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword;
+    readonly value: boolean;
+}
+export interface NullLiteral extends Node {
+    readonly kind: SyntaxKind.NullKeyword;
+}
+export interface UndefinedLiteral extends Node {
+    readonly kind: SyntaxKind.UndefinedKeyword;
+}
+export interface ThisExpression extends Node {
+    readonly kind: SyntaxKind.ThisKeyword;
+}
+export interface ArrayLiteralExpression extends Node {
+    readonly kind: SyntaxKind.ArrayLiteralExpression;
+    readonly elements: Expression[];
+}
+export interface PropertyAssignment extends Node {
+    readonly kind: SyntaxKind.PropertyAssignment;
+    readonly name: PropertyName;
+    readonly initializer: Expression;
+}
+export interface ShorthandPropertyAssignment extends Node {
+    readonly kind: SyntaxKind.ShorthandPropertyAssignment;
+    readonly name: Identifier;
+}
+export interface SpreadElement extends Node {
+    readonly kind: SyntaxKind.SpreadElement;
+    readonly expression: Expression;
+}
+export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadElement;
+export interface ObjectLiteralExpression extends Node {
+    readonly kind: SyntaxKind.ObjectLiteralExpression;
+    readonly properties: ObjectLiteralElementLike[];
+}
+export type PropertyName = Identifier | StringLiteral | NumericLiteral | PrivateIdentifier;
+export interface FunctionExpression extends Node {
+    readonly kind: SyntaxKind.FunctionExpression;
+    readonly name?: Identifier;
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+    readonly body: Block;
+    readonly flags: NodeFlags;
+}
+export interface ArrowFunction extends Node {
+    readonly kind: SyntaxKind.ArrowFunction;
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+    readonly body: Block | Expression;
+    readonly flags: NodeFlags;
+}
+export interface ClassExpression extends Node {
+    readonly kind: SyntaxKind.ClassExpression;
+    readonly name?: Identifier;
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly heritage: HeritageClause[];
+    readonly members: ClassElement[];
+}
+export interface CallExpression extends Node {
+    readonly kind: SyntaxKind.CallExpression;
+    readonly expression: Expression;
+    readonly typeArguments: TypeNode[];
+    readonly arguments: Expression[];
+    readonly optional: boolean;
+}
+export interface NewExpression extends Node {
+    readonly kind: SyntaxKind.NewExpression;
+    readonly expression: Expression;
+    readonly typeArguments: TypeNode[];
+    readonly arguments: Expression[];
+}
+export interface PropertyAccessExpression extends Node {
+    readonly kind: SyntaxKind.PropertyAccessExpression;
+    readonly expression: Expression;
+    readonly name: Identifier;
+    readonly optional: boolean;
+}
+export interface ElementAccessExpression extends Node {
+    readonly kind: SyntaxKind.ElementAccessExpression;
+    readonly expression: Expression;
+    readonly argumentExpression: Expression;
+    readonly optional: boolean;
+}
+export interface ParenthesizedExpression extends Node {
+    readonly kind: SyntaxKind.ParenthesizedExpression;
+    readonly expression: Expression;
+}
+export interface PrefixUnaryExpression extends Node {
+    readonly kind: SyntaxKind.PrefixUnaryExpression;
+    readonly operator: PrefixUnaryOperator;
+    readonly operand: Expression;
+}
+export interface PostfixUnaryExpression extends Node {
+    readonly kind: SyntaxKind.PostfixUnaryExpression;
+    readonly operator: PostfixUnaryOperator;
+    readonly operand: Expression;
+}
+export interface BinaryExpression extends Node {
+    readonly kind: SyntaxKind.BinaryExpression;
+    readonly left: Expression;
+    readonly operator: BinaryOperator;
+    readonly right: Expression;
+    readonly operatorToken: Token;
+}
+export interface AssignmentExpression extends Node {
+    readonly kind: SyntaxKind.BinaryExpression;
+    readonly left: Expression;
+    readonly operator: AssignmentOperator;
+    readonly right: Expression;
+    readonly operatorToken: Token;
+}
+export interface ConditionalExpression extends Node {
+    readonly kind: SyntaxKind.ConditionalExpression;
+    readonly condition: Expression;
+    readonly whenTrue: Expression;
+    readonly whenFalse: Expression;
+}
+export interface AsExpression extends Node {
+    readonly kind: SyntaxKind.AsExpression;
+    readonly expression: Expression;
+    readonly type: TypeNode;
+}
+export interface SatisfiesExpression extends Node {
+    readonly kind: SyntaxKind.SatisfiesExpression;
+    readonly expression: Expression;
+    readonly type: TypeNode;
+}
+export interface NonNullExpression extends Node {
+    readonly kind: SyntaxKind.NonNullExpression;
+    readonly expression: Expression;
+}
+export interface TypeOfExpression extends Node {
+    readonly kind: SyntaxKind.TypeOfExpression;
+    readonly expression: Expression;
+}
+export interface VoidExpression extends Node {
+    readonly kind: SyntaxKind.VoidExpression;
+    readonly expression?: Expression;
+}
+export interface DeleteExpression extends Node {
+    readonly kind: SyntaxKind.DeleteExpression;
+    readonly expression: Expression;
+}
+export interface AwaitExpression extends Node {
+    readonly kind: SyntaxKind.AwaitExpression;
+    readonly expression: Expression;
+}
+export interface YieldExpression extends Node {
+    readonly kind: SyntaxKind.YieldExpression;
+    readonly expression?: Expression;
+    readonly delegate: boolean;
+}
+export interface TaggedTemplateExpression extends Node {
+    readonly kind: SyntaxKind.TaggedTemplateExpression;
+    readonly tag: Expression;
+    readonly template: TemplateLiteral | NoSubstitutionTemplateLiteral;
+}

package/dist/src/ast/expressions.js

@@ -0,0 +1,6 @@
+/**
+ * Expression nodes of the xbintsc AST, plus the literal and identifier nodes
+ * they are built from.
+ */
+export {};
+//# sourceMappingURL=expressions.js.map

package/dist/src/ast/expressions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.js","sourceRoot":"","sources":["../../../src/ast/expressions.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/ast/kinds.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Syntax kinds and node flags for the xbintsc AST.
+ *
+ * These numeric/string tags are the discriminants used throughout the binder,
+ * checker and code generator to switch exhaustively over nodes.
+ */
+export declare const enum SyntaxKind {
+    Unknown = 0,
+    EndOfFileToken = 1,
+    SourceFile = 300,
+    QualifiedName = 301,
+    ExpressionWithTypeArguments = 302,
+    ImportType = 303,
+    Identifier = 2,
+    PrivateIdentifier = 3,
+    NumericLiteral = 4,
+    BigIntLiteral = 5,
+    StringLiteral = 6,
+    NoSubstitutionTemplateLiteral = 7,
+    TemplateLiteral = 8,
+    TemplateSpan = 9,
+    RegularExpressionLiteral = 10,
+    TrueKeyword = 11,
+    FalseKeyword = 12,
+    NullKeyword = 13,
+    UndefinedKeyword = 14,
+    ThisKeyword = 15,
+    ArrayLiteralExpression = 20,
+    ObjectLiteralExpression = 21,
+    PropertyAssignment = 22,
+    ShorthandPropertyAssignment = 23,
+    SpreadElement = 24,
+    FunctionExpression = 25,
+    ArrowFunction = 26,
+    ClassExpression = 27,
+    CallExpression = 28,
+    NewExpression = 29,
+    PropertyAccessExpression = 30,
+    ElementAccessExpression = 31,
+    ParenthesizedExpression = 32,
+    PrefixUnaryExpression = 33,
+    PostfixUnaryExpression = 34,
+    BinaryExpression = 35,
+    ConditionalExpression = 36,
+    AsExpression = 37,
+    SatisfiesExpression = 38,
+    NonNullExpression = 39,
+    TypeOfExpression = 40,
+    VoidExpression = 41,
+    DeleteExpression = 42,
+    AwaitExpression = 43,
+    YieldExpression = 44,
+    TaggedTemplateExpression = 45,
+    ExpressionStatement = 60,
+    Block = 61,
+    EmptyStatement = 62,
+    DebuggerStatement = 63,
+    VariableStatement = 64,
+    VariableDeclarationList = 65,
+    VariableDeclaration = 66,
+    IfStatement = 67,
+    WhileStatement = 68,
+    DoStatement = 69,
+    ForStatement = 70,
+    ForOfStatement = 71,
+    ForInStatement = 72,
+    ReturnStatement = 73,
+    BreakStatement = 74,
+    ContinueStatement = 75,
+    ThrowStatement = 76,
+    TryStatement = 77,
+    CatchClause = 78,
+    SwitchStatement = 79,
+    CaseClause = 80,
+    DefaultClause = 81,
+    LabeledStatement = 82,
+    FunctionDeclaration = 100,
+    ClassDeclaration = 101,
+    InterfaceDeclaration = 102,
+    TypeAliasDeclaration = 103,
+    EnumDeclaration = 104,
+    EnumMember = 105,
+    ModuleDeclaration = 106,
+    Parameter = 107,
+    TypeParameterDeclaration = 108,
+    PropertyDeclaration = 109,
+    MethodDeclaration = 110,
+    ConstructorDeclaration = 111,
+    HeritageClause = 112,
+    ImportDeclaration = 113,
+    ImportClause = 114,
+    NamedImports = 115,
+    ImportSpecifier = 116,
+    NamespaceImport = 117,
+    ExportDeclaration = 118,
+    ExportAssignment = 119,
+    NamedExports = 120,
+    ExportSpecifier = 121,
+    TypeReference = 200,
+    TypePredicate = 201,
+    AnyKeywordType = 202,
+    UnknownKeywordType = 203,
+    NumberKeywordType = 204,
+    BigIntKeywordType = 205,
+    StringKeywordType = 206,
+    BooleanKeywordType = 207,
+    SymbolKeywordType = 208,
+    VoidKeywordType = 209,
+    UndefinedKeywordType = 210,
+    NullKeywordType = 211,
+    NeverKeywordType = 212,
+    ObjectKeywordType = 213,
+    ThisKeywordType = 214,
+    LiteralType = 215,
+    ArrayType = 216,
+    TupleType = 217,
+    UnionType = 218,
+    IntersectionType = 219,
+    FunctionType = 220,
+    TypeLiteral = 221,
+    PropertySignature = 222,
+    MethodSignature = 223,
+    IndexSignature = 224,
+    ParenthesizedType = 225,
+    TypeQuery = 226,
+    IndexedAccessType = 227,
+    TypeOperator = 228,
+    MappedType = 229,
+    ConditionalType = 230,
+    InferType = 231,
+    OptionalType = 232,
+    RestType = 233
+}
+export declare const enum NodeFlags {
+    None = 0,
+    Let = 1,
+    Const = 2,
+    Var = 4,
+    Exported = 8,
+    Default = 16,
+    Declare = 32,
+    Async = 64,
+    Generator = 128,
+    Ambient = 256,
+    Readonly = 512,
+    Abstract = 1024,
+    Optional = 2048
+}
+export declare const enum ModifierKind {
+    Export = "export",
+    Default = "default",
+    Declare = "declare",
+    Abstract = "abstract",
+    Public = "public",
+    Private = "private",
+    Protected = "protected",
+    Static = "static",
+    Readonly = "readonly",
+    Async = "async"
+}