Allow build for web

Revert imports from node:fs to fs to allow the package.json directive
"browser": {
  "fs": false
}
to prevent the fs import to be packaged when building for web.

Fixes #2763

Author: vexdev

packages/quicktype-core/src/input/io/NodeIO.ts

@@ -1,4 +1,4 @@
-import * as fs from "node:fs";
+import * as fs from "fs";
 
 import { defined, exceptionToString } from "@glideapps/ts-necessities";
 import { isNode } from "browser-or-node";
@@ -13,82 +13,79 @@ import { getStream } from "./get-stream";
 import { fetch } from "./$fetch";
 
 interface HttpHeaders {
-    [key: string]: string;
+  [key: string]: string;
 }
 
 function parseHeaders(httpHeaders?: string[]): HttpHeaders {
-    if (!Array.isArray(httpHeaders)) {
-        return {};
-    }
+  if (!Array.isArray(httpHeaders)) {
+    return {};
+  }
 
-    return httpHeaders.reduce((result: HttpHeaders, httpHeader: string) => {
-        if (httpHeader !== undefined && httpHeader.length > 0) {
-            const split = httpHeader.indexOf(":");
+  return httpHeaders.reduce((result: HttpHeaders, httpHeader: string) => {
+    if (httpHeader !== undefined && httpHeader.length > 0) {
+      const split = httpHeader.indexOf(":");
 
-            if (split < 0) {
-                return panic(`Could not parse HTTP header "${httpHeader}".`);
-            }
+      if (split < 0) {
+        return panic(`Could not parse HTTP header "${httpHeader}".`);
+      }
 
-            const key = httpHeader.slice(0, split).trim();
-            const value = httpHeader.slice(split + 1).trim();
-            result[key] = value;
-        }
+      const key = httpHeader.slice(0, split).trim();
+      const value = httpHeader.slice(split + 1).trim();
+      result[key] = value;
+    }
 
-        return result;
-    }, {} as HttpHeaders);
+    return result;
+  }, {} as HttpHeaders);
 }
 
 export async function readableFromFileOrURL(
-    fileOrURL: string,
-    httpHeaders?: string[],
+  fileOrURL: string,
+  httpHeaders?: string[]
 ): Promise<Readable> {
-    try {
-        if (isURL(fileOrURL)) {
-            const response = await fetch(fileOrURL, {
-                headers: parseHeaders(httpHeaders),
-            });
-
-            return defined(response.body) as unknown as Readable;
-        }
-
-        if (isNode) {
-            if (fileOrURL === "-") {
-                // Cast node readable to isomorphic readable from readable-stream
-                return process.stdin as unknown as Readable;
-            }
-
-            const filePath = fs.lstatSync(fileOrURL).isSymbolicLink()
-                ? fs.readlinkSync(fileOrURL)
-                : fileOrURL;
-            if (fs.existsSync(filePath)) {
-                // Cast node readable to isomorphic readable from readable-stream
-                return fs.createReadStream(
-                    filePath,
-                    "utf8",
-                ) as unknown as Readable;
-            }
-        }
-    } catch (e) {
-        return messageError("MiscReadError", {
-            fileOrURL,
-            message: exceptionToString(e),
-        });
+  try {
+    if (isURL(fileOrURL)) {
+      const response = await fetch(fileOrURL, {
+        headers: parseHeaders(httpHeaders),
+      });
+
+      return defined(response.body) as unknown as Readable;
     }
 
-    return messageError("DriverInputFileDoesNotExist", { filename: fileOrURL });
+    if (isNode) {
+      if (fileOrURL === "-") {
+        // Cast node readable to isomorphic readable from readable-stream
+        return process.stdin as unknown as Readable;
+      }
+
+      const filePath = fs.lstatSync(fileOrURL).isSymbolicLink()
+        ? fs.readlinkSync(fileOrURL)
+        : fileOrURL;
+      if (fs.existsSync(filePath)) {
+        // Cast node readable to isomorphic readable from readable-stream
+        return fs.createReadStream(filePath, "utf8") as unknown as Readable;
+      }
+    }
+  } catch (e) {
+    return messageError("MiscReadError", {
+      fileOrURL,
+      message: exceptionToString(e),
+    });
+  }
+
+  return messageError("DriverInputFileDoesNotExist", { filename: fileOrURL });
 }
 
 export async function readFromFileOrURL(
-    fileOrURL: string,
-    httpHeaders?: string[],
+  fileOrURL: string,
+  httpHeaders?: string[]
 ): Promise<string> {
-    const readable = await readableFromFileOrURL(fileOrURL, httpHeaders);
-    try {
-        return await getStream(readable);
-    } catch (e) {
-        return messageError("MiscReadError", {
-            fileOrURL,
-            message: exceptionToString(e),
-        });
-    }
+  const readable = await readableFromFileOrURL(fileOrURL, httpHeaders);
+  try {
+    return await getStream(readable);
+  } catch (e) {
+    return messageError("MiscReadError", {
+      fileOrURL,
+      message: exceptionToString(e),
+    });
+  }
 }