@scriptc/compiler 0.2.4 → 0.2.6

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

@@ -91,7 +91,8 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
         }
     }
     const assignment = (node) => ts.isBinaryExpression(node) &&
-        node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && node.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
+        node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+        node.operatorToken.kind <= ts.SyntaxKind.LastAssignment;
     // Mutable constructor bindings cannot supply a stable nominal type.
     const rejectAssignedName = (node) => {
         if (ts.isIdentifier(node))
@@ -116,10 +117,12 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
     const rejectMutable = (node) => {
         if (assignment(node))
             rejectAssignedName(node.left);
-        if ((ts.isForInStatement(node) || ts.isForOfStatement(node)) && !ts.isVariableDeclarationList(node.initializer))
+        if ((ts.isForInStatement(node) || ts.isForOfStatement(node)) &&
+            !ts.isVariableDeclarationList(node.initializer))
             rejectAssignedName(node.initializer);
         if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-            (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken) &&
+            (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                node.operator === ts.SyntaxKind.MinusMinusToken) &&
             ts.isIdentifier(node.operand))
             constructors.delete(node.operand.text);
         ts.forEachChild(node, rejectMutable);
@@ -131,8 +134,10 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
             continue;
         const fields = new Map();
         for (const member of statement.members) {
-            if (!ts.isPropertyDeclaration(member) || !ts.isIdentifier(member.name) ||
-                member.initializer?.kind !== ts.SyntaxKind.NullKeyword || hasModifier(member, ts.SyntaxKind.StaticKeyword))
+            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));
             if (jsDocTypeOf(member) !== undefined || leading.includes("@type"))
@@ -155,7 +160,11 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
         const collectBindings = (node) => {
             if ((ts.isParameter(node) || ts.isVariableDeclaration(node)) && node.name !== undefined)
                 bindingNames(node.name);
-            if ((ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isClassDeclaration(node) || ts.isClassExpression(node)) && node.name)
+            if ((ts.isFunctionDeclaration(node) ||
+                ts.isFunctionExpression(node) ||
+                ts.isClassDeclaration(node) ||
+                ts.isClassExpression(node)) &&
+                node.name)
                 shadowed.add(node.name.text);
             ts.forEachChild(node, collectBindings);
         };
