@danielx/civet 0.6.37 → 0.6.38

package/README.md

@@ -26,7 +26,7 @@ The modern way to write TypeScript.
   [Gulp](integration/gulp),
   [ESM module resolution](source/esm.civet),
   [CJS](register.js),
-  [Bun](source/bun-civet.coffee)
+  [Bun](source/bun-civet.civet)
 - Starter templates for [Solid](https://github.com/orenelbaum/solid-civet-template) and [Solid Start](https://github.com/orenelbaum/solid-start-civet-template)
 
 Quickstart Guide

package/dist/browser.js

@@ -893,6 +893,28 @@ ${input.slice(result.pos)}
         }
         return expandedOps;
       }
+      function handleThisPrivateShorthands(value) {
+        if (value.privateShorthand) {
+          value = value.children[1].children[1];
+          return [value, false];
+        }
+        if (value.type === "MemberExpression" || value.type === "CallExpression") {
+          let suppressPrefix = value.thisShorthand;
+          value = {
+            ...value,
+            children: value.children.map((c, i) => {
+              if (i === 0) {
+                let s;
+                [c, s] = handleThisPrivateShorthands(c);
+                suppressPrefix || (suppressPrefix = s);
+              }
+              return c;
+            })
+          };
+          return [value, suppressPrefix];
+        }
+        return [value, value.thisShorthand];
+      }
       function processCallMemberExpression(node) {
         const { children } = node;
         for (let i = 0; i < children.length; i++) {
@@ -920,11 +942,15 @@ ${input.slice(result.pos)}
                 throw new Error("Glob pattern cannot have method definition");
               }
               if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
-                throw new Error("Glob pattern must have call or member expression value");
+                throw new Error(`Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`);
               }
+              let suppressPrefix = false;
               let value = part.value ?? part.name;
               const wValue = getTrimmingSpace(part.value);
-              value = prefix.concat(insertTrimmingSpace(value, ""));
+              [value, suppressPrefix] = handleThisPrivateShorthands(value);
+              if (!suppressPrefix) {
+                value = prefix.concat(insertTrimmingSpace(value, ""));
+              }
               if (wValue)
                 value.unshift(wValue);
               if (part.type === "SpreadProperty") {
@@ -1138,14 +1164,14 @@ ${input.slice(result.pos)}
             chains.push(i);
           } else if (lowerPrecedenceOps.includes(op.token)) {
             processChains(op);
-            first = [];
+            first = void 0;
           }
           i++;
         }
         processChains(op);
         return results;
         function processChains(op2) {
-          if (isRelationalOp(op2)) {
+          if (first && isRelationalOp(op2)) {
             first = expandExistence(first);
           }
           if (chains.length > 1) {
@@ -1154,7 +1180,7 @@ ${input.slice(result.pos)}
                 results.push(" ", "&&", " ");
               }
               const binop = binops[index];
-              let [pre, op3, post, exp] = binop;
+              let [, , , exp] = binop;
               exp = binop[3] = expandExistence(exp);
               let endIndex;
               if (k < chains.length - 1) {
@@ -1167,10 +1193,13 @@ ${input.slice(result.pos)}
               return start = endIndex;
             });
           } else {
-            results.push(first, ...binops.slice(start, i + 1).flat());
+            if (first) {
+              results.push(first);
+            }
+            results.push(...binops.slice(start, i + 1).flat());
             start = i + 1;
           }
-          return chains.length = 0;
+          chains.length = 0;
         }
         function expandExistence(exp) {
           const existence = isExistence(exp);
@@ -1252,6 +1281,23 @@ ${input.slice(result.pos)}
           }
         }
       }
