xbintsc 0.1.0

package/dist/src/ast/nodes.js

@@ -0,0 +1,247 @@
+/**
+ * The xbintsc abstract syntax tree.
+ *
+ * The AST is a faithful, lossless-enough representation of the TypeScript
+ * source. Nodes are discriminated unions keyed by `kind` so the binder, checker
+ * and code generator can switch exhaustively over them. Every node carries a
+ * source range (`start`/`end` offsets) which the diagnostics layer maps back to
+ * line/column, and which the incremental cache uses to detect changes.
+ */
+export var SyntaxKind;
+(function (SyntaxKind) {
+    // Markers
+    SyntaxKind[SyntaxKind["Unknown"] = 0] = "Unknown";
+    SyntaxKind[SyntaxKind["EndOfFileToken"] = 1] = "EndOfFileToken";
+    SyntaxKind[SyntaxKind["SourceFile"] = 300] = "SourceFile";
+    SyntaxKind[SyntaxKind["QualifiedName"] = 301] = "QualifiedName";
+    SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 302] = "ExpressionWithTypeArguments";
+    SyntaxKind[SyntaxKind["ImportType"] = 303] = "ImportType";
+    // Trivia-ish
+    SyntaxKind[SyntaxKind["Identifier"] = 2] = "Identifier";
+    SyntaxKind[SyntaxKind["PrivateIdentifier"] = 3] = "PrivateIdentifier";
+    // Literals
+    SyntaxKind[SyntaxKind["NumericLiteral"] = 4] = "NumericLiteral";
+    SyntaxKind[SyntaxKind["BigIntLiteral"] = 5] = "BigIntLiteral";
+    SyntaxKind[SyntaxKind["StringLiteral"] = 6] = "StringLiteral";
+    SyntaxKind[SyntaxKind["NoSubstitutionTemplateLiteral"] = 7] = "NoSubstitutionTemplateLiteral";
+    SyntaxKind[SyntaxKind["TemplateLiteral"] = 8] = "TemplateLiteral";
+    SyntaxKind[SyntaxKind["TemplateSpan"] = 9] = "TemplateSpan";
+    SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 10] = "RegularExpressionLiteral";
+    SyntaxKind[SyntaxKind["TrueKeyword"] = 11] = "TrueKeyword";
+    SyntaxKind[SyntaxKind["FalseKeyword"] = 12] = "FalseKeyword";
+    SyntaxKind[SyntaxKind["NullKeyword"] = 13] = "NullKeyword";
+    SyntaxKind[SyntaxKind["UndefinedKeyword"] = 14] = "UndefinedKeyword";
+    SyntaxKind[SyntaxKind["ThisKeyword"] = 15] = "ThisKeyword";
+    // Expressions
+    SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 20] = "ArrayLiteralExpression";
+    SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 21] = "ObjectLiteralExpression";
+    SyntaxKind[SyntaxKind["PropertyAssignment"] = 22] = "PropertyAssignment";
+    SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 23] = "ShorthandPropertyAssignment";
+    SyntaxKind[SyntaxKind["SpreadElement"] = 24] = "SpreadElement";
+    SyntaxKind[SyntaxKind["FunctionExpression"] = 25] = "FunctionExpression";
+    SyntaxKind[SyntaxKind["ArrowFunction"] = 26] = "ArrowFunction";
+    SyntaxKind[SyntaxKind["ClassExpression"] = 27] = "ClassExpression";
+    SyntaxKind[SyntaxKind["CallExpression"] = 28] = "CallExpression";
+    SyntaxKind[SyntaxKind["NewExpression"] = 29] = "NewExpression";
+    SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 30] = "PropertyAccessExpression";
+    SyntaxKind[SyntaxKind["ElementAccessExpression"] = 31] = "ElementAccessExpression";
+    SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 32] = "ParenthesizedExpression";
+    SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 33] = "PrefixUnaryExpression";
+    SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 34] = "PostfixUnaryExpression";
+    SyntaxKind[SyntaxKind["BinaryExpression"] = 35] = "BinaryExpression";
+    SyntaxKind[SyntaxKind["ConditionalExpression"] = 36] = "ConditionalExpression";
+    SyntaxKind[SyntaxKind["AsExpression"] = 37] = "AsExpression";
+    SyntaxKind[SyntaxKind["SatisfiesExpression"] = 38] = "SatisfiesExpression";
+    SyntaxKind[SyntaxKind["NonNullExpression"] = 39] = "NonNullExpression";
+    SyntaxKind[SyntaxKind["TypeOfExpression"] = 40] = "TypeOfExpression";
+    SyntaxKind[SyntaxKind["VoidExpression"] = 41] = "VoidExpression";
+    SyntaxKind[SyntaxKind["DeleteExpression"] = 42] = "DeleteExpression";
+    SyntaxKind[SyntaxKind["AwaitExpression"] = 43] = "AwaitExpression";
+    SyntaxKind[SyntaxKind["YieldExpression"] = 44] = "YieldExpression";
+    SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 45] = "TaggedTemplateExpression";
+    // Statements
+    SyntaxKind[SyntaxKind["ExpressionStatement"] = 60] = "ExpressionStatement";
+    SyntaxKind[SyntaxKind["Block"] = 61] = "Block";
+    SyntaxKind[SyntaxKind["EmptyStatement"] = 62] = "EmptyStatement";
+    SyntaxKind[SyntaxKind["DebuggerStatement"] = 63] = "DebuggerStatement";
+    SyntaxKind[SyntaxKind["VariableStatement"] = 64] = "VariableStatement";
+    SyntaxKind[SyntaxKind["VariableDeclarationList"] = 65] = "VariableDeclarationList";
+    SyntaxKind[SyntaxKind["VariableDeclaration"] = 66] = "VariableDeclaration";
+    SyntaxKind[SyntaxKind["IfStatement"] = 67] = "IfStatement";
+    SyntaxKind[SyntaxKind["WhileStatement"] = 68] = "WhileStatement";
+    SyntaxKind[SyntaxKind["DoStatement"] = 69] = "DoStatement";
+    SyntaxKind[SyntaxKind["ForStatement"] = 70] = "ForStatement";
+    SyntaxKind[SyntaxKind["ForOfStatement"] = 71] = "ForOfStatement";
+    SyntaxKind[SyntaxKind["ForInStatement"] = 72] = "ForInStatement";
+    SyntaxKind[SyntaxKind["ReturnStatement"] = 73] = "ReturnStatement";
+    SyntaxKind[SyntaxKind["BreakStatement"] = 74] = "BreakStatement";
+    SyntaxKind[SyntaxKind["ContinueStatement"] = 75] = "ContinueStatement";
+    SyntaxKind[SyntaxKind["ThrowStatement"] = 76] = "ThrowStatement";
+    SyntaxKind[SyntaxKind["TryStatement"] = 77] = "TryStatement";
+    SyntaxKind[SyntaxKind["CatchClause"] = 78] = "CatchClause";
+    SyntaxKind[SyntaxKind["SwitchStatement"] = 79] = "SwitchStatement";
+    SyntaxKind[SyntaxKind["CaseClause"] = 80] = "CaseClause";
+    SyntaxKind[SyntaxKind["DefaultClause"] = 81] = "DefaultClause";
+    SyntaxKind[SyntaxKind["LabeledStatement"] = 82] = "LabeledStatement";
+    // Declarations
+    SyntaxKind[SyntaxKind["FunctionDeclaration"] = 100] = "FunctionDeclaration";
+    SyntaxKind[SyntaxKind["ClassDeclaration"] = 101] = "ClassDeclaration";
+    SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 102] = "InterfaceDeclaration";
+    SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 103] = "TypeAliasDeclaration";
+    SyntaxKind[SyntaxKind["EnumDeclaration"] = 104] = "EnumDeclaration";
+    SyntaxKind[SyntaxKind["EnumMember"] = 105] = "EnumMember";
+    SyntaxKind[SyntaxKind["ModuleDeclaration"] = 106] = "ModuleDeclaration";
+    SyntaxKind[SyntaxKind["Parameter"] = 107] = "Parameter";
+    SyntaxKind[SyntaxKind["TypeParameterDeclaration"] = 108] = "TypeParameterDeclaration";
+    SyntaxKind[SyntaxKind["PropertyDeclaration"] = 109] = "PropertyDeclaration";
+    SyntaxKind[SyntaxKind["MethodDeclaration"] = 110] = "MethodDeclaration";
+    SyntaxKind[SyntaxKind["ConstructorDeclaration"] = 111] = "ConstructorDeclaration";
+    SyntaxKind[SyntaxKind["HeritageClause"] = 112] = "HeritageClause";
+    SyntaxKind[SyntaxKind["ImportDeclaration"] = 113] = "ImportDeclaration";
+    SyntaxKind[SyntaxKind["ImportClause"] = 114] = "ImportClause";
+    SyntaxKind[SyntaxKind["NamedImports"] = 115] = "NamedImports";
+    SyntaxKind[SyntaxKind["ImportSpecifier"] = 116] = "ImportSpecifier";
+    SyntaxKind[SyntaxKind["NamespaceImport"] = 117] = "NamespaceImport";
+    SyntaxKind[SyntaxKind["ExportDeclaration"] = 118] = "ExportDeclaration";
+    SyntaxKind[SyntaxKind["ExportAssignment"] = 119] = "ExportAssignment";
+    SyntaxKind[SyntaxKind["NamedExports"] = 120] = "NamedExports";
+    SyntaxKind[SyntaxKind["ExportSpecifier"] = 121] = "ExportSpecifier";
+    // Types
+    SyntaxKind[SyntaxKind["TypeReference"] = 200] = "TypeReference";
+    SyntaxKind[SyntaxKind["TypePredicate"] = 201] = "TypePredicate";
+    SyntaxKind[SyntaxKind["AnyKeywordType"] = 202] = "AnyKeywordType";
+    SyntaxKind[SyntaxKind["UnknownKeywordType"] = 203] = "UnknownKeywordType";
+    SyntaxKind[SyntaxKind["NumberKeywordType"] = 204] = "NumberKeywordType";
+    SyntaxKind[SyntaxKind["BigIntKeywordType"] = 205] = "BigIntKeywordType";
+    SyntaxKind[SyntaxKind["StringKeywordType"] = 206] = "StringKeywordType";
+    SyntaxKind[SyntaxKind["BooleanKeywordType"] = 207] = "BooleanKeywordType";
+    SyntaxKind[SyntaxKind["SymbolKeywordType"] = 208] = "SymbolKeywordType";
+    SyntaxKind[SyntaxKind["VoidKeywordType"] = 209] = "VoidKeywordType";
+    SyntaxKind[SyntaxKind["UndefinedKeywordType"] = 210] = "UndefinedKeywordType";
+    SyntaxKind[SyntaxKind["NullKeywordType"] = 211] = "NullKeywordType";
+    SyntaxKind[SyntaxKind["NeverKeywordType"] = 212] = "NeverKeywordType";
+    SyntaxKind[SyntaxKind["ObjectKeywordType"] = 213] = "ObjectKeywordType";
+    SyntaxKind[SyntaxKind["ThisKeywordType"] = 214] = "ThisKeywordType";
+    SyntaxKind[SyntaxKind["LiteralType"] = 215] = "LiteralType";
+    SyntaxKind[SyntaxKind["ArrayType"] = 216] = "ArrayType";
+    SyntaxKind[SyntaxKind["TupleType"] = 217] = "TupleType";
+    SyntaxKind[SyntaxKind["UnionType"] = 218] = "UnionType";
+    SyntaxKind[SyntaxKind["IntersectionType"] = 219] = "IntersectionType";
+    SyntaxKind[SyntaxKind["FunctionType"] = 220] = "FunctionType";
+    SyntaxKind[SyntaxKind["TypeLiteral"] = 221] = "TypeLiteral";
+    SyntaxKind[SyntaxKind["PropertySignature"] = 222] = "PropertySignature";
+    SyntaxKind[SyntaxKind["MethodSignature"] = 223] = "MethodSignature";
+    SyntaxKind[SyntaxKind["IndexSignature"] = 224] = "IndexSignature";
+    SyntaxKind[SyntaxKind["ParenthesizedType"] = 225] = "ParenthesizedType";
+    SyntaxKind[SyntaxKind["TypeQuery"] = 226] = "TypeQuery";
+    SyntaxKind[SyntaxKind["IndexedAccessType"] = 227] = "IndexedAccessType";
+    SyntaxKind[SyntaxKind["TypeOperator"] = 228] = "TypeOperator";
+    SyntaxKind[SyntaxKind["MappedType"] = 229] = "MappedType";
+    SyntaxKind[SyntaxKind["ConditionalType"] = 230] = "ConditionalType";
+    SyntaxKind[SyntaxKind["InferType"] = 231] = "InferType";
+    SyntaxKind[SyntaxKind["OptionalType"] = 232] = "OptionalType";
+    SyntaxKind[SyntaxKind["RestType"] = 233] = "RestType";
+})(SyntaxKind || (SyntaxKind = {}));
+export var NodeFlags;
+(function (NodeFlags) {
+    NodeFlags[NodeFlags["None"] = 0] = "None";
+    NodeFlags[NodeFlags["Let"] = 1] = "Let";
+    NodeFlags[NodeFlags["Const"] = 2] = "Const";
+    NodeFlags[NodeFlags["Var"] = 4] = "Var";
+    NodeFlags[NodeFlags["Exported"] = 8] = "Exported";
+    NodeFlags[NodeFlags["Default"] = 16] = "Default";
+    NodeFlags[NodeFlags["Declare"] = 32] = "Declare";
+    NodeFlags[NodeFlags["Async"] = 64] = "Async";
+    NodeFlags[NodeFlags["Generator"] = 128] = "Generator";
+    NodeFlags[NodeFlags["Ambient"] = 256] = "Ambient";
+    NodeFlags[NodeFlags["Readonly"] = 512] = "Readonly";
+    NodeFlags[NodeFlags["Abstract"] = 1024] = "Abstract";
+    NodeFlags[NodeFlags["Optional"] = 2048] = "Optional";
+})(NodeFlags || (NodeFlags = {}));
+export var ModifierKind;
+(function (ModifierKind) {
+    ModifierKind["Export"] = "export";
+    ModifierKind["Default"] = "default";
+    ModifierKind["Declare"] = "declare";
+    ModifierKind["Abstract"] = "abstract";
+    ModifierKind["Public"] = "public";
+    ModifierKind["Private"] = "private";
+    ModifierKind["Protected"] = "protected";
+    ModifierKind["Static"] = "static";
+    ModifierKind["Readonly"] = "readonly";
+    ModifierKind["Async"] = "async";
+})(ModifierKind || (ModifierKind = {}));
+export var PrefixUnaryOperator;
+(function (PrefixUnaryOperator) {
+    PrefixUnaryOperator["Plus"] = "+";
+    PrefixUnaryOperator["Minus"] = "-";
+    PrefixUnaryOperator["Tilde"] = "~";
+    PrefixUnaryOperator["Exclamation"] = "!";
+    PrefixUnaryOperator["TypeOf"] = "typeof";
+    PrefixUnaryOperator["Void"] = "void";
+    PrefixUnaryOperator["Delete"] = "delete";
+    PrefixUnaryOperator["PlusPlus"] = "++";
+    PrefixUnaryOperator["MinusMinus"] = "--";
+    PrefixUnaryOperator["Await"] = "await";
+})(PrefixUnaryOperator || (PrefixUnaryOperator = {}));
+export var PostfixUnaryOperator;
+(function (PostfixUnaryOperator) {
+    PostfixUnaryOperator["PlusPlus"] = "++";
+    PostfixUnaryOperator["MinusMinus"] = "--";
+})(PostfixUnaryOperator || (PostfixUnaryOperator = {}));
+export var BinaryOperator;
+(function (BinaryOperator) {
+    BinaryOperator["Add"] = "+";
+    BinaryOperator["Subtract"] = "-";
+    BinaryOperator["Multiply"] = "*";
+    BinaryOperator["Divide"] = "/";
+    BinaryOperator["Remainder"] = "%";
+    BinaryOperator["Exponent"] = "**";
+    BinaryOperator["LessThan"] = "<";
+    BinaryOperator["LessThanEquals"] = "<=";
+    BinaryOperator["GreaterThan"] = ">";
+    BinaryOperator["GreaterThanEquals"] = ">=";
+    BinaryOperator["EqualsEquals"] = "==";
+    BinaryOperator["ExclamationEquals"] = "!=";
+    BinaryOperator["EqualsEqualsEquals"] = "===";
+    BinaryOperator["ExclamationEqualsEquals"] = "!==";
+    BinaryOperator["AmpersandAmpersand"] = "&&";
+    BinaryOperator["BarBar"] = "||";
+    BinaryOperator["QuestionQuestion"] = "??";
+    BinaryOperator["Ampersand"] = "&";
+    BinaryOperator["Bar"] = "|";
+    BinaryOperator["Caret"] = "^";
+    BinaryOperator["LessThanLessThan"] = "<<";
+    BinaryOperator["GreaterThanGreaterThan"] = ">>";
+    BinaryOperator["GreaterThanGreaterThanGreaterThan"] = ">>>";
+    BinaryOperator["Comma"] = ",";
+    BinaryOperator["In"] = "in";
+    BinaryOperator["InstanceOf"] = "instanceof";
+})(BinaryOperator || (BinaryOperator = {}));
+/** Assignment operators, including the compound forms. */
+export var AssignmentOperator;
+(function (AssignmentOperator) {
+    AssignmentOperator["Assign"] = "=";
+    AssignmentOperator["AddAssign"] = "+=";
+    AssignmentOperator["SubtractAssign"] = "-=";
+    AssignmentOperator["MultiplyAssign"] = "*=";
+    AssignmentOperator["DivideAssign"] = "/=";
+    AssignmentOperator["RemainderAssign"] = "%=";
+    AssignmentOperator["ExponentAssign"] = "**=";
+    AssignmentOperator["LessThanLessThanAssign"] = "<<=";
+    AssignmentOperator["GreaterThanGreaterThanAssign"] = ">>=";
+    AssignmentOperator["GreaterThanGreaterThanGreaterThanAssign"] = ">>>=";
+    AssignmentOperator["AmpersandAssign"] = "&=";
+    AssignmentOperator["BarAssign"] = "|=";
+    AssignmentOperator["CaretAssign"] = "^=";
+    AssignmentOperator["AmpersandAmpersandAssign"] = "&&=";
+    AssignmentOperator["BarBarAssign"] = "||=";
+    AssignmentOperator["QuestionQuestionAssign"] = "??=";
+})(AssignmentOperator || (AssignmentOperator = {}));
+export var TypeOperator;
+(function (TypeOperator) {
+    TypeOperator["KeyOf"] = "keyof";
+    TypeOperator["Unique"] = "unique";
+    TypeOperator["Readonly"] = "readonly";
+})(TypeOperator || (TypeOperator = {}));
+//# sourceMappingURL=nodes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nodes.js","sourceRoot":"","sources":["../../../src/ast/nodes.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,18 @@
+import { SyntaxKind, type Node } from "./nodes.js";
+/**
+ * A generic, allocation-light AST visitor. The parser, binder and checker all
+ * traverse the tree; centralizing the "what are my children" logic avoids the
+ * classic bug where a new node kind is added but one traversal forgets it.
+ */
+export type VisitorFn<T extends Node = Node> = (node: T) => void;
+export interface Visitor {
+    [SyntaxKind.Identifier]?: VisitorFn;
+    [key: number]: VisitorFn | undefined;
+}
+/** Return the direct children of a node for generic traversal. */
+export declare function getChildren(node: Node): Node[];
+/** Depth-first pre-order traversal. */
+export declare function forEachChild(node: Node, visit: (child: Node) => void): void;
+export declare function walk(node: Node, visit: VisitorFn): void;
+/** Find the innermost node whose range contains `offset`. */
+export declare function nodeAtPosition(root: Node, offset: number): Node | undefined;