@@ -164,7 +173,8 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
         const targetField = (node) => {
             if (ts.isPropertyAccessExpression(node) && node.expression.kind === ts.SyntaxKind.ThisKeyword)
                 return node.name.text;
-            if (ts.isElementAccessExpression(node) && node.expression.kind === ts.SyntaxKind.ThisKeyword) {
+            if (ts.isElementAccessExpression(node) &&
+                node.expression.kind === ts.SyntaxKind.ThisKeyword) {
                 return ts.isStringLiteral(node.argumentExpression) ? node.argumentExpression.text : "*";
             }
             return null;
@@ -179,7 +189,9 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
             ts.forEachChild(node, invalidate);
         };
         const visit = (node) => {
-            if ((ts.isFunctionLike(node) && !ts.isArrowFunction(node)) || ts.isClassDeclaration(node) || ts.isClassExpression(node))
+            if ((ts.isFunctionLike(node) && !ts.isArrowFunction(node)) ||
+                ts.isClassDeclaration(node) ||
+                ts.isClassExpression(node))
                 return;
             if (assignment(node)) {
                 const name = targetField(node.left);
@@ -189,14 +201,27 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
                     while (ts.isParenthesizedExpression(value))
                         value = value.expression;
                     if (value.kind !== ts.SyntaxKind.NullKeyword) {
-                        const construct = ts.isNewExpression(value) && ts.isIdentifier(value.expression) ? value.expression : null;
-                        const factory = ts.isCallExpression(value) && !value.questionDotToken && ts.isPropertyAccessExpression(value.expression) &&
-                            !value.expression.questionDotToken && ts.isIdentifier(value.expression.name) && ts.isIdentifier(value.expression.expression) ? value.expression : null;
+                        const construct = ts.isNewExpression(value) && ts.isIdentifier(value.expression)
+                            ? value.expression
+                            : null;
+                        const factory = ts.isCallExpression(value) &&
+                            !value.questionDotToken &&
+                            ts.isPropertyAccessExpression(value.expression) &&
+                            !value.expression.questionDotToken &&
+                            ts.isIdentifier(value.expression.name) &&
+                            ts.isIdentifier(value.expression.expression)
+                            ? value.expression
+                            : null;
                         const owner = construct ?? factory?.expression;
-                        if (owner && ts.isIdentifier(owner) && constructors.has(owner.text) && !shadowed.has(owner.text)) {
+                        if (owner &&
+                            ts.isIdentifier(owner) &&
+                            constructors.has(owner.text) &&
+                            !shadowed.has(owner.text)) {
                             // ReturnType asks the same implementation checker that types
                             // the call; no declaration-only class name is invented.
-                            const name = factory ? `ReturnType<typeof ${owner.text}.${factory.name.text}>` : owner.text;
+                            const name = factory
+                                ? `ReturnType<typeof ${owner.text}.${factory.name.text}>`
+                                : owner.text;
                             if (field.className !== undefined && field.className !== name)
                                 field.invalid = true;
                             field.className = name;
@@ -209,7 +234,8 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
                     invalidate(node.left);
             }
             if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
-                (node.operator === ts.SyntaxKind.PlusPlusToken || node.operator === ts.SyntaxKind.MinusMinusToken))
+                (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                    node.operator === ts.SyntaxKind.MinusMinusToken))
                 invalidate(node.operand);
             if (ts.isDeleteExpression(node))
                 invalidate(node.expression);
@@ -218,7 +244,10 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
         for (const member of statement.members) {
             if (hasModifier(member, ts.SyntaxKind.StaticKeyword))
                 continue;
-            if ((ts.isConstructorDeclaration(member) || ts.isMethodDeclaration(member) || ts.isAccessor(member)) && member.body)
+            if ((ts.isConstructorDeclaration(member) ||
+                ts.isMethodDeclaration(member) ||
+                ts.isAccessor(member)) &&
+                member.body)
                 visit(member.body);
             if (ts.isPropertyDeclaration(member) && member.initializer)
                 visit(member.initializer);
@@ -226,7 +255,10 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
         for (const field of fields.values()) {
             if (field.invalid || field.className === undefined)
                 continue;
-            inserts.push({ offset: field.member.getStart(sourceFile), text: `/** @type {${field.className} | null} */ ` });
+            inserts.push({
+                offset: field.member.getStart(sourceFile),
+                text: `/** @type {${field.className} | null} */ `,
+            });
         }
     }
     if (inserts.length === 0)
@@ -234,7 +266,10 @@ export function applyNpmStaticNullableClassFields(sourceFile, source) {
     let text = source;
     for (const insert of [...inserts].sort((a, b) => b.offset - a.offset))
         text = text.slice(0, insert.offset) + insert.text + text.slice(insert.offset);
-    return { text, insertions: inserts.map((insert) => ({ offset: insert.offset, length: insert.text.length })) };
+    return {
+        text,
+        insertions: inserts.map((insert) => ({ offset: insert.offset, length: insert.text.length })),
+    };
 }
 /** A JavaScript return annotation cannot make Array.find return a value
  * when no element matches. Widen only direct finds on constructor-owned
@@ -249,28 +284,37 @@ export function applyNpmStaticFindReturnWidening(sourceFile, source) {
             continue;
         const arrayFields = new Set();
         for (const bodyStatement of constructor.body.statements) {
-            if (!ts.isExpressionStatement(bodyStatement) || !ts.isBinaryExpression(bodyStatement.expression))
+            if (!ts.isExpressionStatement(bodyStatement) ||
+                !ts.isBinaryExpression(bodyStatement.expression))
                 continue;
             const { left, right, operatorToken } = bodyStatement.expression;
-            if (operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(left) &&
-                left.expression.kind === ts.SyntaxKind.ThisKeyword && ts.isArrayLiteralExpression(right))
+            if (operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                ts.isPropertyAccessExpression(left) &&
+                left.expression.kind === ts.SyntaxKind.ThisKeyword &&
+                ts.isArrayLiteralExpression(right))
                 arrayFields.add(left.name.text);
         }
         for (const member of statement.members) {
             if (!ts.isMethodDeclaration(member) || member.body?.statements.length !== 1)
                 continue;
             const returned = member.body.statements[0];
-            if (!returned || !ts.isReturnStatement(returned) || returned.expression === undefined || !ts.isCallExpression(returned.expression))
+            if (!returned ||
+                !ts.isReturnStatement(returned) ||
+                returned.expression === undefined ||
+                !ts.isCallExpression(returned.expression))
                 continue;
             const callee = returned.expression.expression;
-            if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== "find" ||
+            if (!ts.isPropertyAccessExpression(callee) ||
+                callee.name.text !== "find" ||
                 !ts.isPropertyAccessExpression(callee.expression) ||
                 callee.expression.expression.kind !== ts.SyntaxKind.ThisKeyword ||
                 !arrayFields.has(callee.expression.name.text))
                 continue;
             const returnType = jsDocReturnTypeOf(member);
-            if (returnType === undefined || !ts.isTypeReferenceNode(returnType) ||
-                !ts.isIdentifier(returnType.typeName) || (returnType.typeArguments?.length ?? 0) !== 0)
+            if (returnType === undefined ||
+                !ts.isTypeReferenceNode(returnType) ||
+                !ts.isIdentifier(returnType.typeName) ||
+                (returnType.typeArguments?.length ?? 0) !== 0)
                 continue;
             insertions.push({ offset: returnType.getEnd(), length: " | undefined".length });
         }
@@ -309,7 +353,9 @@ function lastJsDocTag(node, kind) {
  * describes the expression rather than the property's storage type. */
 function jsDocTagType(node, kind) {
     let tag;
-    if (ts.isPropertyDeclaration(node) && node.initializer !== undefined && !ts.isParenthesizedExpression(node.initializer)) {
+    if (ts.isPropertyDeclaration(node) &&
+        node.initializer !== undefined &&
+        !ts.isParenthesizedExpression(node.initializer)) {
         tag = lastJsDocTag(node.initializer, kind);
     }
     tag ??= lastJsDocTag(node, kind);
@@ -331,7 +377,8 @@ function jsDocReturnTypeOf(node) {
     return ts.isFunctionTypeNode(type) ? type.type : undefined;
 }
 function hasModifier(node, kind) {
-    return ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === kind);
+    return (ts.canHaveModifiers(node) &&
+        (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === kind));
 }
 function safeTypeText(node, sourceFile, className) {
     if (SAFE_KEYWORD_TYPES.has(node.kind) || ts.isThisTypeNode(node))
@@ -430,7 +477,8 @@ export function parseNpmStaticDeclarationOverloads(sourceFile) {
                 continue;
             if (signatures.length === 1 &&
                 !signatures[0].parameters.some((parameter) => parameter.optional) &&
-                !(signatures[0].parameters.length === 0 && SCALAR_METHOD_RETURNS.has(signatures[0].returnType)))
+                !(signatures[0].parameters.length === 0 &&
+                    SCALAR_METHOD_RETURNS.has(signatures[0].returnType)))
                 continue;
             overloads.set(name, signatures);
         }
@@ -455,8 +503,10 @@ function nullableVoidCallbackType(node) {
             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.type?.kind === ts.SyntaxKind.VoidKeyword)
+        else if (ts.isFunctionTypeNode(arm) &&
+            arm.parameters.length === 0 &&
+            (arm.typeParameters?.length ?? 0) === 0 &&
+            arm.type?.kind === ts.SyntaxKind.VoidKeyword)
             callback = true;
         else
             return null;
@@ -486,7 +536,8 @@ 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, sourceFile, className) ??
+                nullableVoidCallbackType(member.type);
             if (type !== null)
                 properties.set(member.name.text, type);
         }
@@ -507,7 +558,9 @@ export function npmStaticDeclarationReexports(sourceFile) {
         : []);
 }
 function requireSpecifier(expression) {
-    const argument = expression !== undefined && ts.isCallExpression(expression) ? expression.arguments[0] : undefined;
+    const argument = expression !== undefined && ts.isCallExpression(expression)
+        ? expression.arguments[0]
+        : undefined;
     return expression !== undefined &&
         ts.isCallExpression(expression) &&
         ts.isIdentifier(expression.expression) &&
@@ -528,7 +581,9 @@ export function npmStaticRuntimeClassTargets(sourceFile, source, classNames) {
         if (ts.isVariableStatement(statement)) {
             for (const declaration of statement.declarationList.declarations) {
                 const specifier = requireSpecifier(declaration.initializer);
-                if (specifier === null || !specifier.startsWith(".") || !ts.isObjectBindingPattern(declaration.name))
+                if (specifier === null ||
+                    !specifier.startsWith(".") ||
+                    !ts.isObjectBindingPattern(declaration.name))
                     continue;
                 for (const element of declaration.name.elements) {
                     if (element.dotDotDotToken !== undefined || !ts.isIdentifier(element.name))
@@ -580,7 +635,9 @@ export function npmStaticRuntimeClassTargets(sourceFile, source, classNames) {
             record(statement.name.text, statement.name.text);
             continue;
         }
-        if (ts.isExportDeclaration(statement) && statement.exportClause !== undefined && ts.isNamedExports(statement.exportClause)) {
+        if (ts.isExportDeclaration(statement) &&
+            statement.exportClause !== undefined &&
+            ts.isNamedExports(statement.exportClause)) {
             const specifier = statement.moduleSpecifier !== undefined && ts.isStringLiteral(statement.moduleSpecifier)
                 ? statement.moduleSpecifier.text
                 : undefined;
@@ -635,7 +692,9 @@ function exportedClassNames(sourceFile) {
             names.add(statement.name.text);
             continue;
         }
-        if (ts.isExportDeclaration(statement) && statement.exportClause !== undefined && ts.isNamedExports(statement.exportClause)) {
+        if (ts.isExportDeclaration(statement) &&
+            statement.exportClause !== undefined &&
+            ts.isNamedExports(statement.exportClause)) {
             for (const element of statement.exportClause.elements)
                 names.add(element.propertyName?.text ?? element.name.text);
             continue;
@@ -687,10 +746,12 @@ function implementationComment(className, method, signatures) {
         return null;
     const params = [];
     for (let index = 0; index < maxParams; index++) {
-        const types = [...new Set(signatures.flatMap((signature) => {
+        const types = [
+            ...new Set(signatures.flatMap((signature) => {
                 const type = signature.parameters[index]?.type;
                 return type === undefined ? [] : [type];
-            }))];
+            })),
+        ];
         if (types.length === 0)
             return null;
         const parameter = method.parameters[index];
@@ -703,24 +764,34 @@ function implementationComment(className, method, signatures) {
         });
         params.push(`@param {${types.join(" | ")}} ${optional ? `[${name}]` : name}`);
     }
-    const returns = [...new Set(signatures.map((signature) => signature.returnType.replace(/\bthis\b/g, className)))];
+    const returns = [
+        ...new Set(signatures.map((signature) => signature.returnType.replace(/\bthis\b/g, className))),
+    ];
     return `/** ${params.join(" ")} @returns {${returns.join(" | ")}} */`;
 }
 function directReturn(statement) {
     if (ts.isReturnStatement(statement))
         return statement;
-    return ts.isBlock(statement) && statement.statements.length === 1 && ts.isReturnStatement(statement.statements[0])
+    return ts.isBlock(statement) &&
+        statement.statements.length === 1 &&
+        ts.isReturnStatement(statement.statements[0])
         ? statement.statements[0]
         : null;
 }
 function undefinedParameterTest(expression, parameter) {
-    if (!ts.isBinaryExpression(expression) || expression.operatorToken.kind !== ts.SyntaxKind.EqualsEqualsEqualsToken)
+    if (!ts.isBinaryExpression(expression) ||
+        expression.operatorToken.kind !== ts.SyntaxKind.EqualsEqualsEqualsToken)
         return false;
-    const matches = (left, right) => ts.isIdentifier(left) && left.text === parameter && ts.isIdentifier(right) && right.text === "undefined";
+    const matches = (left, right) => ts.isIdentifier(left) &&
+        left.text === parameter &&
+        ts.isIdentifier(right) &&
+        right.text === "undefined";
     return matches(expression.left, expression.right) || matches(expression.right, expression.left);
 }
 function overloadArrayBackingField(method, signatures) {
-    if (method.body === undefined || method.parameters.length !== 1 || !ts.isIdentifier(method.parameters[0].name))
+    if (method.body === undefined ||
+        method.parameters.length !== 1 ||
+        !ts.isIdentifier(method.parameters[0].name))
         return null;
     const getters = signatures.filter((signature) => signature.parameters.length === 0 && signature.returnType.endsWith("[]"));
     if (getters.length !== 1)
@@ -746,7 +817,9 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
     const exported = exportedClassNames(sourceFile);
     const inserts = [];
     for (const statement of sourceFile.statements) {
-        if (!ts.isClassDeclaration(statement) || statement.name === undefined || !exported.has(statement.name.text))
+        if (!ts.isClassDeclaration(statement) ||
+            statement.name === undefined ||
+            !exported.has(statement.name.text))
             continue;
         const classOverloads = declarations.get(statement.name.text);
         if (classOverloads === undefined)
@@ -754,21 +827,29 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
         const constructor = statement.members.find((member) => ts.isConstructorDeclaration(member) && member.body !== undefined);
         const projectedFields = new Set();
         for (const member of statement.members) {
-            if (!ts.isMethodDeclaration(member) || !ts.isIdentifier(member.name) || member.body === undefined)
+            if (!ts.isMethodDeclaration(member) ||
+                !ts.isIdentifier(member.name) ||
+                member.body === undefined)
                 continue;
             const signatures = classOverloads.get(member.name.text);
             if (signatures === undefined)
                 continue;
-            if (hasModifier(member, ts.SyntaxKind.StaticKeyword) || hasModifier(member, ts.SyntaxKind.AsyncKeyword) || member.asteriskToken !== undefined)
+            if (hasModifier(member, ts.SyntaxKind.StaticKeyword) ||
+                hasModifier(member, ts.SyntaxKind.AsyncKeyword) ||
+                member.asteriskToken !== undefined)
                 continue;
             const backing = overloadArrayBackingField(member, signatures);
-            if (backing !== null && constructor?.body !== undefined && !projectedFields.has(backing.field)) {
+            if (backing !== null &&
+                constructor?.body !== undefined &&
+                !projectedFields.has(backing.field)) {
                 for (const bodyStatement of constructor.body.statements) {
-                    if (!ts.isExpressionStatement(bodyStatement) || !ts.isBinaryExpression(bodyStatement.expression))
+                    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 ||
+                        !ts.isArrayLiteralExpression(right) ||
+                        right.elements.length !== 0 ||
                         !ts.isPropertyAccessExpression(left) ||
                         left.expression.kind !== ts.SyntaxKind.ThisKeyword ||
                         left.name.text !== backing.field) {
@@ -776,7 +857,10 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
                     }
                     const leading = source.slice(bodyStatement.getFullStart(), bodyStatement.getStart(sourceFile));
                     if (!leading.includes("@type")) {
-                        inserts.push({ offset: bodyStatement.getStart(sourceFile), text: `/** @type {${backing.type}} */ ` });
+                        inserts.push({
+                            offset: bodyStatement.getStart(sourceFile),
+                            text: `/** @type {${backing.type}} */ `,
+                        });
                     }
                     projectedFields.add(backing.field);
                     break;
@@ -792,7 +876,9 @@ export function applyNpmStaticDeclarationOverloads(sourceFile, source, declarati
                     const missingOptional = signatures[0].parameters.some((parameter) => parameter.optional && !existing.includes(`[${parameter.name}]`));
                     if (missingOptional)
                         inserts.push({ offset: member.getStart(sourceFile), text: `${implementation} ` });
-                    else if (jsDocs.length === 0 && member.parameters.length === 0 && SCALAR_METHOD_RETURNS.has(signatures[0].returnType)) {
+                    else if (jsDocs.length === 0 &&
+                        member.parameters.length === 0 &&
+                        SCALAR_METHOD_RETURNS.has(signatures[0].returnType)) {
                         inserts.push({ offset: member.getStart(sourceFile), text: `${implementation} ` });
                     }
                 }
@@ -871,8 +957,10 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
         return properties;
     };
     const callbackInitializer = (node) => {
-        if (!ts.isArrowFunction(node) || node.parameters.length !== 0 ||
-            (node.typeParameters?.length ?? 0) !== 0 || hasModifier(node, ts.SyntaxKind.AsyncKeyword) ||
+        if (!ts.isArrowFunction(node) ||
+            node.parameters.length !== 0 ||
+            (node.typeParameters?.length ?? 0) !== 0 ||
+            hasModifier(node, ts.SyntaxKind.AsyncKeyword) ||
             !ts.isBlock(node.body))
             return false;
         // A void callback contract permits value-returning implementations in
@@ -894,12 +982,15 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
         if (properties.size === 0)
             continue;
         for (const member of statement.members) {
-            if (!ts.isPropertyDeclaration(member) || !ts.isIdentifier(member.name) ||
-                member.initializer === undefined || hasModifier(member, ts.SyntaxKind.StaticKeyword))
+            if (!ts.isPropertyDeclaration(member) ||
+                !ts.isIdentifier(member.name) ||
+                member.initializer === undefined ||
+                hasModifier(member, ts.SyntaxKind.StaticKeyword))
                 continue;
             const type = properties.get(member.name.text);
-            if (type !== NULLABLE_VOID_CALLBACK || (member.initializer.kind !== ts.SyntaxKind.NullKeyword &&
-                !callbackInitializer(member.initializer)))
+            if (type !== NULLABLE_VOID_CALLBACK ||
+                (member.initializer.kind !== ts.SyntaxKind.NullKeyword &&
+                    !callbackInitializer(member.initializer)))
                 continue;
             const leading = source.slice(member.getFullStart(), member.getStart(sourceFile));
             if (jsDocTypeOf(member) !== undefined || leading.includes("@type"))
@@ -910,7 +1001,8 @@ export function applyNpmStaticDeclarationProperties(sourceFile, source, declarat
         if (constructor?.body === undefined)
             continue;
         for (const bodyStatement of constructor.body.statements) {
-            if (!ts.isExpressionStatement(bodyStatement) || !ts.isBinaryExpression(bodyStatement.expression))
+            if (!ts.isExpressionStatement(bodyStatement) ||
+                !ts.isBinaryExpression(bodyStatement.expression))
                 continue;
             const { left, right, operatorToken } = bodyStatement.expression;
             if (operatorToken.kind !== ts.SyntaxKind.EqualsToken ||