+      function replaceBlockExpression(node, child, replacement) {
+        let found = false;
+        const { expressions } = node;
+        for (let i = 0, l = expressions.length; i < l; i++) {
+          const statement = expressions[i];
+          const [, s] = statement;
+          if (s === child) {
+            statement[1] = replacement;
+            replacement.parent = node;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          throw new Error("Could not find child to replace");
+        }
+      }
       function findChildIndex(parent, child) {
         const children = Array.isArray(parent) ? parent : parent.children;
         const len = children.length;
@@ -2138,12 +2184,12 @@ ${input.slice(result.pos)}
       }
       function processDeclarationConditions(node) {
         gatherRecursiveAll(node, (n) => {
-          return n.type === "IfStatement" || n.type === "IterationStatement";
+          return n.type === "IfStatement" || n.type === "IterationStatement" || n.type === "SwitchStatement";
         }).forEach(processDeclarationConditionStatement);
       }
       function processDeclarationConditionStatement(s) {
         const { condition } = s;
-        if (!condition) {
+        if (!condition?.expression) {
           return;
         }
         processDeclarationCondition(condition.expression);
@@ -2184,6 +2230,27 @@ ${input.slice(result.pos)}
             updateParentPointers(newBlock, s);
             break;
           }
+          case "SwitchStatement": {
+            const { blockPrefix, ref: ref2 } = condition.expression;
+            if (!blockPrefix) {
+              return;
+            }
+            s.condition = {
+              type: "ParenthesizedExpression",
+              children: ["(", ref2, ")"],
+              expression: ref2,
+              parent: s
+            };
+            s.children[1] = s.condition;
+            const block = blockWithPrefix([["", [{
+              type: "Declaration",
+              children: ["let ", ...condition.expression.children]
+            }], ";"], ...blockPrefix], makeEmptyBlock());
+            replaceBlockExpression(s.parent, s, block);
+            block.expressions.push(["", s]);
+            s.parent = block;
+            break;
+          }
         }
       }
       function implicitFunctionBlock(f) {
@@ -2632,12 +2699,12 @@ ${input.slice(result.pos)}
           }
           if (errors || !isPattern)
             return;
-          let { expression } = s;
-          if (expression.type === "ParenthesizedExpression") {
-            expression = expression.expression;
+          let { condition } = s;
+          if (condition.type === "ParenthesizedExpression") {
+            condition = condition.expression;
           }
-          let hoistDec, refAssignment = [], ref = maybeRef(expression, "m");
-          if (ref !== expression) {
+          let hoistDec, refAssignment = [], ref = maybeRef(condition, "m");
+          if (ref !== condition) {
             hoistDec = {
               type: "Declaration",
               children: ["let ", ref],
@@ -2645,7 +2712,7 @@ ${input.slice(result.pos)}
             };
             refAssignment = [{
               type: "AssignmentExpression",
-              children: [ref, " = ", expression]
+              children: [ref, " = ", condition]
             }, ","];
           }
           let prev = [], root = prev;
@@ -2673,7 +2740,7 @@ ${input.slice(result.pos)}
                 return conditionArray;
               return [" || ", ...conditionArray];
             });
-            const condition = {
+            const condition2 = {
               type: "ParenthesizedExpression",
               children: ["(", ...refAssignment, conditionExpression, ")"],
               expression: conditionExpression
@@ -2708,7 +2775,7 @@ ${input.slice(result.pos)}
               next.push("\n", "else ");
             prev.push(["", {
               type: "IfStatement",
-              children: ["if", condition, block, next],
+              children: ["if", condition2, block, next],
               then: block,
               else: next,
               hoistDec
@@ -5361,7 +5428,8 @@ ${input.slice(result.pos)}
             type: "PropertyAccess",
             name: id,
             children: [".", id]
-          }]
+          }],
+          thisShorthand: true
         };
       });
       var ThisLiteral$2 = AtThis;
@@ -5382,7 +5450,8 @@ ${input.slice(result.pos)}
             type: "PropertyAccess",
             name: id.name,
             children: [".", id]
-          }]
+          }],
+          privateShorthand: true
         };
       });
       var PrivateThis$$ = [PrivateThis$0, PrivateThis$1];