package/dist/src/ast/visitor.js

@@ -0,0 +1,52 @@
+import { SyntaxKind } from "./nodes.js";
+/** Return the direct children of a node for generic traversal. */
+export function getChildren(node) {
+    const children = [];
+    const push = (n) => {
+        if (n && typeof n === "object" && "kind" in n)
+            children.push(n);
+    };
+    const pushAll = (list) => {
+        if (!list)
+            return;
+        for (const item of list)
+            push(item);
+    };
+    const n = node;
+    for (const key of Object.keys(n)) {
+        if (key === "kind" || key === "start" || key === "end" || key === "text" || key === "value")
+            continue;
+        const value = n[key];
+        if (Array.isArray(value))
+            pushAll(value);
+        else if (value && typeof value === "object" && "kind" in value)
+            push(value);
+    }
+    return children;
+}
+/** Depth-first pre-order traversal. */
+export function forEachChild(node, visit) {
+    for (const child of getChildren(node))
+        visit(child);
+}
+export function walk(node, visit) {
+    visit(node);
+    for (const child of getChildren(node))
+        walk(child, visit);
+}
+/** Find the innermost node whose range contains `offset`. */
+export function nodeAtPosition(root, offset) {
+    let current = root;
+    let result;
+    while (current) {
+        const children = getChildren(current).filter((c) => c.start <= offset && offset < c.end);
+        if (children.length === 0)
+            break;
+        // Prefer the smallest (innermost) child.
+        children.sort((a, b) => a.end - a.start - (b.end - b.start));
+        current = children[0];
+        result = current;
+    }
+    return result;
+}
+//# sourceMappingURL=visitor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"visitor.js","sourceRoot":"","sources":["../../../src/ast/visitor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAa,MAAM,YAAY,CAAC;AAenD,kEAAkE;AAClE,MAAM,UAAU,WAAW,CAAC,IAAU;IACpC,MAAM,QAAQ,GAAW,EAAE,CAAC;IAC5B,MAAM,IAAI,GAAG,CAAC,CAAU,EAAQ,EAAE;QAChC,IAAI,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,MAAM,IAAK,CAAU;YAAE,QAAQ,CAAC,IAAI,CAAC,CAAS,CAAC,CAAC;IACpF,CAAC,CAAC;IACF,MAAM,OAAO,GAAG,CAAC,IAAoC,EAAQ,EAAE;QAC7D,IAAI,CAAC,IAAI;YAAE,OAAO;QAClB,KAAK,MAAM,IAAI,IAAI,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC,CAAC;IAEF,MAAM,CAAC,GAAG,IAA0C,CAAC;IACrD,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;QACjC,IAAI,GAAG,KAAK,MAAM,IAAI,GAAG,KAAK,OAAO,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,KAAK,MAAM,IAAI,GAAG,KAAK,OAAO;YAAE,SAAS;QACtG,MAAM,KAAK,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACrB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,KAAK,CAAC,CAAC;aACpC,IAAI,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,IAAK,KAAgB;YAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1F,CAAC;IACD,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,uCAAuC;AACvC,MAAM,UAAU,YAAY,CAAC,IAAU,EAAE,KAA4B;IACnE,KAAK,MAAM,KAAK,IAAI,WAAW,CAAC,IAAI,CAAC;QAAE,KAAK,CAAC,KAAK,CAAC,CAAC;AACtD,CAAC;AAED,MAAM,UAAU,IAAI,CAAC,IAAU,EAAE,KAAgB;IAC/C,KAAK,CAAC,IAAI,CAAC,CAAC;IACZ,KAAK,MAAM,KAAK,IAAI,WAAW,CAAC,IAAI,CAAC;QAAE,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC5D,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,cAAc,CAAC,IAAU,EAAE,MAAc;IACvD,IAAI,OAAO,GAAqB,IAAI,CAAC;IACrC,IAAI,MAAwB,CAAC;IAC7B,OAAO,OAAO,EAAE,CAAC;QACf,MAAM,QAAQ,GAAW,WAAW,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAO,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,MAAM,IAAI,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;QACvG,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;YAAE,MAAM;QACjC,yCAAyC;QACzC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAO,EAAE,CAAO,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QACzE,OAAO,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;QACtB,MAAM,GAAG,OAAO,CAAC;IACnB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/src/binder/binder.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The binder walks the AST once and answers two questions the code generator
+ * and checker depend on:
+ *
+ *   1. Which declaration does every identifier refer to? (scopes + symbols)
+ *   2. Which variables are captured by nested functions? (closure conversion)
+ *
+ * The result is deliberately plain data — maps and records — so it can be
+ * cached, serialized for the incremental build, and unit tested in isolation.
+ */
+import { type ArrowFunction, type FunctionDeclaration, type FunctionExpression, type Identifier, type Node, type SourceFileNode } from "../ast/nodes.js";
+export declare enum SymbolKind {
+    Var = "var",
+    Let = "let",
+    Const = "const",
+    Function = "function",
+    Parameter = "parameter",
+    Class = "class",
+    Interface = "interface",
+    TypeAlias = "type",
+    Enum = "enum",
+    Import = "import",
+    Namespace = "namespace"
+}
+export interface SymbolInfo {
+    readonly id: number;
+    readonly name: string;
+    readonly kind: SymbolKind;
+    /** False for `const` bindings and imports. */
+    readonly mutable: boolean;
+    /** The function this symbol belongs to. */
+    readonly fn: FunctionInfo;
+    readonly declarations: Node[];
+    readonly references: Identifier[];
+    /** Set when referenced from a nested function. */
+    captured: boolean;
+    /** Assigned after construction once we know it is captured. */
+    boxed: boolean;
+}
+export type FunctionNode = SourceFileNode | FunctionDeclaration | FunctionExpression | ArrowFunction;
+export interface FunctionInfo {
+    readonly id: number;
+    readonly name: string;
+    readonly node: FunctionNode;
+    readonly parent?: FunctionInfo;
+    readonly scope: Scope;
+    readonly params: SymbolInfo[];
+    /** Every binding declared directly in this function (params + locals). */
+    readonly locals: SymbolInfo[];
+    /** Outer bindings referenced by this function or any descendant. */
+    readonly captures: SymbolInfo[];
+    readonly captureIndex: Map<number, number>;
+    readonly isModule: boolean;
+    readonly isArrow: boolean;
+}
+export declare enum ScopeKind {
+    Module = "module",
+    Function = "function",
+    Block = "block",
+    For = "for",
+    Catch = "catch"
+}
+export interface Scope {
+    readonly kind: ScopeKind;
+    readonly parent?: Scope;
+    readonly fn: FunctionInfo;
+    readonly symbols: Map<string, SymbolInfo>;
+    /** The syntax node that introduced the scope, when there is one. */
+    readonly node?: Node;
+}
+export interface BindResult {
+    readonly moduleFunction: FunctionInfo;
+    readonly functions: FunctionInfo[];
+    /** Maps a function-like AST node to the FunctionInfo the binder built for it. */
+    readonly functionOfNode: Map<Node, FunctionInfo>;
+    readonly symbolOfDeclaration: Map<Node, SymbolInfo>;
+    readonly symbolOfIdentifier: Map<Identifier, SymbolInfo>;
+    readonly scopes: Map<Node, Scope>;
+    /** Identifier references that could not be resolved in user code. */
+    readonly unresolved: Identifier[];
+}
+export declare function bind(sourceFile: SourceFileNode): BindResult;