@scriptc/compiler 0.3.6 → 0.4.1

package/dist/frontend/npm-static-declaration-syntax.js

@@ -9,6 +9,7 @@
  * string/number/boolean methods retain their own declared return contract
  * too; inferred checked values validate at the ordinary return boundary. */
 import * as ts from "./ts7/syntax.js";
+import { getTextOfNode, tokenStartOfNode } from "./ts7/node-functions.js";
 const SCALAR_METHOD_RETURNS = new Set(["string", "number", "boolean"]);
 const NULLABLE_VOID_CALLBACK = "(() => void) | null";
 /** TypeScript truncates JSDoc inner/instance namepaths (`Owner~Item`,
@@ -19,16 +20,16 @@ export function applyNpmStaticJsDocNamepaths(sourceFile, source) {
     const replacements = new Map();
     const visit = (node) => {
         for (const doc of node.jsDoc ?? [])
-            for (const tag of doc.tags ?? []) {
+            for (const tag of doc.tags?.nodes ?? []) {
                 const expression = tag.typeExpression;
                 if (expression?.kind !== ts.SyntaxKind.JSDocTypeExpression)
                     continue;
-                const start = expression.getStart(sourceFile);
+                const start = tokenStartOfNode(expression);
                 if (source[start] !== "{")
                     continue;
                 let depth = 1;
                 let quote = "";
-                for (let i = start + 1; i < tag.getEnd() && depth > 0; i++) {
+                for (let i = start + 1; i < tag.end && depth > 0; i++) {
                     const char = source[i];
                     if (quote !== "") {
                         if (char === "\\")
@@ -49,7 +50,7 @@ export function applyNpmStaticJsDocNamepaths(sourceFile, source) {
                         depth--;
                         continue;
                     }
-                    const name = /^[$A-Z_a-z][$\w]*(?:[.#~][$A-Z_a-z][$\w]*)*/.exec(source.slice(i, tag.getEnd()))?.[0];
+                    const name = /^[$A-Z_a-z][$\w]*(?:[.#~][$A-Z_a-z][$\w]*)*/.exec(source.slice(i, tag.end))?.[0];
                     if (!name)
                         continue;
                     if (name.includes("~") || name.includes("#"))
@@ -75,7 +76,7 @@ export function applyNpmStaticJsDocNamepaths(sourceFile, source) {
  * downstream lowering still checks every assignment against the slot. */
 export function applyNpmStaticNullableClassFields(sourceFile, source) {
     const constructors = new Set();
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (ts.isClassDeclaration(statement) && statement.name)
             constructors.add(statement.name.text);
         if (ts.isImportDeclaration(statement) && !statement.importClause?.isTypeOnly) {
@@ -83,7 +84,7 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
             if (clause?.name)
                 constructors.add(clause.name.text);
             if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
-                for (const binding of clause.namedBindings.elements) {
+                for (const binding of clause.namedBindings.elements.nodes) {
                     if (!binding.isTypeOnly)
                         constructors.add(binding.name.text);
                 }
@@ -98,10 +99,10 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
         if (ts.isIdentifier(node))
             constructors.delete(node.text);
         else if (ts.isArrayLiteralExpression(node))
-            for (const item of node.elements)
+            for (const item of node.elements.nodes)
                 rejectAssignedName(item);
         else if (ts.isObjectLiteralExpression(node))
-            for (const item of node.properties) {
+            for (const item of node.properties.nodes) {
                 if (ts.isPropertyAssignment(item))
                     rejectAssignedName(item.initializer);
                 else if (ts.isShorthandPropertyAssignment(item))
@@ -129,17 +130,17 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
     };
     rejectMutable(sourceFile);
     const inserts = [];
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (!ts.isClassDeclaration(statement))
             continue;
         const fields = new Map();
-        for (const member of statement.members) {
+        for (const member of statement.members.nodes) {
             if (!ts.isPropertyDeclaration(member) ||
                 !ts.isIdentifier(member.name) ||
                 member.initializer?.kind !== ts.SyntaxKind.NullKeyword ||
                 hasModifier(member, ts.SyntaxKind.StaticKeyword))
                 continue;
-            const leading = source.slice(member.getFullStart(), member.getStart(sourceFile));
+            const leading = source.slice(member.pos, tokenStartOfNode(member));
             if (jsDocTypeOf(member) !== undefined || leading.includes("@type"))
                 continue;
             fields.set(member.name.text, { member, invalid: false });
@@ -153,7 +154,7 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
             if (ts.isIdentifier(name))
                 shadowed.add(name.text);
             else
-                for (const element of name.elements)
+                for (const element of name.elements.nodes)
                     if (ts.isBindingElement(element) && element.name !== undefined)
                         bindingNames(element.name);
         };
@@ -168,7 +169,7 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
                 shadowed.add(node.name.text);
             ts.forEachChild(node, collectBindings);
         };
-        for (const member of statement.members)
+        for (const member of statement.members.nodes)
             collectBindings(member);
         const targetField = (node) => {
             if (ts.isPropertyAccessExpression(node) && node.expression.kind === ts.SyntaxKind.ThisKeyword)
@@ -241,7 +242,7 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
                 invalidate(node.expression);
             ts.forEachChild(node, visit);
         };
-        for (const member of statement.members) {
+        for (const member of statement.members.nodes) {
             if (hasModifier(member, ts.SyntaxKind.StaticKeyword))
                 continue;
             if ((ts.isConstructorDeclaration(member) ||
@@ -256,7 +257,7 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
             if (field.invalid || field.className === undefined)
                 continue;
             inserts.push({
-                offset: field.member.getStart(sourceFile),
+                offset: tokenStartOfNode(field.member),
                 text: `/** @type {${field.className} | null} */ `,
             });
         }
@@ -276,14 +277,14 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
  * arrays; arbitrary methods also named find are left alone. */
 export function applyNpmStaticFindReturnWidening(sourceFile, source) {
     const insertions = [];
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (!ts.isClassDeclaration(statement))
             continue;
-        const constructor = statement.members.find((member) => ts.isConstructorDeclaration(member) && member.body !== undefined);
+        const constructor = statement.members.nodes.find((member) => ts.isConstructorDeclaration(member) && member.body !== undefined);
         if (constructor?.body === undefined)
             continue;
         const arrayFields = new Set();
-        for (const bodyStatement of constructor.body.statements) {
+        for (const bodyStatement of constructor.body.statements.nodes) {
             if (!ts.isExpressionStatement(bodyStatement) ||
                 !ts.isBinaryExpression(bodyStatement.expression))
                 continue;
@@ -294,10 +295,10 @@ export function applyNpmStaticFindReturnWidening(sourceFile, source) {
                 ts.isArrayLiteralExpression(right))
                 arrayFields.add(left.name.text);
         }
-        for (const member of statement.members) {
-            if (!ts.isMethodDeclaration(member) || member.body?.statements.length !== 1)
+        for (const member of statement.members.nodes) {
+            if (!ts.isMethodDeclaration(member) || member.body?.statements?.nodes.length !== 1)
                 continue;
-            const returned = member.body.statements[0];
+            const returned = member.body.statements.nodes[0];
             if (!returned ||
                 !ts.isReturnStatement(returned) ||
                 returned.expression === undefined ||
@@ -314,9 +315,9 @@ export function applyNpmStaticFindReturnWidening(sourceFile, source) {
             if (returnType === undefined ||
                 !ts.isTypeReferenceNode(returnType) ||
                 !ts.isIdentifier(returnType.typeName) ||
-                (returnType.typeArguments?.length ?? 0) !== 0)
+                (returnType.typeArguments?.nodes.length ?? 0) !== 0)
                 continue;
-            insertions.push({ offset: returnType.getEnd(), length: " | undefined".length });
+            insertions.push({ offset: returnType.end, length: " | undefined".length });
         }
     }
     if (insertions.length === 0)
@@ -342,7 +343,7 @@ function lastJsDocTag(node, kind) {
     const docs = node.jsDoc;
     if (docs === undefined || docs.length === 0)
         return undefined;
-    for (const tag of docs[docs.length - 1].tags ?? []) {
+    for (const tag of docs[docs.length - 1].tags?.nodes ?? []) {
         if (tag.kind === kind)
             return tag;
     }
@@ -372,7 +373,7 @@ function jsDocReturnTypeOf(node) {
     if (type === undefined)
         return undefined;
     if (ts.isTypeLiteralNode(type)) {
-        return type.members.find(ts.isCallSignatureDeclaration)?.type;
+        return type.members.nodes.find(ts.isCallSignatureDeclaration)?.type;
     }
     return ts.isFunctionTypeNode(type) ? type.type : undefined;
 }
@@ -380,55 +381,55 @@ function hasModifier(node, kind) {
     return (ts.canHaveModifiers(node) &&
         (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === kind));
 }
-function safeTypeText(node, sourceFile, className) {
+function safeTypeText(node, className) {
     if (SAFE_KEYWORD_TYPES.has(node.kind) || ts.isThisTypeNode(node))
-        return node.getText(sourceFile);
+        return getTextOfNode(node);
     if (ts.isLiteralTypeNode(node) && node.literal.kind === ts.SyntaxKind.NullKeyword)
         return "null";
     if (ts.isParenthesizedTypeNode(node)) {
-        const inner = safeTypeText(node.type, sourceFile, className);
+        const inner = safeTypeText(node.type, className);
         return inner === null ? null : `(${inner})`;
     }
     if (ts.isArrayTypeNode(node)) {
-        const element = safeTypeText(node.elementType, sourceFile, className);
+        const element = safeTypeText(node.elementType, className);
         return element === null ? null : `${element}[]`;
     }
     if (ts.isTypeOperatorNode(node) && node.operator === ts.SyntaxKind.ReadonlyKeyword) {
-        return safeTypeText(node.type, sourceFile, className);
+        return safeTypeText(node.type, className);
     }
     if (ts.isUnionTypeNode(node)) {
-        const arms = node.types.map((type) => safeTypeText(type, sourceFile, className));
+        const arms = node.types.nodes.map((type) => safeTypeText(type, className));
         return arms.some((arm) => arm === null) ? null : arms.join(" | ");
     }
     if (ts.isTypeReferenceNode(node) &&
         ts.isIdentifier(node.typeName) &&
         node.typeName.text === "Record" &&
-        node.typeArguments?.length === 2 &&
-        node.typeArguments[0]?.kind === ts.SyntaxKind.StringKeyword &&
-        node.typeArguments[1]?.kind === ts.SyntaxKind.StringKeyword) {
+        node.typeArguments?.nodes.length === 2 &&
+        node.typeArguments.nodes[0]?.kind === ts.SyntaxKind.StringKeyword &&
+        node.typeArguments.nodes[1]?.kind === ts.SyntaxKind.StringKeyword) {
         return "Record<string, string>";
     }
     return ts.isTypeReferenceNode(node) &&
         ts.isIdentifier(node.typeName) &&
         node.typeName.text === className &&
-        (node.typeArguments?.length ?? 0) === 0
+        (node.typeArguments?.nodes.length ?? 0) === 0
         ? className
         : null;
 }
 function overloadSignature(sourceFile, className, method) {
     if (!ts.isIdentifier(method.name) ||
         method.type === undefined ||
-        (method.typeParameters?.length ?? 0) !== 0 ||
+        (method.typeParameters?.nodes.length ?? 0) !== 0 ||
         hasModifier(method, ts.SyntaxKind.StaticKeyword) ||
         hasModifier(method, ts.SyntaxKind.PrivateKeyword) ||
         hasModifier(method, ts.SyntaxKind.ProtectedKeyword)) {
         return null;
     }
-    const returnType = safeTypeText(method.type, sourceFile, className);
+    const returnType = safeTypeText(method.type, className);
     if (returnType === null)
         return null;
     const parameters = [];
-    for (const parameter of method.parameters) {
+    for (const parameter of method.parameters.nodes) {
         if (!ts.isIdentifier(parameter.name) ||
             parameter.name.text === "this" ||
             parameter.type === undefined ||
@@ -436,7 +437,7 @@ function overloadSignature(sourceFile, className, method) {
             parameter.dotDotDotToken !== undefined) {
             return null;
         }
-        const type = safeTypeText(parameter.type, sourceFile, className);
+        const type = safeTypeText(parameter.type, className);
         if (type === null)
             return null;
         parameters.push({
@@ -451,17 +452,17 @@ function overloadSignature(sourceFile, className, method) {
  * contracts from exported non-generic classes. */
 export function parseNpmStaticDeclarationOverloads(sourceFile) {
     const classes = new Map();
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (!ts.isClassDeclaration(statement) ||
             statement.name === undefined ||
-            (statement.typeParameters?.length ?? 0) !== 0 ||
+            (statement.typeParameters?.nodes.length ?? 0) !== 0 ||
             !hasModifier(statement, ts.SyntaxKind.ExportKeyword) ||
             hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
             continue;
         }
         const className = statement.name.text;
         const groups = new Map();
-        for (const member of statement.members) {
+        for (const member of statement.members.nodes) {
             if (!ts.isMethodDeclaration(member) || !ts.isIdentifier(member.name))
                 continue;
             const group = groups.get(member.name.text) ?? [];
@@ -487,25 +488,25 @@ export function parseNpmStaticDeclarationOverloads(sourceFile) {
     }
     return classes;
 }
-function nullableSelfType(node, sourceFile, className) {
-    if (!ts.isUnionTypeNode(node) || node.types.length !== 2)
+function nullableSelfType(node, className) {
+    if (!ts.isUnionTypeNode(node) || node.types.nodes.length !== 2)
         return null;
-    const arms = node.types.map((type) => safeTypeText(type, sourceFile, className));
+    const arms = node.types.nodes.map((type) => safeTypeText(type, className));
     return arms.includes(className) && arms.includes("null") ? `${className} | null` : null;
 }
 function nullableVoidCallbackType(node) {
-    if (!ts.isUnionTypeNode(node) || node.types.length !== 2)
+    if (!ts.isUnionTypeNode(node) || node.types.nodes.length !== 2)
         return null;
     let callback = false;
     let nullable = false;
-    for (let arm of node.types) {
+    for (let arm of node.types.nodes) {
         while (ts.isParenthesizedTypeNode(arm))
             arm = arm.type;
         if (ts.isLiteralTypeNode(arm) && arm.literal.kind === ts.SyntaxKind.NullKeyword)
             nullable = true;
         else if (ts.isFunctionTypeNode(arm) &&
-            arm.parameters.length === 0 &&
-            (arm.typeParameters?.length ?? 0) === 0 &&
+            arm.parameters.nodes.length === 0 &&
+            (arm.typeParameters?.nodes.length ?? 0) === 0 &&
             arm.type?.kind === ts.SyntaxKind.VoidKeyword)
             callback = true;
         else
@@ -516,17 +517,17 @@ function nullableVoidCallbackType(node) {
 /** Extracts nullable self links and zero-argument void callback fields. */
 export function parseNpmStaticDeclarationProperties(sourceFile) {
     const classes = new Map();
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (!ts.isClassDeclaration(statement) ||
             statement.name === undefined ||
-            (statement.typeParameters?.length ?? 0) !== 0 ||
+            (statement.typeParameters?.nodes.length ?? 0) !== 0 ||
             !hasModifier(statement, ts.SyntaxKind.ExportKeyword) ||
             hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
             continue;
         }
         const className = statement.name.text;
         const properties = new Map();
-        for (const member of statement.members) {
+        for (const member of statement.members.nodes) {
             if (!ts.isPropertyDeclaration(member) ||
                 !ts.isIdentifier(member.name) ||
                 member.type === undefined ||
@@ -536,8 +537,7 @@ export function parseNpmStaticDeclarationProperties(sourceFile) {
                 hasModifier(member, ts.SyntaxKind.ProtectedKeyword)) {
                 continue;
             }
-            const type = nullableSelfType(member.type, sourceFile, className) ??
-                nullableVoidCallbackType(member.type);
+            const type = nullableSelfType(member.type, className) ?? nullableVoidCallbackType(member.type);
             if (type !== null)
                 properties.set(member.name.text, type);
         }
@@ -550,7 +550,7 @@ export function parseNpmStaticDeclarationProperties(sourceFile) {
  * caller's package-bounded resolution. Bare type dependencies deliberately
  * do not inherit the opted package's declaration trust. */
 export function npmStaticDeclarationReexports(sourceFile) {
-    return sourceFile.statements.flatMap((statement) => ts.isExportDeclaration(statement) &&
+    return sourceFile.statements.nodes.flatMap((statement) => ts.isExportDeclaration(statement) &&
         statement.moduleSpecifier !== undefined &&
         ts.isStringLiteral(statement.moduleSpecifier) &&
         statement.moduleSpecifier.text.startsWith(".")
@@ -559,13 +559,13 @@ export function npmStaticDeclarationReexports(sourceFile) {
 }
 function requireSpecifier(expression) {
     const argument = expression !== undefined && ts.isCallExpression(expression)
-        ? expression.arguments[0]
+        ? expression.arguments.nodes[0]
         : undefined;
     return expression !== undefined &&
         ts.isCallExpression(expression) &&
         ts.isIdentifier(expression.expression) &&
         expression.expression.text === "require" &&
-        expression.arguments.length === 1 &&
+        expression.arguments.nodes.length === 1 &&
         argument !== undefined &&
         ts.isStringLiteralLike(argument)
         ? argument.text
@@ -575,17 +575,17 @@ function requireSpecifier(expression) {
  * Named ESM aliases preserve the implementation's exported name, including
  * bundler-renamed classes. Multi-hop re-exports remain outside this slice. */
 export function npmStaticRuntimeClassTargets(sourceFile, source, classNames) {
-    const localClasses = new Set(sourceFile.statements.flatMap((statement) => ts.isClassDeclaration(statement) && statement.name !== undefined ? [statement.name.text] : []));
+    const localClasses = new Set(sourceFile.statements.nodes.flatMap((statement) => ts.isClassDeclaration(statement) && statement.name !== undefined ? [statement.name.text] : []));
     const linked = new Map();
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (ts.isVariableStatement(statement)) {
-            for (const declaration of statement.declarationList.declarations) {
+            for (const declaration of statement.declarationList.declarations.nodes) {
                 const specifier = requireSpecifier(declaration.initializer);
                 if (specifier === null ||
                     !specifier.startsWith(".") ||
                     !ts.isObjectBindingPattern(declaration.name))
                     continue;
-                for (const element of declaration.name.elements) {
+                for (const element of declaration.name.elements.nodes) {
                     if (element.dotDotDotToken !== undefined || !ts.isIdentifier(element.name))
                         continue;
                     const imported = element.propertyName !== undefined && ts.isIdentifier(element.propertyName)
@@ -602,7 +602,7 @@ export function npmStaticRuntimeClassTargets(sourceFile, source, classNames) {
             !statement.importClause?.isTypeOnly &&
             statement.importClause?.namedBindings !== undefined &&
             ts.isNamedImports(statement.importClause.namedBindings)) {
-            for (const element of statement.importClause.namedBindings.elements) {
+            for (const element of statement.importClause.namedBindings.elements.nodes) {
                 if (element.isTypeOnly)
                     continue;
                 linked.set(element.name.text, {
@@ -628,7 +628,7 @@ export function npmStaticRuntimeClassTargets(sourceFile, source, classNames) {
         else if (localClasses.has(local))
             targets.set(exported, { specifier: null, localName: local });
     };
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (ts.isClassDeclaration(statement) &&
             statement.name !== undefined &&
             hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
@@ -643,7 +643,7 @@ export function npmStaticRuntimeClassTargets(sourceFile, source, classNames) {
                 : undefined;
             if (specifier !== undefined && !specifier.startsWith("."))
                 continue;
-            for (const element of statement.exportClause.elements) {
+            for (const element of statement.exportClause.elements.nodes) {
                 if (!statement.isTypeOnly && !element.isTypeOnly) {
                     record(element.name.text, element.propertyName?.text ?? element.name.text, specifier, true);
                 }
@@ -670,7 +670,7 @@ export function npmStaticRuntimeClassTargets(sourceFile, source, classNames) {
             left.expression.text === "module" &&
             left.name.text === "exports" &&
             ts.isObjectLiteralExpression(right)) {
-            for (const property of right.properties) {
+            for (const property of right.properties.nodes) {
                 if (ts.isShorthandPropertyAssignment(property) && ts.isIdentifier(property.name))
                     record(property.name.text, property.name.text);
                 else if (ts.isPropertyAssignment(property) &&
@@ -685,7 +685,7 @@ export function npmStaticRuntimeClassTargets(sourceFile, source, classNames) {
 }
 function exportedClassNames(sourceFile) {
     const names = new Set();
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (ts.isClassDeclaration(statement) &&
             statement.name !== undefined &&
             hasModifier(statement, ts.SyntaxKind.ExportKeyword)) {
@@ -695,7 +695,7 @@ function exportedClassNames(sourceFile) {
         if (ts.isExportDeclaration(statement) &&
             statement.exportClause !== undefined &&
             ts.isNamedExports(statement.exportClause)) {
-            for (const element of statement.exportClause.elements)
+            for (const element of statement.exportClause.elements.nodes)
                 names.add(element.propertyName?.text ?? element.name.text);
             continue;
         }
@@ -720,7 +720,7 @@ function exportedClassNames(sourceFile) {
             left.expression.text === "module" &&
             left.name.text === "exports" &&
             ts.isObjectLiteralExpression(right)) {
-            for (const property of right.properties) {
+            for (const property of right.properties.nodes) {
                 if (ts.isShorthandPropertyAssignment(property) && ts.isIdentifier(property.name))
                     names.add(property.name.text);
                 else if (ts.isPropertyAssignment(property) &&
@@ -739,10 +739,10 @@ function overloadComment(signature) {
     return `/** @overload ${params.join(" ")} @returns {${signature.returnType}} */`;
 }
 function implementationComment(className, method, signatures) {
-    if (method.parameters.some((parameter) => !ts.isIdentifier(parameter.name) || parameter.dotDotDotToken !== undefined))
+    if (method.parameters.nodes.some((parameter) => !ts.isIdentifier(parameter.name) || parameter.dotDotDotToken !== undefined))
         return null;
     const maxParams = Math.max(...signatures.map((signature) => signature.parameters.length));
-    if (method.parameters.length !== maxParams)
+    if (method.parameters.nodes.length !== maxParams)
         return null;
     const params = [];
     for (let index = 0; index < maxParams; index++) {
@@ -754,7 +754,7 @@ function implementationComment(className, method, signatures) {
         ];
         if (types.length === 0)
             return null;
-        const parameter = method.parameters[index];
+        const parameter = method.parameters.nodes[index];
         if (parameter === undefined || !ts.isIdentifier(parameter.name))
             return null;
         const name = parameter.name.text;
@@ -773,9 +773,9 @@ function directReturn(statement) {
     if (ts.isReturnStatement(statement))
         return statement;
     return ts.isBlock(statement) &&
-        statement.statements.length === 1 &&
-        ts.isReturnStatement(statement.statements[0])
-        ? statement.statements[0]
+        statement.statements.nodes.length === 1 &&
+        ts.isReturnStatement(statement.statements.nodes[0])
+        ? statement.statements.nodes[0]
         : null;
 }
 function undefinedParameterTest(expression, parameter) {
@@ -790,14 +790,14 @@ function undefinedParameterTest(expression, parameter) {
 }
 function overloadArrayBackingField(method, signatures) {
     if (method.body === undefined ||
-        method.parameters.length !== 1 ||
-        !ts.isIdentifier(method.parameters[0].name))
+        method.parameters.nodes.length !== 1 ||
+        !ts.isIdentifier(method.parameters.nodes[0].name))
         return null;
     const getters = signatures.filter((signature) => signature.parameters.length === 0 && signature.returnType.endsWith("[]"));
     if (getters.length !== 1)
         return null;
-    const parameter = method.parameters[0].name.text;
-    for (const statement of method.body.statements) {
+    const parameter = method.parameters.nodes[0].name.text;
+    for (const statement of method.body.statements.nodes) {
         if (!ts.isIfStatement(statement) || !undefinedParameterTest(statement.expression, parameter))
             continue;
         const returned = directReturn(statement.thenStatement);
@@ -816,7 +816,7 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
         return null;
     const exported = exportedClassNames(sourceFile);
     const inserts = [];
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (!ts.isClassDeclaration(statement) ||
             statement.name === undefined ||
             !exported.has(statement.name.text))
@@ -824,9 +824,9 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
         const classOverloads = declarations.get(statement.name.text);
         if (classOverloads === undefined)
             continue;
-        const constructor = statement.members.find((member) => ts.isConstructorDeclaration(member) && member.body !== undefined);
+        const constructor = statement.members.nodes.find((member) => ts.isConstructorDeclaration(member) && member.body !== undefined);
         const projectedFields = new Set();
-        for (const member of statement.members) {
+        for (const member of statement.members.nodes) {
             if (!ts.isMethodDeclaration(member) ||
                 !ts.isIdentifier(member.name) ||
                 member.body === undefined)
@@ -842,23 +842,23 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
             if (backing !== null &&
                 constructor?.body !== undefined &&
                 !projectedFields.has(backing.field)) {
-                for (const bodyStatement of constructor.body.statements) {
+                for (const bodyStatement of constructor.body.statements.nodes) {
                     if (!ts.isExpressionStatement(bodyStatement) ||
                         !ts.isBinaryExpression(bodyStatement.expression))
                         continue;
                     const { left, right, operatorToken } = bodyStatement.expression;
                     if (operatorToken.kind !== ts.SyntaxKind.EqualsToken ||
                         !ts.isArrayLiteralExpression(right) ||
-                        right.elements.length !== 0 ||
+                        right.elements.nodes.length !== 0 ||
                         !ts.isPropertyAccessExpression(left) ||
                         left.expression.kind !== ts.SyntaxKind.ThisKeyword ||
                         left.name.text !== backing.field) {
                         continue;
                     }
-                    const leading = source.slice(bodyStatement.getFullStart(), bodyStatement.getStart(sourceFile));
+                    const leading = source.slice(bodyStatement.pos, tokenStartOfNode(bodyStatement));
                     if (!leading.includes("@type")) {
                         inserts.push({
-                            offset: bodyStatement.getStart(sourceFile),
+                            offset: tokenStartOfNode(bodyStatement),
                             text: `/** @type {${backing.type}} */ `,
                         });
                     }
@@ -875,11 +875,11 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
                     const existing = jsDocs.map((doc) => source.slice(doc.pos, doc.end)).join("\n");
                     const missingOptional = signatures[0].parameters.some((parameter) => parameter.optional && !existing.includes(`[${parameter.name}]`));
                     if (missingOptional)
-                        inserts.push({ offset: member.getStart(sourceFile), text: `${implementation} ` });
+                        inserts.push({ offset: tokenStartOfNode(member), text: `${implementation} ` });
                     else if (jsDocs.length === 0 &&
-                        member.parameters.length === 0 &&
+                        member.parameters.nodes.length === 0 &&
                         SCALAR_METHOD_RETURNS.has(signatures[0].returnType)) {
-                        inserts.push({ offset: member.getStart(sourceFile), text: `${implementation} ` });
+                        inserts.push({ offset: tokenStartOfNode(member), text: `${implementation} ` });
                     }
                 }
                 continue;
@@ -887,7 +887,8 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
             const implementation = jsDocs.length === 0 ? implementationComment(statement.name.text, member, signatures) : null;
             if (jsDocs.length === 0 && implementation === null)
                 continue;
-            const offset = jsDocs[0]?.getStart(sourceFile) ?? member.getStart(sourceFile);
+            const offset = (jsDocs[0] === undefined ? undefined : tokenStartOfNode(jsDocs[0])) ??
+                tokenStartOfNode(member);
             const text = `${signatures.map(overloadComment).join(" ")} ${implementation === null ? "" : implementation + " "}`;
             inserts.push({ offset, text });
         }
@@ -922,7 +923,7 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
     const exported = exportedClassNames(sourceFile);
     const inserts = [];
     const classes = new Map();
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (ts.isClassDeclaration(statement) && statement.name !== undefined)
             classes.set(statement.name.text, statement);
     }
@@ -936,7 +937,7 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
             return new Map();
         collecting.add(name);
         const statement = classes.get(name);
-        const base = statement?.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0]?.expression;
+        const base = statement?.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
         const properties = new Map();
         if (base && ts.isIdentifier(base) && classes.has(base.text)) {
             // Self-link types belong to their own class. Only the callback ABI
@@ -958,8 +959,8 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
     };
     const callbackInitializer = (node) => {
         if (!ts.isArrowFunction(node) ||
-            node.parameters.length !== 0 ||
-            (node.typeParameters?.length ?? 0) !== 0 ||
+            node.parameters.nodes.length !== 0 ||
+            (node.typeParameters?.nodes.length ?? 0) !== 0 ||
             hasModifier(node, ts.SyntaxKind.AsyncKeyword) ||
             !ts.isBlock(node.body))
             return false;
@@ -975,13 +976,13 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
         };
         return returnsValue(node.body) !== true;
     };
-    for (const statement of sourceFile.statements) {
+    for (const statement of sourceFile.statements.nodes) {
         if (!ts.isClassDeclaration(statement) || statement.name === undefined)
             continue;
         const properties = propertiesOf(statement.name.text);
         if (properties.size === 0)
             continue;
-        for (const member of statement.members) {
+        for (const member of statement.members.nodes) {
             if (!ts.isPropertyDeclaration(member) ||
                 !ts.isIdentifier(member.name) ||
                 member.initializer === undefined ||
@@ -992,15 +993,15 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
                 (member.initializer.kind !== ts.SyntaxKind.NullKeyword &&
                     !callbackInitializer(member.initializer)))
                 continue;
-            const leading = source.slice(member.getFullStart(), member.getStart(sourceFile));
+            const leading = source.slice(member.pos, tokenStartOfNode(member));
             if (jsDocTypeOf(member) !== undefined || leading.includes("@type"))
                 continue;
-            inserts.push({ offset: member.getStart(sourceFile), text: `/** @type {${type}} */ ` });
+            inserts.push({ offset: tokenStartOfNode(member), text: `/** @type {${type}} */ ` });
         }
-        const constructor = statement.members.find((member) => ts.isConstructorDeclaration(member) && member.body !== undefined);
+        const constructor = statement.members.nodes.find((member) => ts.isConstructorDeclaration(member) && member.body !== undefined);
         if (constructor?.body === undefined)
             continue;
-        for (const bodyStatement of constructor.body.statements) {
+        for (const bodyStatement of constructor.body.statements.nodes) {
             if (!ts.isExpressionStatement(bodyStatement) ||
                 !ts.isBinaryExpression(bodyStatement.expression))
                 continue;
@@ -1014,10 +1015,10 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
             const type = properties.get(left.name.text);
             if (type === undefined)
                 continue;
-            const leading = source.slice(bodyStatement.getFullStart(), bodyStatement.getStart(sourceFile));
+            const leading = source.slice(bodyStatement.pos, tokenStartOfNode(bodyStatement));
             if (leading.includes("@type"))
                 continue;
-            inserts.push({ offset: bodyStatement.getStart(sourceFile), text: `/** @type {${type}} */ ` });
+            inserts.push({ offset: tokenStartOfNode(bodyStatement), text: `/** @type {${type}} */ ` });
         }
     }
     if (inserts.length === 0)