fix some types (#295)

Author: Fil

src/javascript.ts

@@ -1,4 +1,5 @@
-import {type Identifier, type Node, type Options, Parser, tokTypes} from "acorn";
+import {Parser, tokTypes} from "acorn";
+import type {Expression, Identifier, Node, Options, Program} from "acorn";
 import {fileReference} from "./files.js";
 import {findAssignments} from "./javascript/assignments.js";
 import {findAwaits} from "./javascript/awaits.js";
@@ -131,12 +132,12 @@ function parseJavaScript(input: string, options: ParseOptions): JavaScriptNode {
   if (expression?.type === "ClassExpression" && expression.id) expression = null; // treat named class as program
   if (expression?.type === "FunctionExpression" && expression.id) expression = null; // treat named function as program
   if (!expression && inline) throw new SyntaxError("invalid expression");
-  const body = expression ?? (Parser.parse(input, parseOptions) as any);
+  const body = expression ?? Parser.parse(input, parseOptions);
   const exports = findExports(body);
   if (exports.length) throw syntaxError("Unexpected token 'export'", exports[0], input); // disallow exports
   const references = findReferences(body, globals);
   findAssignments(body, references, globals, input);
-  const declarations = expression ? null : findDeclarations(body, globals, input);
+  const declarations = expression ? null : findDeclarations(body as Program, globals, input);
   const imports = findImports(body, root, sourcePath);
   const features = findFeatures(body, root, sourcePath, references, input);
   return {
@@ -152,11 +153,11 @@ function parseJavaScript(input: string, options: ParseOptions): JavaScriptNode {
 
 // Parses a single expression; like parseExpressionAt, but returns null if
 // additional input follows the expression.
-function maybeParseExpression(input, options) {
+function maybeParseExpression(input: string, options: Options): Expression | null {
   const parser = new (Parser as any)(options, input, 0); // private constructor
   parser.nextToken();
   try {
-    const node = (parser as any).parseExpression();
+    const node = parser.parseExpression();
     return parser.type === tokTypes.eof ? node : null;
   } catch {
     return null;

src/javascript/imports.ts

@@ -115,7 +115,7 @@ export function parseLocalImports(root: string, paths: string[]): ImportReferenc
 
 /** Rewrites import specifiers in the specified ES module source. */
 export function rewriteModule(input: string, sourcePath: string, resolver: ImportResolver): string {
-  const body = Parser.parse(input, parseOptions) as any;
+  const body = Parser.parse(input, parseOptions);
   const output = new Sourcemap(input);
 
   simple(body, {

src/markdown.ts

@@ -338,7 +338,7 @@ export function normalizePieceHtml(html: string, sourcePath: string, context: Pa
   // Extracting references to files (such as from linked stylesheets).
   const filePaths = new Set<FileReference["path"]>();
   for (const {query, src} of SUPPORTED_PROPERTIES) {
-    for (const element of document.querySelectorAll(query) as any as Iterable<Element>) {
+    for (const element of document.querySelectorAll(query)) {
       if (src === "srcset") {
         const srcset = element.getAttribute(src);
         const paths =
@@ -379,15 +379,13 @@ export function normalizePieceHtml(html: string, sourcePath: string, context: Pa
   // Syntax highlighting for <code> elements. The code could contain an inline
   // expression within, or other HTML, but we only highlight text nodes that are
   // direct children of code elements.
-  for (const code of document.querySelectorAll("code[class*='language-']") as any as Iterable<Element>) {
-    const language = [...(code.classList as any).keys()]
-      .find((c) => c.startsWith("language-"))
-      ?.slice("language-".length);
+  for (const code of document.querySelectorAll("code[class*='language-']")) {
+    const language = [...code.classList].find((c) => c.startsWith("language-"))?.slice("language-".length);
     if (!language || !hljs.getLanguage(language)) continue;
     if (code.parentElement?.tagName === "PRE") code.parentElement.setAttribute("data-language", language);
     let html = "";
     code.normalize(); // coalesce adjacent text nodes
-    for (const child of [...(code.childNodes as any as Iterable<Node>)]) {
+    for (const child of code.childNodes) {
       html += child.nodeType === TEXT_NODE ? hljs.highlight(child.textContent!, {language}).value : String(child);
     }
     code.innerHTML = html;

tsconfig.json

@@ -4,7 +4,7 @@
   "_version": "18.1.0",
   "compilerOptions": {
     "noImplicitAny": false,
-    "lib": ["es2023"],
+    "lib": ["es2023", "DOM.Iterable"],
     "module": "node16",
     "target": "es2022",
     "strict": true,