@danielx/civet 0.6.50 → 0.6.52

package/dist/main.mjs

@@ -3873,6 +3873,10 @@ var require_parser = __commonJS({
       ShortArrowParameters,
       ArrowParameters,
       NonEmptyParameters,
+      ParameterList,
+      NestedParameterList,
+      NestedParameter,
+      Parameter,
       FunctionRestParameter,
       ParameterElement,
       ParameterElementDelimiter,
@@ -4199,6 +4203,7 @@ var require_parser = __commonJS({
       Case,
       Catch,
       Class,
+      CloseAngleBracket,
       CloseBrace,
       CloseBracket,
       CloseParen,
@@ -4670,7 +4675,7 @@ var require_parser = __commonJS({
     var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
     var $R2 = $R(new RegExp("[0-9]", "suy"));
     var $R3 = $R(new RegExp("[ \\t]", "suy"));
-    var $R4 = $R(new RegExp("(?=['\"`])", "suy"));
+    var $R4 = $R(new RegExp("(?=['\"`<])", "suy"));
     var $R5 = $R(new RegExp("(?=[\\/?])", "suy"));
     var $R6 = $R(new RegExp("(?=[\\/\\[{?.!@'\u2019:])", "suy"));
     var $R7 = $R(new RegExp("[)}]", "suy"));
@@ -5318,8 +5323,11 @@ var require_parser = __commonJS({
     function TrailingDeclaration(ctx, state) {
       return $EVENT(ctx, state, "TrailingDeclaration", TrailingDeclaration$0);
     }
-    var FatArrowBody$0 = $T($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(SemicolonDelimiter)), function(value) {
-      var exp = value[1];
+    var FatArrowBody$0 = $TS($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(SemicolonDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var exp = $2;
+      if (exp.type === "ObjectExpression") {
+        return makeLeftHandSideExpression(exp);
+      }
       return exp;
     });
     var FatArrowBody$1 = NoCommaBracedOrEmptyBlock;
@@ -5791,12 +5799,15 @@ var require_parser = __commonJS({
       return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
     }
     var CallExpressionRest$0 = MemberExpressionRest;
-    var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"`])/"), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
-      var literal = $2;
+    var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"`<])/"), $E(TypeArguments), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2, $3) {
+      var args = $2;
+      var literal = $3;
       if (literal.type === "StringLiteral") {
-        return "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
+        literal = "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
       }
-      return literal;
+      if (!args)
+        return literal;
+      return [args, literal];
     });
     var CallExpressionRest$2 = $TS($S($E(OptionalShorthand), ArgumentsWithTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
       if (!$1)
@@ -6136,15 +6147,55 @@ var require_parser = __commonJS({
     function ArrowParameters(ctx, state) {
       return $EVENT_C(ctx, state, "ArrowParameters", ArrowParameters$$);
     }
-    var NonEmptyParameters$0 = $TS($S($E(TypeParameters), OpenParen, $E(ThisType), $Q(ParameterElement), $E(FunctionRestParameter), $Q(ParameterElement), $S(__, CloseParen)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+    var NonEmptyParameters$0 = $TS($S($E(TypeParameters), OpenParen, ParameterList, $S(__, CloseParen)), function($skip, $loc, $0, $1, $2, $3, $4) {
       var tp = $1;
       var open = $2;
-      var tt = $3;
-      var pes = $4;
-      var rest = $5;
-      var after = $6;
-      var close = $7;
-      const names = pes.flatMap((p) => p.names);
+      var params = $3;
+      var close = $4;
+      let tt, before = [], rest, after = [], errors = [];
+      function append(p) {
+        (rest ? after : before).push(p);
+      }
+      for (const param of params) {
+        switch (param.type) {
+          case "ThisType":
+            if (tt) {
+              append({
+                type: "Error",
+                message: "Only one typed this parameter is allowed"
+              });
+              append(param);
+            } else {
+              tt = insertTrimmingSpace(param, "");
+              if (before.length || rest) {
+                let delim = tt.children.at(-1);
+                if (Array.isArray(delim))
+                  delim = delim.at(-1);
+                if (delim?.token !== ",") {
+                  tt = {
+                    ...tt,
+                    children: [...tt.children, ", "]
+                  };
+                }
+              }
+            }
+            break;
+          case "FunctionRestParameter":
+            if (rest) {
+              append({
+                type: "Error",
+                message: "Only one rest parameter is allowed"
+              });
+              append(param);
+            } else {
+              rest = param;
+            }
+            break;
+          default:
+            append(param);
+        }
+      }
+      const names = before.flatMap((p) => p.names);
       if (rest) {
         const restIdentifier = rest.binding.ref || rest.binding;
         names.push(...rest.names || []);
@@ -6161,7 +6212,7 @@ var require_parser = __commonJS({
             tp,
             open,
             tt,
-            ...pes,
+            ...before,
             // Remove delimiter
             { ...rest, children: rest.children.slice(0, -1) },
             close
@@ -6173,19 +6224,61 @@ var require_parser = __commonJS({
       }
       return {
         type: "Parameters",
-        children: [tp, open, tt, ...pes, close],
-        names: pes.flatMap((p) => p.names),
+        children: [tp, open, tt, ...before, close],
+        names,
         tp
       };
     });
     function NonEmptyParameters(ctx, state) {
       return $EVENT(ctx, state, "NonEmptyParameters", NonEmptyParameters$0);
     }
-    var FunctionRestParameter$0 = $TS($S(__, BindingRestElement, $E(TypeSuffix), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var ParameterList$0 = $TS($S($Q(Parameter), NestedParameterList), function($skip, $loc, $0, $1, $2) {
+      return [...$1, ...$2];
+    });
+    var ParameterList$1 = $TV($Q($S(__, Parameter)), function($skip, $loc, $0, $1) {
+      return $1.map(([eos, p]) => ({
+        ...p,
+        children: [eos, ...p.children]
+      }));
+    });
+    var ParameterList$$ = [ParameterList$0, ParameterList$1];
+    function ParameterList(ctx, state) {
+      return $EVENT_C(ctx, state, "ParameterList", ParameterList$$);
+    }
+    var NestedParameterList$0 = $TS($S(PushIndent, $Q(NestedParameter), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var params = $2;
+      if (!params.length)
+        return $skip;
+      return params;
+    });
+    function NestedParameterList(ctx, state) {
+      return $EVENT(ctx, state, "NestedParameterList", NestedParameterList$0);
+    }
+    var NestedParameter$0 = $TS($S(Nested, $P(Parameter)), function($skip, $loc, $0, $1, $2) {
+      var ws = $1;
+      var params = $2;
+      params = [...params];
+      params[0] = {
+        ...params[0],
+        children: [ws, ...params[0].children]
+      };
+      return params;
+    });
+    function NestedParameter(ctx, state) {
+      return $EVENT(ctx, state, "NestedParameter", NestedParameter$0);
+    }
+    var Parameter$0 = ThisType;
+    var Parameter$1 = ParameterElement;
+    var Parameter$2 = FunctionRestParameter;
+    var Parameter$$ = [Parameter$0, Parameter$1, Parameter$2];
+    function Parameter(ctx, state) {
+      return $EVENT_C(ctx, state, "Parameter", Parameter$$);
+    }
+    var FunctionRestParameter$0 = $TS($S($N(EOS), BindingRestElement, $E(TypeSuffix), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
       var id = $2;
       return {
         type: "FunctionRestParameter",
-        children: $0,
+        children: $0.slice(1),
         names: id.names,
         binding: id.binding
       };
@@ -6193,12 +6286,14 @@ var require_parser = __commonJS({
     function FunctionRestParameter(ctx, state) {
       return $EVENT(ctx, state, "FunctionRestParameter", FunctionRestParameter$0);
     }
-    var ParameterElement$0 = $TS($S(__, $E(AccessModifier), $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var ParameterElement$0 = $TS($S($E(_), $E(AccessModifier), $E(_), $C(NWBindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+      var accessModifier = $2;
+      var binding = $4;
       return {
         type: "Parameter",
         children: $0,
-        names: $3.names,
-        accessModifier: $2
+        names: binding.names,
+        accessModifier
       };
     });
     function ParameterElement(ctx, state) {
@@ -6593,8 +6688,8 @@ var require_parser = __commonJS({
         async,
         generator,
         modifier: {
-          async: !async.length,
-          generator: !generator.length
+          async: !!async.length,
+          generator: !!generator.length
         },
         block: null,
         children: !parameters.implicit ? [async, func, generator, wid, w, parameters, suffix] : [async, func, generator, wid, parameters, w, suffix]
@@ -6617,9 +6712,11 @@ var require_parser = __commonJS({
       }
       if (hasAwait(block) && !signature.async.length) {
         signature.async.push("async ");
+        signature.modifier.async = true;
       }
       if (hasYield(block) && !signature.generator.length) {
         signature.generator.push("*");
+        signature.modifier.generator = true;
       }
       return {
         ...signature,
@@ -6794,10 +6891,11 @@ var require_parser = __commonJS({
     function AmpersandBlockRHS(ctx, state) {
       return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
     }
-    var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($R8, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3) {
+    var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S(WAssignmentOp, $Q($S(NotDedented, UpdateExpression, WAssignmentOp)), NonPipelineExtendedExpression)), $E($S($N($EXPECT($R8, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3, $4) {
       var callExpRest = $1;
       var unaryPostfix = $2;
-      var binopRHS = $3;
+      var assign = $3;
+      var binopRHS = $4;
       if (!callExpRest && !binopRHS && !unaryPostfix)
         return $skip;
       const ref = makeRef("$");
@@ -6813,8 +6911,24 @@ var require_parser = __commonJS({
       if (unaryPostfix) {
         exp = processUnaryExpression([], exp, unaryPostfix);
       }
+      if (assign) {
+        const [op1, more, rhs] = assign;
+        const lhs = [
+          [void 0, exp, ...op1],
+          ...more.map((x) => [x[0], x[1], ...x[2]])
+        ];
+        exp = {
+          type: "AssignmentExpression",
+          children: [lhs, rhs],
+          names: null,
+          lhs,
+          assigned: exp,
+          exp: rhs,
+          ref
+        };
+      }
       if (binopRHS) {
-        return {
+        exp = {
           children: processBinaryOpExpression([exp, binopRHS[1]]),
           ref
         };
@@ -10699,6 +10813,12 @@ var require_parser = __commonJS({
     function Class(ctx, state) {
       return $EVENT(ctx, state, "Class", Class$0);
     }
+    var CloseAngleBracket$0 = $TV($EXPECT($L33, 'CloseAngleBracket ">"'), function($skip, $loc, $0, $1) {
+      return { $loc, token: $1 };
+    });
+    function CloseAngleBracket(ctx, state) {
+      return $EVENT(ctx, state, "CloseAngleBracket", CloseAngleBracket$0);
+    }
     var CloseBrace$0 = $TV($EXPECT($L25, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
@@ -12497,9 +12617,14 @@ var require_parser = __commonJS({
     function TypeArrowFunction(ctx, state) {
       return $EVENT(ctx, state, "TypeArrowFunction", TypeArrowFunction$0);
     }
-    var TypeArguments$0 = $TS($S($EXPECT($L154, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L33, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var TypeArguments$0 = $TS($S(OpenAngleBracket, $P(TypeArgument), __, CloseAngleBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
       var args = $2;
-      return { ts: true, types: args.map(([, t]) => t), children: $0 };
+      return {
+        type: "TypeArguments",
+        ts: true,
+        types: args.map(([, t]) => t),
+        children: $0
+      };
     });
     function TypeArguments(ctx, state) {
       return $EVENT(ctx, state, "TypeArguments", TypeArguments$0);
@@ -12512,7 +12637,7 @@ var require_parser = __commonJS({
     function TypeArgumentDelimiter(ctx, state) {
       return $EVENT(ctx, state, "TypeArgumentDelimiter", TypeArgumentDelimiter$0);
     }
-    var TypeParameters$0 = $TS($S($E(_), $EXPECT($L154, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L33, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var TypeParameters$0 = $TS($S($E(_), OpenAngleBracket, $P(TypeParameter), __, CloseAngleBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var parameters = $3;
       return {
         type: "TypeParameters",
@@ -12545,7 +12670,7 @@ var require_parser = __commonJS({
     function TypeParameterDelimiter(ctx, state) {
       return $EVENT_C(ctx, state, "TypeParameterDelimiter", TypeParameterDelimiter$$);
     }
-    var ThisType$0 = $T($S($C(This, AtThis), Colon, Type, ParameterElementDelimiter), function(value) {
+    var ThisType$0 = $T($S($E(_), $C(This, AtThis), Colon, Type, ParameterElementDelimiter), function(value) {
       return { "type": "ThisType", "ts": true, "children": value };
     });
     function ThisType(ctx, state) {
@@ -12988,19 +13113,45 @@ var require_parser = __commonJS({
           };
           module.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
         },
+        Falsy(FalsyRef) {
+          module.prelude.push(["", [{
+            ts: true,
+            children: ["type ", FalsyRef, " = false | 0 | '' | 0n | null | undefined;", "\n"]
+          }]]);
+        },
         xor(xorRef) {
+          const Falsy = module.getRef("Falsy");
           const typeSuffix = {
             ts: true,
-            children: [": (a: unknown, b: unknown) => boolean"]
+            children: [
+              ": <A, B>(a: A, b: B) => A extends ",
+              Falsy,
+              " ? B : B extends ",
+              Falsy,
+              " ? A : (false | (A & ",
+              Falsy,
+              " extends never ? never : B) | (B & ",
+              Falsy,
+              " extends never ? never : A))"
+            ]
           };
-          module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
+          module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => (a ? !b && a : b)", asAny, ";", "\n"]]);
         },
         xnor(xnorRef) {
+          const Falsy = module.getRef("Falsy");
           const typeSuffix = {
             ts: true,
-            children: [": (a: unknown, b: unknown) => boolean"]
+            children: [
+              ": <A, B>(a: A, b: B) => A & ",
+              Falsy,
+              " extends never ? B : (true | (B extends ",
+              Falsy,
+              " ? never : A) | (A extends ",
+              Falsy,
+              " ? never : B))"
+            ]
           };
-          module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
+          module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => (a ? b : !b || a)", asAny, ";", "\n"]]);
         },
         returnSymbol(ref) {
           module.prelude.push({
@@ -13340,6 +13491,10 @@ var require_parser = __commonJS({
     exports.ShortArrowParameters = ShortArrowParameters;
     exports.ArrowParameters = ArrowParameters;
     exports.NonEmptyParameters = NonEmptyParameters;
+    exports.ParameterList = ParameterList;
+    exports.NestedParameterList = NestedParameterList;
+    exports.NestedParameter = NestedParameter;
+    exports.Parameter = Parameter;
     exports.FunctionRestParameter = FunctionRestParameter;
     exports.ParameterElement = ParameterElement;
     exports.ParameterElementDelimiter = ParameterElementDelimiter;
@@ -13666,6 +13821,7 @@ var require_parser = __commonJS({
     exports.Case = Case;
     exports.Catch = Catch;
     exports.Class = Class;
+    exports.CloseAngleBracket = CloseAngleBracket;
     exports.CloseBrace = CloseBrace;
     exports.CloseBracket = CloseBracket;
     exports.CloseParen = CloseParen;

package/dist/rollup.js

@@ -42,14 +42,46 @@ var fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_typescript = __toESM(require("typescript"));
 var tsvfs = __toESM(require("@typescript/vfs"));
+var import_os = __toESM(require("os"));
 var formatHost = {
   getCurrentDirectory: () => import_typescript.default.sys.getCurrentDirectory(),
   getNewLine: () => import_typescript.default.sys.newLine,
   getCanonicalFileName: import_typescript.default.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
 };
 var isCivet = (id) => /\.civet$/.test(id);
-var isCivetTranspiled = (id) => /\.civet\.(m?)(j|t)s(x?)(\?transform)?$/.test(id);
-var isCivetTranspiledTS = (id) => /\.civet\.(m?)ts(x?)$/.test(id);
+var isCivetTranspiled = (id) => /\.civet\.[jt]sx(\?transform)?$/.test(id);
+var isCivetTranspiledTS = (id) => /\.civet\.tsx$/.test(id);
+var postfixRE = /(\.[jt]sx)?[?#].*$/s;
+var isWindows = import_os.default.platform() === "win32";
+var windowsSlashRE = /\\/g;
+function cleanCivetId(id) {
+  return id.replace(postfixRE, "");
+}
+function tryStatSync(file) {
+  try {
+    return fs.statSync(file, { throwIfNoEntry: false });
+  } catch {
+    return void 0;
+  }
+}
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+  return import_path.default.posix.normalize(isWindows ? slash(id) : id);
+}
+function tryFsResolve(file) {
+  const fileStat = tryStatSync(file);
+  if (fileStat?.isFile())
+    return normalizePath(file);
+  return void 0;
+}
+function resolveAbsolutePath(rootDir, id) {
+  const resolved = tryFsResolve(import_path.default.join(rootDir, id));
+  if (!resolved)
+    return tryFsResolve(id);
+  return resolved;
+}
 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`.");
@@ -62,7 +94,7 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
   let fsMap = /* @__PURE__ */ new Map();
   const sourceMaps = /* @__PURE__ */ new Map();
   let compilerOptions;
-  let rootDir;
+  let rootDir = process.cwd();
   return {
     name: "unplugin-civet",
     enforce: "pre",
@@ -162,10 +194,11 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
         return null;
       if (!isCivet(id) && !isCivetTranspiled(id))
         return null;
-      const absolutePath = rootDir != null && import_path.default.isAbsolute(id) ? import_path.default.join(rootDir, id) : import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
+      id = cleanCivetId(id);
+      const absolutePath = import_path.default.isAbsolute(id) ? resolveAbsolutePath(rootDir, id) : import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
+      if (!absolutePath)
+        return null;
       const relativeId = import_path.default.relative(process.cwd(), absolutePath);
-      if (isCivetTranspiled(id))
-        return relativeId.replace(/\?transform$/, "");
       const relativePath = relativeId + outExt;
       return relativePath;
     },
@@ -206,9 +239,9 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
       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);
+        const slashed = slash(resolved);
+        if (resolved !== slashed)
+          fsMap.set(slashed, code);
       }
       return null;
     },

package/dist/unplugin-shared.mjs

@@ -11,14 +11,46 @@ import * as fs from "fs";
 import path from "path";
 import ts from "typescript";
 import * as tsvfs from "@typescript/vfs";
+import os from "os";
 var formatHost = {
   getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
   getNewLine: () => ts.sys.newLine,
   getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
 };
 var isCivet = (id) => /\.civet$/.test(id);
-var isCivetTranspiled = (id) => /\.civet\.(m?)(j|t)s(x?)(\?transform)?$/.test(id);
-var isCivetTranspiledTS = (id) => /\.civet\.(m?)ts(x?)$/.test(id);
+var isCivetTranspiled = (id) => /\.civet\.[jt]sx(\?transform)?$/.test(id);
+var isCivetTranspiledTS = (id) => /\.civet\.tsx$/.test(id);
+var postfixRE = /(\.[jt]sx)?[?#].*$/s;
+var isWindows = os.platform() === "win32";
+var windowsSlashRE = /\\/g;
+function cleanCivetId(id) {
+  return id.replace(postfixRE, "");
+}
+function tryStatSync(file) {
+  try {
+    return fs.statSync(file, { throwIfNoEntry: false });
+  } catch {
+    return void 0;
+  }
+}
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+  return path.posix.normalize(isWindows ? slash(id) : id);
+}
+function tryFsResolve(file) {
+  const fileStat = tryStatSync(file);
+  if (fileStat?.isFile())
+    return normalizePath(file);
+  return void 0;
+}
+function resolveAbsolutePath(rootDir, id) {
+  const resolved = tryFsResolve(path.join(rootDir, id));
+  if (!resolved)
+    return tryFsResolve(id);
+  return resolved;
+}
 var civetUnplugin = createUnplugin((options = {}) => {
   if (options.dts && options.js) {
     throw new Error("Can't have both `dts` and `js` be set to `true`.");
@@ -31,7 +63,7 @@ var civetUnplugin = createUnplugin((options = {}) => {
   let fsMap = /* @__PURE__ */ new Map();
   const sourceMaps = /* @__PURE__ */ new Map();
   let compilerOptions;
-  let rootDir;
+  let rootDir = process.cwd();
   return {
     name: "unplugin-civet",
     enforce: "pre",
@@ -131,10 +163,11 @@ var civetUnplugin = createUnplugin((options = {}) => {
         return null;
       if (!isCivet(id) && !isCivetTranspiled(id))
         return null;
-      const absolutePath = rootDir != null && path.isAbsolute(id) ? path.join(rootDir, id) : path.resolve(path.dirname(importer ?? ""), id);
+      id = cleanCivetId(id);
+      const absolutePath = path.isAbsolute(id) ? resolveAbsolutePath(rootDir, id) : path.resolve(path.dirname(importer ?? ""), id);
+      if (!absolutePath)
+        return null;
       const relativeId = path.relative(process.cwd(), absolutePath);
-      if (isCivetTranspiled(id))
-        return relativeId.replace(/\?transform$/, "");
       const relativePath = relativeId + outExt;
       return relativePath;
     },
@@ -175,9 +208,9 @@ var civetUnplugin = createUnplugin((options = {}) => {
       if (options.dts || options.typecheck) {
         const resolved = path.resolve(process.cwd(), id);
         fsMap.set(resolved, code);
-        const slash = resolved.replace(/\\/g, "/");
-        if (resolved !== slash)
-          fsMap.set(slash, code);
+        const slashed = slash(resolved);
+        if (resolved !== slashed)
+          fsMap.set(slashed, code);
       }
       return null;
     },
@@ -218,5 +251,6 @@ var civetUnplugin = createUnplugin((options = {}) => {
 var src_default = civetUnplugin;
 
 export {
+  slash,
   src_default
 };

package/dist/unplugin.d.mts

@@ -13,6 +13,7 @@ type PluginOptions = {
     typecheck?: true;
     js?: false;
 });
+declare function slash(p: string): string;
 declare const civetUnplugin: unplugin.UnpluginInstance<PluginOptions, boolean>;
 
-export { PluginOptions, civetUnplugin as default };
+export { PluginOptions, civetUnplugin as default, slash };

package/dist/unplugin.d.ts

@@ -13,6 +13,7 @@ type PluginOptions = {
     typecheck?: true;
     js?: false;
 });
+declare function slash(p: string): string;
 declare const civetUnplugin: unplugin.UnpluginInstance<PluginOptions, boolean>;
 
-export { PluginOptions, civetUnplugin as default };
+export { PluginOptions, civetUnplugin as default, slash };