@@ -7234,20 +7303,7 @@ ${input.slice(result.pos)}
       function ObjectPropertyDelimiter(ctx, state) {
         return $EVENT_C(ctx, state, "ObjectPropertyDelimiter", ObjectPropertyDelimiter$$);
       }
-      var PropertyDefinition$0 = $TS($S($E(_), AtThis, IdentifierReference), function($skip, $loc, $0, $1, $2, $3) {
-        var ws = $1;
-        var at = $2;
-        var id = $3;
-        const value = [at, ".", id];
-        return {
-          type: "Property",
-          children: [ws, id, ": ", ...value],
-          name: id,
-          names: id.names,
-          value
-        };
-      });
-      var PropertyDefinition$1 = $TS($S($E(_), NamedProperty), function($skip, $loc, $0, $1, $2) {
+      var PropertyDefinition$0 = $TS($S($E(_), NamedProperty), function($skip, $loc, $0, $1, $2) {
         var ws = $1;
         var prop = $2;
         return {
@@ -7255,7 +7311,7 @@ ${input.slice(result.pos)}
           children: [ws, ...prop.children]
         };
       });
-      var PropertyDefinition$2 = $TS($S($E(_), $TEXT($EXPECT($R6, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyDefinition$1 = $TS($S($E(_), $TEXT($EXPECT($R6, "PropertyDefinition /[!+-]/")), PropertyName), function($skip, $loc, $0, $1, $2, $3) {
         var ws = $1;
         var toggle = $2;
         var id = $3;
@@ -7268,7 +7324,7 @@ ${input.slice(result.pos)}
           value
         };
       });
-      var PropertyDefinition$3 = $TS($S($E(_), MethodDefinition), function($skip, $loc, $0, $1, $2) {
+      var PropertyDefinition$2 = $TS($S($E(_), MethodDefinition), function($skip, $loc, $0, $1, $2) {
         var ws = $1;
         var def = $2;
         if (!def.block || def.block.empty)
@@ -7278,7 +7334,7 @@ ${input.slice(result.pos)}
           children: [ws, ...def.children]
         };
       });
-      var PropertyDefinition$4 = $TS($S($E(_), DotDotDot, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyDefinition$3 = $TS($S($E(_), DotDotDot, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3) {
         var ws = $1;
         var dots = $2;
         var exp = $3;
@@ -7290,7 +7346,7 @@ ${input.slice(result.pos)}
           value: exp
         };
       });
-      var PropertyDefinition$5 = $TS($S($E(_), $N(EOS), CallExpression), function($skip, $loc, $0, $1, $2, $3) {
+      var PropertyDefinition$4 = $TS($S($E(_), $N(EOS), CallExpression), function($skip, $loc, $0, $1, $2, $3) {
         var ws = $1;
         var value = $3;
         switch (value.type) {
@@ -7349,16 +7405,18 @@ ${input.slice(result.pos)}
           if (!name)
             return $skip;
         }
+        if (name[0] === "#")
+          name = name.slice(1);
         return {
           type: "Property",
           children: [ws, name, ": ", value],
           name,
-          value,
           names: [],
+          value,
           hoistDec
         };
       });
-      var PropertyDefinition$$ = [PropertyDefinition$0, PropertyDefinition$1, PropertyDefinition$2, PropertyDefinition$3, PropertyDefinition$4, PropertyDefinition$5];
+      var PropertyDefinition$$ = [PropertyDefinition$0, PropertyDefinition$1, PropertyDefinition$2, PropertyDefinition$3, PropertyDefinition$4];
       function PropertyDefinition(ctx, state) {
         return $EVENT_C(ctx, state, "PropertyDefinition", PropertyDefinition$$);
       }
@@ -8722,7 +8780,7 @@ ${input.slice(result.pos)}
         return {
           type: "SwitchStatement",
           children: $0,
-          expression: condition,
+          condition,
           caseBlock
         };
       });
@@ -13418,6 +13476,7 @@ ${input.slice(result.pos)}
     generate: () => generate_default,
     isCompileError: () => isCompileError,
     parse: () => parse,
+    prune: () => prune,
     util: () => util_exports
   });
   var import_parser = __toESM(require_parser());
@@ -13585,7 +13644,10 @@ ${input.slice(result.pos)}
           sources: [srcFileName],
           mappings: this.renderMappings(),
           names: [],
-          sourcesContent: [sourceString]
+          sourcesContent: [sourceString],
+          toString: function() {
+            return JSON.stringify(this);
+          }
         };
       },
       updateSourceMap: function(outputStr, inputPos) {

package/dist/civet

@@ -1,20 +1,39 @@
 #!/usr/bin/env node
 "use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 
 // source/cli.civet
 var import_main = require("./main.js");
 var import_config = require("./config.js");
-var prune;
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
 var version;
-var encoding;
-var fs;
-var path;
 var parseArgs;
 var readFiles;
 var repl;
 var cli;
 var indexOf = [].indexOf;
-({ prune } = import_main.generate);
 version = function() {
   return require("../package.json").version;
 };
@@ -60,9 +79,7 @@ if (process.argv.includes("--help")) {
 `);
   process.exit(0);
 }
-encoding = "utf8";
-fs = require("fs/promises");
-path = require("path");
+var encoding = "utf8";
 parseArgs = function(args) {
   var options, filenames, scriptArgs, i, endOfArgs, arg;
   options = {};
@@ -167,7 +184,7 @@ readFiles = async function* (filenames, options) {
         process.stdin.setEncoding(encoding);
         filename = "<stdin>";
         try {
-          filename = await fs.realpath("/dev/stdin");
+          filename = await import_promises.default.realpath("/dev/stdin");
         } catch (e) {
         }
         if (process.stdin.isTTY) {
@@ -196,7 +213,7 @@ readFiles = async function* (filenames, options) {
           })()).join("");
         }
       } else {
-        content = await fs.readFile(filename, { encoding });
+        content = await import_promises.default.readFile(filename, { encoding });
       }
       results1.push(yield { filename, content, stdin });
     } catch (error) {
@@ -284,7 +301,7 @@ repl = function(options) {
   });
 };
 cli = async function() {
-  var argv, filenames, scriptArgs, options, filename, error, content, stdin, output, outputPath, outputFilename, optionsPath, stat, esm, child;
+  var argv, filenames, scriptArgs, options, filename, error, content, stdin, output, outputPath, outputFilename, optionsPath, stat, esm, execArgv, debugRe, isDebug, child;
   argv = process.argv;
   ({ filenames, scriptArgs, options } = parseArgs(argv.slice(2)));
   if (options.config !== false) {
@@ -330,7 +347,7 @@ cli = async function() {
       if (stdin && !options.output || options.output === "-") {
         results3.push(process.stdout.write(output));
       } else {
-        outputPath = path.parse(filename);
+        outputPath = import_path.default.parse(filename);
         delete outputPath.base;
         if (options.js) {
           outputPath.ext += ".jsx";
@@ -338,13 +355,13 @@ cli = async function() {
           outputPath.ext += ".tsx";
         }
         if (options.output) {
-          optionsPath = path.parse(options.output);
+          optionsPath = import_path.default.parse(options.output);
           try {
-            stat = await fs.stat(options.output);
+            stat = await import_promises.default.stat(options.output);
           } catch {
             stat = null;
           }
-          if (stat?.isDirectory() || options.output.endsWith(path.sep) || options.output.endsWith("/")) {
+          if (stat?.isDirectory() || options.output.endsWith(import_path.default.sep) || options.output.endsWith("/")) {
             outputPath.dir = options.output;
           } else if (/^(\.[^.]+)+$/.test(optionsPath.base)) {
             outputPath.ext = optionsPath.base;
@@ -356,11 +373,11 @@ cli = async function() {
           }
         }
         if (outputPath.dir) {
-          fs.mkdir(outputPath.dir, { recursive: true });
+          import_promises.default.mkdir(outputPath.dir, { recursive: true });
         }
-        outputFilename = path.format(outputPath);
+        outputFilename = import_path.default.format(outputPath);
         try {
-          results3.push(await fs.writeFile(outputFilename, output));
+          results3.push(await import_promises.default.writeFile(outputFilename, output));
         } catch (error2) {
           console.error(`${outputFilename} failed to write:`);
           results3.push(console.error(error2));
@@ -372,32 +389,45 @@ cli = async function() {
         if (stdin) {
           filename = `.stdin-${process.pid}.civet`;
           try {
-            await fs.writeFile(filename, content, { encoding });
+            await import_promises.default.writeFile(filename, content, { encoding });
           } catch (e) {
             console.error(`Could not write ${filename} for Civet ESM mode:`);
             console.error(e);
             process.exit(1);
           }
         }
-        child = require("child_process").spawnSync(argv[0], [
-          "--loader",
-          "@danielx/civet/esm",
-          filename,
-          ...scriptArgs
-        ], { stdio: "inherit" });
-        if (stdin) {
-          await fs.unlink(filename);
+        ;
+        const { fork } = await import("child_process");
+        execArgv = ["--loader", "@danielx/civet/esm"];
+        debugRe = /--debug|--inspect/;
+        isDebug = typeof v8debug === "object" || debugRe.test(process.execArgv.join(" ")) || debugRe.test(process.env.NODE_OPTIONS);
+        if (process.env.NODE_OPTIONS) {
+          execArgv.push(process.env.NODE_OPTIONS);
+        }
+        if (isDebug) {
+          execArgv.push("--inspect=" + (process.debugPort + 1));
         }
-        results3.push(process.exit(child.status));
+        child = fork(filename, [
+          ...scriptArgs
+        ], {
+          execArgv,
+          stdio: "inherit"
+        });
+        results3.push(child.on("exit", async function(code) {
+          if (stdin) {
+            await import_promises.default.unlink(filename);
+          }
+          return process.exit(code ?? 1);
+        }));
       } else {
         require("../register.js");
         try {
-          module.filename = await fs.realpath(filename);
+          module.filename = await import_promises.default.realpath(filename);
         } catch {
           module.filename = filename;
         }
         process.argv = ["civet", module.filename, ...scriptArgs];
-        module.paths = require("module")._nodeModulePaths(path.dirname(module.filename));
+        module.paths = require("module")._nodeModulePaths(import_path.default.dirname(module.filename));
         try {
           results3.push(module._compile(output, module.filename));
         } catch (error2) {

package/dist/esbuild.js

@@ -37,6 +37,7 @@ module.exports = __toCommonJS(esbuild_exports);
 // src/index.ts
 var import_unplugin = require("unplugin");
 var import_civet = __toESM(require("@danielx/civet"));
+var import_ts_diagnostic = require("@danielx/civet/ts-diagnostic");
 var fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_typescript = __toESM(require("typescript"));
@@ -52,15 +53,19 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
   if (options.dts && options.js) {
     throw new Error("Can't have both `dts` and `js` be set to `true`.");
   }
-  const transpileToJS = options.js ?? !options.dts;
+  if (options.typecheck && options.js) {
+    throw new Error("Can't have both `typecheck` and `js` be set to `true`.");
+  }
+  const transpileToJS = options.js ?? !(options.dts || options.typecheck);
   const outExt = options.outputExtension ?? (transpileToJS ? ".jsx" : ".tsx");
   let fsMap = /* @__PURE__ */ new Map();
+  const sourceMaps = /* @__PURE__ */ new Map();
   let compilerOptions;
   return {
     name: "unplugin-civet",
     enforce: "pre",
     async buildStart() {
-      if (options.dts) {
+      if (options.dts || options.typecheck) {
         const configPath = import_typescript.default.findConfigFile(process.cwd(), import_typescript.default.sys.fileExists);
         if (!configPath) {
           throw new Error("Could not find 'tsconfig.json'");
@@ -86,7 +91,7 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
       }
     },
     buildEnd() {
-      if (options.dts) {
+      if (options.dts || options.typecheck) {
         const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), import_typescript.default);
         const host = tsvfs.createVirtualCompilerHost(
           system,
@@ -98,20 +103,55 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
           options: compilerOptions,
           host: host.compilerHost
         });
-        for (const file of fsMap.keys()) {
-          const sourceFile = program.getSourceFile(file);
-          program.emit(
-            sourceFile,
-            (filePath, content) => {
-              this.emitFile({
-                source: content,
-                fileName: import_path.default.relative(process.cwd(), filePath),
-                type: "asset"
-              });
+        const diagnostics = import_typescript.default.getPreEmitDiagnostics(program).map((diagnostic) => {
+          const file = diagnostic.file;
+          if (!file)
+            return diagnostic;
+          const sourceMap = sourceMaps.get(file.fileName);
+          if (!sourceMap)
+            return diagnostic;
+          const sourcemapLines = sourceMap.data.lines;
+          const range = (0, import_ts_diagnostic.remapRange)(
+            {
+              start: diagnostic.start || 0,
+              end: (diagnostic.start || 0) + (diagnostic.length || 1)
             },
-            void 0,
-            true
+            sourcemapLines
           );
+          return {
+            ...diagnostic,
+            messageText: (0, import_ts_diagnostic.flattenDiagnosticMessageText)(diagnostic.messageText),
+            length: diagnostic.length,
+            start: range.start
+          };
+        });
+        if (diagnostics.length > 0) {
+          console.error(
+            import_typescript.default.formatDiagnosticsWithColorAndContext(diagnostics, formatHost)
+          );
+        }
+        if (options.dts) {
+          for (const file of fsMap.keys()) {
+            const sourceFile = program.getSourceFile(file);
+            program.emit(
+              sourceFile,
+              async (filePath, content) => {
+                const dir = import_path.default.dirname(filePath);
+                await fs.promises.mkdir(dir, { recursive: true });
+                const pathFromDistDir = import_path.default.relative(
+                  compilerOptions.outDir ?? process.cwd(),
+                  filePath
+                );
+                this.emitFile({
+                  source: content,
+                  fileName: pathFromDistDir,
+                  type: "asset"
+                });
+              },
+              void 0,
+              true
+            );
+          }
         }
       }
     },
@@ -135,13 +175,20 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
         return null;
       const filename = import_path.default.resolve(process.cwd(), id.slice(0, -outExt.length));
       const code = await fs.promises.readFile(filename, "utf-8");
+      const compiled = import_civet.default.compile(code, {
+        // inlineMap: true,
+        filename: id,
+        js: transpileToJS,
+        sourceMap: true
+      });
+      sourceMaps.set(import_path.default.resolve(process.cwd(), id), compiled.sourceMap);
+      const jsonSourceMap = compiled.sourceMap.json(
+        import_path.default.basename(id.replace(/\.[jt]sx$/, "")),
+        import_path.default.basename(id)
+      );
       let transformed = {
-        code: import_civet.default.compile(code, {
-          inlineMap: true,
-          filename: id,
-          js: transpileToJS
-        }),
-        map: null
+        code: compiled.code,
+        map: jsonSourceMap
       };
       if (options.transformOutput)
         transformed = await options.transformOutput(transformed.code, id);
@@ -150,8 +197,12 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
     transform(code, id) {
       if (!/\.civet\.tsx?$/.test(id))
         return null;
-      if (options.dts) {
-        fsMap.set(import_path.default.resolve(process.cwd(), id), code);
+      if (options.dts || options.typecheck) {
+        const resolved = import_path.default.resolve(process.cwd(), id);
+        fsMap.set(resolved, code);
+        const slash = resolved.replace(/\\/g, "/");
+        if (resolved !== slash)
+          fsMap.set(slash, code);
       }
       return null;
     },